diff --git a/Config.ini b/Config.ini
new file mode 100644
index 00000000..2015654c
--- /dev/null
+++ b/Config.ini
@@ -0,0 +1,389 @@
+;-------------------
+[System]
+
+; リリースバージョン
+; Release Version.
+Version=1.5.7
+
+; 譜面ファイルが格納されているフォルダへのパス。
+; セミコロン(;)で区切ることにより複数のパスを指定できます。（例: d:\tja\;e:\tja2\）
+; Pathes for TJA data.
+; You can specify many pathes separated with semicolon(;). (e.g. d:\tja\;e:\tja2\)
+TJAPath=.\
+
+; 使用するSkinのフォルダ名。
+; 例えば System\Default\Graphics\... などの場合は、SkinPath=.\Default\ を指定します。
+; Skin folder path.
+; e.g. System\Default\Graphics\... -> Set SkinPath=.\Default\
+SkinPath=SimpleStyle\
+
+; 事前画像描画機能を使うかどうか。(0: OFF, 1: ON)
+; Use pre-textures render.
+FastRender=1
+
+; 画面モード(0:ウィンドウ, 1:全画面)
+; Screen mode. (0:Window, 1:Fullscreen)
+FullScreen=0
+
+; ウインドウモード時の画面幅
+; A width size in the window mode.
+WindowWidth=1280
+
+; ウインドウモード時の画面高さ
+; A height size in the window mode.
+WindowHeight=720
+
+; ウィンドウモード時の位置X
+; X position in the window mode.
+WindowX=310
+
+; ウィンドウモード時の位置Y
+; Y position in the window mode.
+WindowY=152
+
+; ウインドウをダブルクリックした時にフルスクリーンに移行するか(0:移行しない,1:移行する)
+; Whether double click to go full screen mode or not.(0:No, 1:Yes)
+DoubleClickFullScreen=1
+
+; ALT+SPACEのメニュー表示を抑制するかどうか(0:抑制する 1:抑制しない)
+; Whether ALT+SPACE menu would be masked or not.(0=masked 1=not masked)
+EnableSystemMenu=1
+
+; 非フォーカス時のsleep値[ms]
+; A sleep time[ms] while the window is inactive.
+BackSleep=1
+
+; フォントレンダリングに使用するフォント名
+; Font name used for font rendering.
+FontName=FOT-大江戸勘亭流 Std E
+
+; 垂直帰線同期(0:OFF,1:ON)
+VSyncWait=1
+
+; フレーム毎のsleep値[ms] (-1でスリープ無し, 0以上で毎フレームスリープ。動画キャプチャ等で活用下さい)
+; A sleep time[ms] per frame.
+SleepTimePerFrame=-1
+
+; サウンド出力方式(0=ACM(って今はまだDirectSoundですが), 1=ASIO, 2=WASAPI)
+; WASAPIはVista以降のOSで使用可能。推奨方式はWASAPI。
+; なお、WASAPIが使用不可ならASIOを、ASIOが使用不可ならACMを使用します。
+; Sound device type(0=ACM, 1=ASIO, 2=WASAPI)
+; WASAPI can use on Vista or later OSs.
+; If WASAPI is not available, DTXMania try to use ASIO. If ASIO can't be used, ACM is used.
+SoundDeviceType=2
+
+; WASAPI使用時のサウンドバッファサイズ
+; (0=デバイスに設定されている値を使用, 1〜9999=バッファサイズ(単位:ms)の手動指定
+; WASAPI Sound Buffer Size.
+; (0=Use system default buffer size, 1-9999=specify the buffer size(ms) by yourself)
+WASAPIBufferSizeMs=50
+
+; ASIO使用時のサウンドデバイス
+; 存在しないデバイスを指定すると、DTXManiaが起動しないことがあります。
+; Sound device used by ASIO.
+; Don't specify unconnected device, as the DTXMania may not bootup.
+; 0: None
+ASIODevice=0
+
+; WASAPI/ASIO時に使用する演奏タイマーの種類
+; Playback timer used for WASAPI/ASIO
+; (0=FDK Timer, 1=System Timer)
+SoundTimerType=0
+
+; 背景画像の半透明割合(0:透明〜255:不透明)
+; Transparency for background image in playing screen.(0:tranaparent - 255:no transparent)
+BGAlpha=100
+
+; ゲージゼロでSTAGE FAILED (0:OFF, 1:ON)
+StageFailed=1
+
+; AVIの表示(0:OFF, 1:ON)
+AVI=0
+
+; BGAの表示(0:OFF, 1:ON)
+BGA=1
+
+; 動画表示モード( 0:表示しない, 1:背景のみ, 2:窓表示のみ, 3:両方)
+ClipDispType=1
+
+; 曲選択からプレビュー音の再生までのウェイト[ms]
+PreviewSoundWait=1000
+
+; 曲選択からプレビュー画像表示までのウェイト[ms]
+PreviewImageWait=100
+
+; BGM の再生(0:OFF, 1:ON)
+BGMSound=1
+
+; 演奏記録（〜.score.ini）の出力 (0:OFF, 1:ON)
+SaveScoreIni=1
+
+; 最小表示コンボ数
+MinComboDrums=10
+
+; RANDOM SELECT で子BOXを検索対象に含める (0:OFF, 1:ON)
+RandomFromSubBox=1
+
+; 演奏情報を表示する (0:OFF, 1:ON)
+; Showing playing info on the playing screen. (0:OFF, 1:ON)
+ShowDebugStatus=0
+
+; BS1770GAIN によるラウドネスメータの測量を適用する (0:OFF, 1:ON)
+; Apply BS1770GAIN loudness metadata (0:OFF, 1:ON)
+ApplyLoudnessMetadata=1
+
+; BS1770GAIN によるラウドネスメータの目標値 (0). (-100-10)
+; Loudness Target in dB (decibels) relative to full scale (0). (-100-10)
+TargetLoudness=-7.4
+
+; .tjaファイルのSONGVOLヘッダを音源の音量に適用する (0:OFF, 1:ON)
+; Apply SONGVOL (0:OFF, 1:ON)
+ApplySongVol=0
+
+; 効果音の音量 (0-100%)
+; Sound effect level (0-100%)
+SoundEffectLevel=100
+
+; 各ボイス、コンボボイスの音量 (0-100%)
+; Voice level (0-100%)
+VoiceLevel=90
+
+; 選曲画面のプレビュー時の音量 (0-100%)
+; Song preview level (0-100%)
+SongPreviewLevel=80
+
+; ゲーム中の音源の音量 (0-100%)
+; Song playback level (0-100%)
+SongPlaybackLevel=100
+
+; キーボードによる音量変更の増加量、減少量 (1-20)
+; Keyboard sound level increment (1-20)
+KeyboardSoundLevelIncrement=5
+
+; 2P演奏時に叩いた音を左右別々にならすか (0:OFF, 1:ON)
+; Use panning for SE (0:OFF, 1:ON)
+UsePanning=1
+
+; 音源再生前の空白時間 (ms)
+; Blank time before music source to play. (ms)
+MusicPreTimeMs=1000
+
+; ストイックモード(0:OFF, 1:ON)
+; Stoic mode. (0:OFF, 1:ON)
+StoicMode=0
+
+; バッファ入力モード(0:OFF, 1:ON)
+; Using Buffered input (0:OFF, 1:ON)
+BufferedInput=1
+
+; リザルト画像自動保存機能(0:OFF, 1:ON)
+; Set "1" if you'd like to save result screen image automatically
+; when you get hiscore/hiskill.
+AutoResultCapture=0
+
+; Discordに再生中の譜面情報を送信する(0:OFF, 1:ON)
+; Share Playing .tja file infomation on Discord.
+SendDiscordPlayingInformation=1
+
+; 再生速度変更を、ピッチ変更で行うかどうか(0:ピッチ変更, 1:タイムストレッチ
+; (WASAPI/ASIO使用時のみ有効)
+; Set "0" if you'd like to use pitch shift with PlaySpeed.
+; Set "1" for time stretch.
+; (Only available when you're using using WASAPI or ASIO)
+TimeStretch=0
+
+; 動画再生にDirectShowを使用する(0:OFF, 1:ON)
+; 動画再生にDirectShowを使うことによって、再生時の負担を軽減できます。
+; ただし使用時にはセットアップが必要になるのでご注意ください。
+DirectShowMode=0
+
+; 判定タイミング調整(-99〜99)[ms]
+; Revision value to adjust judgment timing.
+InputAdjustTime=11
+
+; 判定ラインの表示位置調整(ドラム, ギター, ベース)(-99〜99)[px]
+; Offset value to adjust displaying judgement line for the drums, guitar and bass.
+JudgeLinePosOffsetDrums=0
+
+; 「また遊んでね」画面(0:OFF, 1:ON)
+EndingAnime=0
+
+;-------------------
+[AutoPlay]
+
+; 自動演奏(0:OFF, 1:ON)
+Taiko=0
+Taiko2P=0
+TaikoAutoRoll=1
+
+;-------------------
+[HitRange]
+
+; Perfect〜Poor とみなされる範囲[ms]
+Perfect=30
+Good=100
+Poor=130
+
+;-------------------
+[Log]
+
+; Log出力(0:OFF, 1:ON)
+OutputLog=1
+
+; 曲データ検索に関するLog出力(0:OFF, 1:ON)
+TraceSongSearch=0
+
+; 画像やサウンドの作成_解放に関するLog出力(0:OFF, 1:ON)
+TraceCreatedDisposed=0
+
+; DTX読み込み詳細に関するLog出力(0:OFF, 1:ON)
+TraceDTXDetails=0
+
+;-------------------
+[PlayOption]
+
+; 各画像の表示設定
+; キャラクター画像を表示する (0:OFF, 1:ON)
+ShowChara=1
+; ダンサー画像を表示する (0:OFF, 1:ON)
+ShowDancer=1
+; ランナー画像を表示する (0:OFF, 1:ON)
+ShowRunner=1
+; モブ画像を表示する (0:OFF, 1:ON)
+ShowMob=1
+; フッター画像 (0:OFF, 1:ON)
+ShowFooter=1
+; ぷちキャラ画像 (0:OFF, 1:ON)
+ShowPuchiChara=1
+
+; DARKモード(0:OFF, 1:HALF, 2:FULL)
+Dark=0
+
+
+; 選曲画面でのタイマーを有効にするかどうか(0:無効,1:有効)
+; Enable countdown in songselect.(0:No, 1:Yes)
+EnableCountDownTimer=1
+
+; ドラムSUDDENモード(0:OFF, 1:ON)
+DrumsSudden=0
+
+; ドラムHIDDENモード(0:OFF, 1:ON)
+DrumsHidden=0
+
+; ドラムチップ非表示モード (0:OFF, 1=SEMI, 2:FULL)
+; Drums chip invisible mode
+DrumsInvisible=0
+
+; ドラムREVERSEモード(0:OFF, 1:ON)
+DrumsReverse=0
+
+; RISKYモード(0:OFF, 1-10)
+; RISKY mode. 0=OFF, 1-10 is the times of misses to be Failed.
+Risky=0
+
+; TIGHTモード(0:OFF, 1:ON)
+; TIGHT mode. 0=OFF, 1=ON
+DrumsTight=0
+
+; ドラム譜面スクロール速度(0:x0.5, 1:x1.0, 2:x1.5,…,1999:x1000.0)
+DrumsScrollSpeed=1
+
+; 演奏速度(5〜40)(→x5/20〜x40/20)
+PlaySpeed=20
+
+; 演奏速度が一倍速であるときのみBGMを再生する(0:OFF, 1:ON)
+PlaySpeedNotEqualOneNoSound=0
+
+; デフォルトで選択される難易度
+DefaultCourse=3
+
+; 譜面分岐のガイド表示(0:OFF, 1:ON)
+BranchGuide=0
+
+; スコア計算方法(0:旧配点, 1:旧筐体配点, 2:新配点)
+ScoreMode=2
+
+; 真打モード (0:OFF, 1:ON)
+; Fixed score mode (0:OFF, 1:ON)
+ShinuchiMode=1
+; 大音符の両手入力待機時間(ms)
+BigNotesWaitTime=50
+
+; 大音符の両手判定(0:OFF, 1:ON)
+BigNotesJudge=0
+
+; NoInfo(0:OFF, 1:ON)
+NoInfo=0
+
+; 譜面分岐のアニメーション(0:7〜14, 1:15)
+BranchAnime=1
+
+; デフォルトの曲ソート(0:絶対パス順, 1:ジャンル名ソートOLD, 2:ジャンル名ソートNEW )
+0:Path, 1:GenreName(AC8〜AC14), 2GenreName(AC15〜)
+DefaultSongSort=2
+
+; RANDOMモード(0:OFF, 1:Random, 2:Mirorr 3:SuperRandom, 4:HyperRandom)
+TaikoRandom=0
+
+; STEALTHモード(0:OFF, 1:ドロン, 2:ステルス)
+TaikoStealth=0
+
+; ゲーム(0:OFF, 1:完走!叩ききりまショー!, 2:完走!叩ききりまショー!(激辛) )
+GameMode=0
+
+
+; 特訓モード時にPgUp/PgDnで何小節飛ばすか
+TokkunSkipMeasures=0
+
+; 特訓モード時にジャンプポイントに飛ばすための時間(ms)
+; 指定ms以内に5回縁を叩きましょう
+TokkunMashInterval=750
+
+; JUST(0:OFF, 1:ON)
+Just=0
+
+; 判定数の表示(0:OFF, 1:ON)
+JudgeCountDisplay=0
+
+; プレイ人数
+PlayerCount=1
+
+;-------------------
+[GUID]
+
+
+;-------------------
+; キーアサイン
+; 項 目：Keyboard → 'K'＋'0'＋キーコード(10進数)
+; Mouse → 'N'＋'0'＋ボタン番号(0〜7)
+; MIDI In → 'M'＋デバイス番号1桁(0〜9,A〜Z)＋ノート番号(10進数)
+; Joystick → 'J'＋デバイス番号1桁(0〜9,A〜Z)＋ 0 ...... Ｘ減少(左)ボタン
+; 1 ...... Ｘ増加(右)ボタン
+; 2 ...... Ｙ減少(上)ボタン
+; 3 ...... Ｙ増加(下)ボタン
+; 4 ...... Ｚ減少(前)ボタン
+; 5 ...... Ｚ増加(後)ボタン
+; 6〜133.. ボタン1〜128
+; これらの項目を 16 個まで指定可能(',' で区切って記述）。
+;
+; 表記例：HH=K044,M042,J16
+; → HiHat を Keyboard の 44 ('Z'), MidiIn#0 の 42, JoyPad#1 の 6(ボタン1) に割当て
+;
+; ※Joystick のデバイス番号とデバイスとの関係は [GUID] セクションに記してあるものが有効。
+;
+
+[DrumsKeyAssign]
+
+LeftRed=K016,K015
+RightRed=K017,K019
+LeftBlue=K028,K013
+RightBlue=K020,K021
+LeftRed2P=K031,K011
+RightRed2P=K022,K023
+LeftBlue2P=K033,K012
+RightBlue2P=K0111,K047
+
+[SystemKeyAssign]
+
+Capture=K065
+
diff --git a/FDK19/FDK19.csproj b/FDK19/FDK19.csproj
new file mode 100644
index 00000000..4cf3c82c
--- /dev/null
+++ b/FDK19/FDK19.csproj
@@ -0,0 +1,205 @@
+ｻｿ
+
+
+ Debug
+ AnyCPU
+ 9.0.21022
+ 2.0
+ {BCD40908-F3E2-4707-BFAA-1DD99DF6357D}
+ Library
+ Properties
+ FDK
+ FDK
+ v4.6.1
+ 512
+ true
+
+
+
+
+
+
+
+
+ 3.5
+
+
+
+ x86
+ bin\x86\Debug\
+ true
+
+
+ false
+ 0219
+ TRACE;TEST_CancelEnterCodeInAltEnter2 TEST_Direct3D9Ex_
+ false
+ full
+ 7.3
+ true
+ false
+
+
+ x86
+ bin\x86\Release\
+ true
+
+
+ true
+ 0219
+ TRACE;TEST_ENGLISH_ TEST_Direct3D9Ex_
+ true
+ 7.3
+ full
+ true
+ false
+
+
+
+ ..\Test\dll\Bass.Net.dll
+ True
+
+
+ False
+ ..\Test\dll\DirectShowLib-2005.dll
+ True
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Form
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ GameWindow.cs
+
+
+ Designer
+
+
+
+
+
+
+
+ 1.3.1.2
+
+
+ 4.2.0
+
+
+ 4.2.0
+
+
+ 4.2.0
+
+
+ 4.2.0
+
+
+ 4.0.13.44
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/FDK19/FDK19.csproj.user b/FDK19/FDK19.csproj.user
new file mode 100644
index 00000000..eb6ef04a
--- /dev/null
+++ b/FDK19/FDK19.csproj.user
@@ -0,0 +1,7 @@
+ｻｿ
+
+
+
+
+
+
\ No newline at end of file
diff --git a/FDK19/Properties/AssemblyInfo.cs b/FDK19/Properties/AssemblyInfo.cs
new file mode 100644
index 00000000..6561304f
--- /dev/null
+++ b/FDK19/Properties/AssemblyInfo.cs
@@ -0,0 +1,39 @@
+ｻｿusing System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Resources;
+
+// 繧｢繧ｻ繝ｳ繝悶Μ縺ｫ髢｢縺吶ｋ荳闊ｬ諠蝣ｱ縺ｯ莉･荳九ｮ螻樊ｧ繧ｻ繝繝医ｒ縺ｨ縺翫＠縺ｦ蛻ｶ蠕｡縺輔ｌ縺ｾ縺吶
+// 繧｢繧ｻ繝ｳ繝悶Μ縺ｫ髢｢騾｣莉倥¢繧峨ｌ縺ｦ縺繧区ュ蝣ｱ繧貞､画峩縺吶ｋ縺ｫ縺ｯ縲
+// 縺薙ｌ繧峨ｮ螻樊ｧ蛟､繧貞､画峩縺励※縺上□縺輔＞縲
+[assembly: AssemblyTitle( "FDK繝ｩ繧､繝悶Λ繝ｪ" )]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct( "FDK繝ｩ繧､繝悶Λ繝ｪ ver.21" )]
+[assembly: AssemblyCopyright( "Copyright(C) 2000-2013 DTXMania Group" )]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+//[assembly: AssemblyKeyName( "FROMsCspContainer" )]
+
+// ComVisible 繧 false 縺ｫ險ｭ螳壹☆繧九→縲√◎縺ｮ蝙九ｯ縺薙ｮ繧｢繧ｻ繝ｳ繝悶Μ蜀縺ｧ COM 繧ｳ繝ｳ繝昴ｼ繝阪Φ繝医°繧
+// 蜿らｧ荳榊庄閭ｽ縺ｫ縺ｪ繧翫∪縺吶COM 縺九ｉ縺薙ｮ繧｢繧ｻ繝ｳ繝悶Μ蜀縺ｮ蝙九↓繧｢繧ｯ繧ｻ繧ｹ縺吶ｋ蝣ｴ蜷医ｯ縲
+// 縺昴ｮ蝙九ｮ ComVisible 螻樊ｧ繧 true 縺ｫ險ｭ螳壹＠縺ｦ縺上□縺輔＞縲
+[assembly: ComVisible(false)]
+
+// 谺｡縺ｮ GUID 縺ｯ縲√％縺ｮ繝励Ο繧ｸ繧ｧ繧ｯ繝医′ COM 縺ｫ蜈ｬ髢九＆繧後ｋ蝣ｴ蜷医ｮ縲》ypelib 縺ｮ ID 縺ｧ縺
+[assembly: Guid("c5f9e698-bec1-4d94-b8a4-3e39b636ccb8")]
+
+// 繧｢繧ｻ繝ｳ繝悶Μ縺ｮ繝舌ｼ繧ｸ繝ｧ繝ｳ諠蝣ｱ縺ｯ縲∽ｻ･荳九ｮ 4 縺､縺ｮ蛟､縺ｧ讒区舌＆繧後※縺縺ｾ縺:
+//
+// Major Version
+// Minor Version
+// Build Number
+// Revision
+//
+// 縺吶∋縺ｦ縺ｮ蛟､繧呈欠螳壹☆繧九°縲∽ｸ九ｮ繧医≧縺ｫ '*' 繧剃ｽｿ縺｣縺ｦ繝薙Ν繝峨♀繧医ｳ繝ｪ繝薙ず繝ｧ繝ｳ逡ｪ蜿ｷ繧
+// 譌｢螳壼､縺ｫ縺吶ｋ縺薙→縺後〒縺阪∪縺:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion( "21.0.0.0" )]
+[assembly: AssemblyFileVersion( "21.0.0.0" )]
+[assembly: NeutralResourcesLanguageAttribute("ja-JP")]
diff --git a/FDK19/packages.config b/FDK19/packages.config
new file mode 100644
index 00000000..5dd07c98
--- /dev/null
+++ b/FDK19/packages.config
@@ -0,0 +1,11 @@
+ｻｿ
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/FDK19/繧ｳ繝ｼ繝/00.蜈ｱ騾/CActivity.cs b/FDK19/繧ｳ繝ｼ繝/00.蜈ｱ騾/CActivity.cs
new file mode 100644
index 00000000..6afd9ae7
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/00.蜈ｱ騾/CActivity.cs
@@ -0,0 +1,176 @@
+ｻｿusing System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace FDK
+{
+ public class CActivity
+ {
+ // 繝励Ο繝代ユ繧｣
+
+ public bool b豢ｻ諤ｧ蛹悶＠縺ｦ繧 { get; private set; }
+ public bool b豢ｻ諤ｧ蛹悶＠縺ｦ縺ｪ縺
+ {
+ get
+ {
+ return !this.b豢ｻ諤ｧ蛹悶＠縺ｦ繧;
+ }
+ set
+ {
+ this.b豢ｻ諤ｧ蛹悶＠縺ｦ繧 = !value;
+ }
+ }
+ public List list蟄植ctivities;
+
+ ///
+ /// 蛻昴ａ縺ｦ On騾ｲ陦梧緒逕ｻ() 繧貞他縺ｳ蜃ｺ縺吝ｴ蜷医↓ true 繧堤､ｺ縺吶ゑｼOn豢ｻ諤ｧ蛹() 蜀縺ｧ true 縺ｫ繧ｻ繝繝医＆繧後ｋ縲ゑｼ
+ /// 縺薙ｮ繝輔Λ繧ｰ縺ｯ縲＾n豢ｻ諤ｧ蛹() 縺ｧ縺ｯ陦後∴縺ｪ縺繧ｿ繧､繝溘Φ繧ｰ縺ｮ繧ｷ繝薙い縺ｪ蛻晄悄蛹悶ｒ On騾ｲ陦梧緒逕ｻ() 縺ｧ陦後≧縺溘ａ縺ｫ貅門ｙ縺輔ｌ縺ｦ縺繧九ょ茜逕ｨ縺ｯ蠢鬆医〒縺ｯ縺ｪ縺縲
+ /// On騾ｲ陦梧緒逕ｻ() 蛛ｴ縺ｧ縺ｯ縲∝ｿ隕√↑蛻晄悄蛹悶ｒ霑ｽ縺医◆繧 false 繧偵そ繝繝医☆繧九％縺ｨ縲
+ ///
+ protected bool b蛻昴ａ縺ｦ縺ｮ騾ｲ陦梧緒逕ｻ = true;
+
+
+ // 繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ
+
+ public CActivity()
+ {
+ this.b豢ｻ諤ｧ蛹悶＠縺ｦ縺ｪ縺 = true;
+ this.list蟄植ctivities = new List();
+ }
+
+
+ // 繝ｩ繧､繝輔し繧､繧ｯ繝ｫ繝｡繧ｽ繝繝
+
+ #region [ 蟄舌け繝ｩ繧ｹ縺ｧ蠢隕√↑繧ゅｮ縺ｮ縺ｿ override 縺吶ｋ縺薙→縲]
+ //-----------------
+
+ public virtual void On豢ｻ諤ｧ蛹()
+ {
+ // 縺吶〒縺ｫ豢ｻ諤ｧ蛹悶＠縺ｦ繧九↑繧我ｽ輔ｂ縺励↑縺縲
+ if( this.b豢ｻ諤ｧ蛹悶＠縺ｦ繧 )
+ return;
+
+ this.b豢ｻ諤ｧ蛹悶＠縺ｦ繧 = true; // 縺薙ｮ繝輔Λ繧ｰ縺ｯ縲∽ｻ･荳九ｮ蜃ｦ逅繧偵☆繧句燕縺ｫ繧ｻ繝繝医☆繧九
+
+ // 閾ｪ霄ｫ縺ｮ繝ｪ繧ｽ繝ｼ繧ｹ繧剃ｽ懈舌☆繧九
+ this.OnManaged繝ｪ繧ｽ繝ｼ繧ｹ縺ｮ菴懈();
+ this.OnUnmanaged繝ｪ繧ｽ繝ｼ繧ｹ縺ｮ菴懈();
+
+ // 縺吶∋縺ｦ縺ｮ蟄 Activity 繧呈ｴｻ諤ｧ蛹悶☆繧九
+ foreach( CActivity activity in this.list蟄植ctivities )
+ activity.On豢ｻ諤ｧ蛹();
+
+ // 縺昴ｮ莉悶ｮ蛻晄悄蛹
+ this.b蛻昴ａ縺ｦ縺ｮ騾ｲ陦梧緒逕ｻ = true;
+ }
+ public virtual void On髱樊ｴｻ諤ｧ蛹()
+ {
+ // 豢ｻ諤ｧ蛹悶＠縺ｦ縺ｪ縺縺ｪ繧我ｽ輔ｂ縺励↑縺縲
+ if( this.b豢ｻ諤ｧ蛹悶＠縺ｦ縺ｪ縺 )
+ return;
+
+ // 閾ｪ霄ｫ縺ｮ繝ｪ繧ｽ繝ｼ繧ｹ繧定ｧ｣謾ｾ縺吶ｋ縲
+ this.OnUnmanaged繝ｪ繧ｽ繝ｼ繧ｹ縺ｮ隗｣謾ｾ();
+ this.OnManaged繝ｪ繧ｽ繝ｼ繧ｹ縺ｮ隗｣謾ｾ();
+
+ // 縺吶∋縺ｦ縺ｮ 蟄植ctivity 繧帝撼豢ｻ諤ｧ蛹悶☆繧九
+ foreach( CActivity activity in this.list蟄植ctivities )
+ activity.On髱樊ｴｻ諤ｧ蛹();
+
+ this.b豢ｻ諤ｧ蛹悶＠縺ｦ縺ｪ縺 = true; // 縺薙ｮ繝輔Λ繧ｰ縺ｯ縲∽ｻ･荳翫ｮ繝｡繧ｽ繝繝峨ｒ蜻ｼ縺ｳ蜃ｺ縺励◆蠕後↓繧ｻ繝繝医☆繧九
+ }
+
+ ///
+ /// Managed 繝ｪ繧ｽ繝ｼ繧ｹ縺ｮ菴懈舌ｒ陦後≧縲
+ /// Direct3D 繝繝舌う繧ｹ縺御ｽ懈舌＆繧後◆逶ｴ蠕後↓蜻ｼ縺ｳ蜃ｺ縺輔ｌ繧九ｮ縺ｧ縲∬ｪ蛻縺梧ｴｻ諤ｧ蛹悶＠縺ｦ縺繧区凾縺ｫ髯舌ｊ縲
+ /// Managed 繝ｪ繧ｽ繝ｼ繧ｹ繧剃ｽ懈撰ｼ医∪縺溘ｯ蜀肴ｧ狗ｯ会ｼ峨☆繧九％縺ｨ縲
+ /// 縺縺､縺ｩ縺ｮ繧ｿ繧､繝溘Φ繧ｰ縺ｧ蜻ｼ縺ｳ蜃ｺ縺輔ｌ繧九°ｼ医＞縺､Direct3D縺悟堺ｽ懈舌＆繧後ｋ縺具ｼ牙縺九ｉ縺ｪ縺縺ｮ縺ｧ縲
+ /// 縺縺､菴墓凾蜻ｼ縺ｳ蜃ｺ縺輔ｌ縺ｦ繧ょ撫鬘檎┌縺繧医≧縺ｫ繧ｳ繝ｼ繝繧｣繝ｳ繧ｰ縺励※縺翫￥縺薙→縲
+ ///
+ public virtual void OnManaged繝ｪ繧ｽ繝ｼ繧ｹ縺ｮ菴懈()
+ {
+ // 豢ｻ諤ｧ蛹悶＠縺ｦ縺ｪ縺縺ｪ繧我ｽ輔ｂ縺励↑縺縲
+ if( this.b豢ｻ諤ｧ蛹悶＠縺ｦ縺ｪ縺 )
+ return;
+
+ // 縺吶∋縺ｦ縺ｮ 蟄植ctivity 縺ｮ Managed 繝ｪ繧ｽ繝ｼ繧ｹ繧剃ｽ懈舌☆繧九
+ foreach( CActivity activity in this.list蟄植ctivities )
+ activity.OnManaged繝ｪ繧ｽ繝ｼ繧ｹ縺ｮ菴懈();
+ }
+
+ ///
+ /// Unmanaged 繝ｪ繧ｽ繝ｼ繧ｹ縺ｮ菴懈舌ｒ陦後≧縲
+ /// Direct3D 繝繝舌う繧ｹ縺御ｽ懈舌∪縺溘ｯ繝ｪ繧ｻ繝繝医＆繧後◆逶ｴ蠕後↓蜻ｼ縺ｳ蜃ｺ縺輔ｌ繧九ｮ縺ｧ縲∬ｪ蛻縺梧ｴｻ諤ｧ蛹悶＠縺ｦ縺繧区凾縺ｫ髯舌ｊ縲
+ /// Unmanaged 繝ｪ繧ｽ繝ｼ繧ｹ繧剃ｽ懈撰ｼ医∪縺溘ｯ蜀肴ｧ狗ｯ会ｼ峨☆繧九％縺ｨ縲
+ /// 縺縺､縺ｩ縺ｮ繧ｿ繧､繝溘Φ繧ｰ縺ｧ蜻ｼ縺ｳ蜃ｺ縺輔ｌ繧九°ｼ医＞縺､Direct3D縺悟堺ｽ懈舌∪縺溘ｯ繝ｪ繧ｻ繝繝医＆繧後ｋ縺具ｼ牙縺九ｉ縺ｪ縺縺ｮ縺ｧ縲
+ /// 縺縺､菴墓凾蜻ｼ縺ｳ蜃ｺ縺輔ｌ縺ｦ繧ょ撫鬘檎┌縺繧医≧縺ｫ繧ｳ繝ｼ繝繧｣繝ｳ繧ｰ縺励※縺翫￥縺薙→縲
+ ///
+ public virtual void OnUnmanaged繝ｪ繧ｽ繝ｼ繧ｹ縺ｮ菴懈()
+ {
+ // 豢ｻ諤ｧ蛹悶＠縺ｦ縺ｪ縺縺ｪ繧我ｽ輔ｂ縺励↑縺縲
+ if( this.b豢ｻ諤ｧ蛹悶＠縺ｦ縺ｪ縺 )
+ return;
+
+ // 縺吶∋縺ｦ縺ｮ 蟄植ctivity 縺ｮ Unmanaged 繝ｪ繧ｽ繝ｼ繧ｹ繧剃ｽ懈舌☆繧九
+ foreach( CActivity activity in this.list蟄植ctivities )
+ activity.OnUnmanaged繝ｪ繧ｽ繝ｼ繧ｹ縺ｮ菴懈();
+ }
+
+ ///
+ /// Unmanaged 繝ｪ繧ｽ繝ｼ繧ｹ縺ｮ隗｣謾ｾ繧定｡後≧縲
+ /// Direct3D 繝繝舌う繧ｹ縺ｮ隗｣謾ｾ逶ｴ蜑阪∪縺溘ｯ繝ｪ繧ｻ繝繝育峩蜑阪↓蜻ｼ縺ｳ蜃ｺ縺輔ｌ繧九
+ /// 縺縺､縺ｩ縺ｮ繧ｿ繧､繝溘Φ繧ｰ縺ｧ蜻ｼ縺ｳ蜃ｺ縺輔ｌ繧九°ｼ医＞縺､Direct3D縺瑚ｧ｣謾ｾ縺ｾ縺溘ｯ繝ｪ繧ｻ繝繝医＆繧後ｋ縺具ｼ牙縺九ｉ縺ｪ縺縺ｮ縺ｧ縲
+ /// 縺縺､菴墓凾蜻ｼ縺ｳ蜃ｺ縺輔ｌ縺ｦ繧ょ撫鬘檎┌縺繧医≧縺ｫ繧ｳ繝ｼ繝繧｣繝ｳ繧ｰ縺励※縺翫￥縺薙→縲
+ ///
+ public virtual void OnUnmanaged繝ｪ繧ｽ繝ｼ繧ｹ縺ｮ隗｣謾ｾ()
+ {
+ // 豢ｻ諤ｧ蛹悶＠縺ｦ縺ｪ縺縺ｪ繧我ｽ輔ｂ縺励↑縺縲
+ if( this.b豢ｻ諤ｧ蛹悶＠縺ｦ縺ｪ縺 )
+ return;
+
+ // 縺吶∋縺ｦ縺ｮ 蟄植ctivity 縺ｮ Unmanaged 繝ｪ繧ｽ繝ｼ繧ｹ繧定ｧ｣謾ｾ縺吶ｋ縲
+ foreach( CActivity activity in this.list蟄植ctivities )
+ activity.OnUnmanaged繝ｪ繧ｽ繝ｼ繧ｹ縺ｮ隗｣謾ｾ();
+ }
+
+ ///
+ /// Managed 繝ｪ繧ｽ繝ｼ繧ｹ縺ｮ隗｣謾ｾ繧定｡後≧縲
+ /// Direct3D 繝繝舌う繧ｹ縺ｮ隗｣謾ｾ逶ｴ蜑阪↓蜻ｼ縺ｳ蜃ｺ縺輔ｌ繧九
+ /// ｼUnmanaged 繝ｪ繧ｽ繝ｼ繧ｹ縺ｨ縺ｯ逡ｰ縺ｪ繧翫．irect3D 繝繝舌う繧ｹ縺ｮ繝ｪ繧ｻ繝繝域凾縺ｫ縺ｯ蜻ｼ縺ｳ蜃ｺ縺輔ｌ縺ｪ縺縲ゑｼ
+ /// 縺縺､縺ｩ縺ｮ繧ｿ繧､繝溘Φ繧ｰ縺ｧ蜻ｼ縺ｳ蜃ｺ縺輔ｌ繧九°ｼ医＞縺､Direct3D縺瑚ｧ｣謾ｾ縺輔ｌ繧九°ｼ牙縺九ｉ縺ｪ縺縺ｮ縺ｧ縲
+ /// 縺縺､菴墓凾蜻ｼ縺ｳ蜃ｺ縺輔ｌ縺ｦ繧ょ撫鬘檎┌縺繧医≧縺ｫ繧ｳ繝ｼ繝繧｣繝ｳ繧ｰ縺励※縺翫￥縺薙→縲
+ ///
+ public virtual void OnManaged繝ｪ繧ｽ繝ｼ繧ｹ縺ｮ隗｣謾ｾ()
+ {
+ // 豢ｻ諤ｧ蛹悶＠縺ｦ縺ｪ縺縺ｪ繧我ｽ輔ｂ縺励↑縺縲
+ if( this.b豢ｻ諤ｧ蛹悶＠縺ｦ縺ｪ縺 )
+ return;
+
+ // 縺吶∋縺ｦ縺ｮ 蟄植ctivity 縺ｮ Managed 繝ｪ繧ｽ繝ｼ繧ｹ繧定ｧ｣謾ｾ縺吶ｋ縲
+ foreach( CActivity activity in this.list蟄植ctivities )
+ activity.OnManaged繝ｪ繧ｽ繝ｼ繧ｹ縺ｮ隗｣謾ｾ();
+ }
+
+ ///
+ /// 騾ｲ陦後→謠冗判繧定｡後≧縲ゑｼ医％繧後ｉ縺ｯ蛻髮｢縺輔ｌ縺壹√％縺ｮｼ代▽縺ｮ繝｡繧ｽ繝繝峨□縺代〒螳溯｣縺吶ｋ縲ゑｼ
+ /// 縺薙ｮ繝｡繧ｽ繝繝峨ｯ BeginScene() 縺ｮ蠕後↓蜻ｼ縺ｳ蜃ｺ縺輔ｌ繧九ｮ縺ｧ縲√Γ繧ｽ繝繝牙縺ｧ縺縺阪↑繧頑緒逕ｻ繧定｡後▲縺ｦ縺九∪繧上↑縺縲
+ ///
+ /// 莉ｻ諢上ｮ謨ｴ謨ｰ縲ょ他縺ｳ蜃ｺ縺怜縺ｨ縺ｮ謨ｴ蜷域ｧ繧貞粋繧上○縺ｦ縺翫￥縺薙→縲
+ public virtual int On騾ｲ陦梧緒逕ｻ()
+ {
+ // 豢ｻ諤ｧ蛹悶＠縺ｦ縺ｪ縺縺ｪ繧我ｽ輔ｂ縺励↑縺縲
+ if( this.b豢ｻ諤ｧ蛹悶＠縺ｦ縺ｪ縺 )
+ return 0;
+
+
+ /* 縺薙％縺ｧ騾ｲ陦後→謠冗判繧定｡後≧縲*/
+
+
+ // 謌ｻ繧雁､縺ｨ縺昴ｮ諢丞袖縺ｯ蟄舌け繝ｩ繧ｹ縺ｧ閾ｪ逕ｱ縺ｫ豎ｺ繧√※縺縺縲
+ return 0;
+ }
+
+ //-----------------
+ #endregion
+ }
+}
\ No newline at end of file
diff --git a/FDK19/繧ｳ繝ｼ繝/00.蜈ｱ騾/CCounter.cs b/FDK19/繧ｳ繝ｼ繝/00.蜈ｱ騾/CCounter.cs
new file mode 100644
index 00000000..d209aa9d
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/00.蜈ｱ騾/CCounter.cs
@@ -0,0 +1,315 @@
+ｻｿusing System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace FDK
+{
+ ///
+ /// 荳螳夐俣髫斐〒蜊倡ｴ泌｢怜刈縺吶ｋ謨ｴ謨ｰｼ医き繧ｦ繝ｳ繝亥､ｼ峨ｒ謇ｱ縺縲
+ ///
+ ///
+ /// 笳倶ｽｿ縺譁ｹ
+ /// 1.CCounter縺ｮ螟画焚繧偵▽縺上ｋ縲
+ /// 2.CCounter繧堤函謌
+ /// ctCounter = new CCounter( 0, 3, 10, CDTXMania.Timer );
+ /// 3.騾ｲ陦後Γ繧ｽ繝繝峨ｒ菴ｿ逕ｨ縺吶ｋ縲
+ /// 4.繧ｦ繝槭ｼ縲
+ ///
+ /// double蛟､繧剃ｽｿ縺蝣ｴ蜷医》騾ｲ陦慧b縲》騾ｲ陦鍬oopDb繧剃ｽｿ縺縺薙→縲
+ /// 縺ｾ縺溘‥ouble迚医〒縺ｯ髢馴囈縺ｮ蛟､縺ｯ繝溘Μ遘貞腰菴阪〒縺ｯ縺ｪ縺上騾壼ｸｸ縺ｮ遘貞腰菴阪↓縺ｪ繧翫∪縺吶
+ ///
+ public class CCounter
+ {
+ public bool b髢句ｧ九＠縺
+ {
+ get;
+ set;
+ }
+ // 蛟､繝励Ο繝代ユ繧｣
+ public float n髢句ｧ句､
+ {
+ get;
+ private set;
+ }
+ public float n邨ゆｺ蛟､
+ {
+ get;
+ set;
+ }
+ public int n迴ｾ蝨ｨ縺ｮ蛟､
+ {
+ get;
+ set;
+ }
+
+ public double _n髢馴囈
+ {
+ get
+ {
+ return this.n髢馴囈;
+ }
+ set
+ {
+ this.n髢馴囈 = value >= 0 ? value : value * -1;
+ }
+ }
+
+ public float n迴ｾ蝨ｨ縺ｮ邨碁℃譎る俣ms
+ {
+ get;
+ set;
+ }
+ // 迥ｶ諷九励Ο繝代ユ繧｣
+
+ public bool b騾ｲ陦御ｸｭ
+ {
+ get { return (this.n迴ｾ蝨ｨ縺ｮ邨碁℃譎る俣ms != -1); }
+ }
+ public bool b蛛懈ｭ｢荳ｭ
+ {
+ get { return !this.b騾ｲ陦御ｸｭ; }
+ }
+ public bool b邨ゆｺ蛟､縺ｫ驕斐＠縺
+ {
+ get { return (this.n迴ｾ蝨ｨ縺ｮ蛟､ >= this.n邨ゆｺ蛟､); }
+ }
+ public bool b邨ゆｺ蛟､縺ｫ驕斐＠縺ｦ縺ｪ縺
+ {
+ get { return !this.b邨ゆｺ蛟､縺ｫ驕斐＠縺; }
+ }
+
+ // 繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ
+
+ public CCounter()
+ {
+ this.timer = null;
+ this.n髢句ｧ句､ = 0;
+ this.n邨ゆｺ蛟､ = 0;
+ this.n迴ｾ蝨ｨ縺ｮ蛟､ = 0;
+ this.n迴ｾ蝨ｨ縺ｮ蛟､ = 0;
+ this.n迴ｾ蝨ｨ縺ｮ邨碁℃譎る俣ms = CSoundTimer.n譛ｪ菴ｿ逕ｨ;
+ }
+
+ /// 逕滓舌→蜷梧凾縺ｫ髢句ｧ九☆繧九
+ public CCounter(float n髢句ｧ句､, float n邨ゆｺ蛟､, float n髢馴囈ms, CTimer timer)
+ : this()
+ {
+ this.t髢句ｧ(n髢句ｧ句､, n邨ゆｺ蛟､, n髢馴囈ms, timer);
+ }
+
+ /// 逕滓舌→蜷梧凾縺ｫ髢句ｧ九☆繧九(double迚)
+ public CCounter(double db髢句ｧ句､, double db邨ゆｺ蛟､, double db髢馴囈, CSoundTimer timer)
+ : this()
+ {
+ this.t髢句ｧ(db髢句ｧ句､, db邨ゆｺ蛟､, db髢馴囈 * 1000.0f, timer);
+ }
+
+
+ // 迥ｶ諷区桃菴懊Γ繧ｽ繝繝
+
+ ///
+ /// 繧ｫ繧ｦ繝ｳ繝医ｒ髢句ｧ九☆繧九
+ ///
+ /// 譛蛻昴ｮ繧ｫ繧ｦ繝ｳ繝亥､縲
+ /// 譛蠕後ｮ繧ｫ繧ｦ繝ｳ繝亥､縲
+ /// 繧ｫ繧ｦ繝ｳ繝亥､繧抵ｼ大｢怜刈縺輔○繧九ｮ縺ｫ縺九¢繧区凾髢難ｼ医Α繝ｪ遘貞腰菴搾ｼ峨
+ /// 繧ｫ繧ｦ繝ｳ繝医↓菴ｿ逕ｨ縺吶ｋ繧ｿ繧､繝槭
+ public void t髢句ｧ(float n髢句ｧ句､, float n邨ゆｺ蛟､, float n髢馴囈ms, CTimer timer)
+ {
+ this.n髢句ｧ句､ = n髢句ｧ句､;
+ this.n邨ゆｺ蛟､ = n邨ゆｺ蛟､;
+ this._n髢馴囈 = n髢馴囈ms;
+ this.timer = timer;
+ this.n迴ｾ蝨ｨ縺ｮ邨碁℃譎る俣ms = this.timer.n迴ｾ蝨ｨ譎ょ綾;
+ this.n迴ｾ蝨ｨ縺ｮ蛟､ = (int)n髢句ｧ句､;
+ this.b髢句ｧ九＠縺 = true;
+ }
+
+ ///
+ /// 繧ｫ繧ｦ繝ｳ繝医ｒ髢句ｧ九☆繧九(double迚)
+ ///
+ /// 譛蛻昴ｮ繧ｫ繧ｦ繝ｳ繝亥､縲
+ /// 譛蠕後ｮ繧ｫ繧ｦ繝ｳ繝亥､縲
+ /// 繧ｫ繧ｦ繝ｳ繝亥､繧抵ｼ大｢怜刈縺輔○繧九ｮ縺ｫ縺九¢繧区凾髢難ｼ育ｧ貞腰菴搾ｼ峨
+ /// 繧ｫ繧ｦ繝ｳ繝医↓菴ｿ逕ｨ縺吶ｋ繧ｿ繧､繝槭
+ public void t髢句ｧ(double db髢句ｧ句､, double db邨ゆｺ蛟､, double db髢馴囈, CSoundTimer timer)
+ {
+ this.n髢句ｧ句､ = (float)db髢句ｧ句､;
+ this.n邨ゆｺ蛟､ = (float)db邨ゆｺ蛟､;
+ this._n髢馴囈 = db髢馴囈;
+ this.timerdb = timer;
+ this.n迴ｾ蝨ｨ縺ｮ邨碁℃譎る俣ms = (float)this.timerdb.db繧ｷ繧ｹ繝繝譎ょ綾;
+ this.n迴ｾ蝨ｨ縺ｮ蛟､ = (int)db髢句ｧ句､;
+ this.b髢句ｧ九＠縺 = true;
+ }
+
+ ///
+ /// 蜑榊屓縺ｮ t騾ｲ陦() 縺ｮ蜻ｼ縺ｳ蜃ｺ縺励°繧峨ｮ邨碁℃譎る俣繧偵ｂ縺ｨ縺ｫ縲∝ｿ隕√↑縺縺代き繧ｦ繝ｳ繝亥､繧貞｢怜刈縺輔○繧九
+ /// 繧ｫ繧ｦ繝ｳ繝亥､縺檎ｵゆｺ蛟､縺ｫ驕斐＠縺ｦ縺繧句ｴ蜷医ｯ縲√◎繧御ｻ･荳雁｢怜刈縺励↑縺ｼ育ｵゆｺ蛟､繧堤ｶｭ謖√☆繧具ｼ峨
+ ///
+ public void t騾ｲ陦()
+ {
+ if ((this.timer != null) && (this.n迴ｾ蝨ｨ縺ｮ邨碁℃譎る俣ms != CTimer.n譛ｪ菴ｿ逕ｨ))
+ {
+ long num = this.timer.n迴ｾ蝨ｨ譎ょ綾;
+ if (num < this.n迴ｾ蝨ｨ縺ｮ邨碁℃譎る俣ms)
+ this.n迴ｾ蝨ｨ縺ｮ邨碁℃譎る俣ms = num;
+
+ while ((num - this.n迴ｾ蝨ｨ縺ｮ邨碁℃譎る俣ms) >= this.n髢馴囈)
+ {
+ if (++this.n迴ｾ蝨ｨ縺ｮ蛟､ > this.n邨ゆｺ蛟､)
+ this.n迴ｾ蝨ｨ縺ｮ蛟､ = (int)this.n邨ゆｺ蛟､;
+
+ this.n迴ｾ蝨ｨ縺ｮ邨碁℃譎る俣ms += (float)this.n髢馴囈;
+ }
+ }
+ }
+
+ ///
+ /// 蜑榊屓縺ｮ t騾ｲ陦() 縺ｮ蜻ｼ縺ｳ蜃ｺ縺励°繧峨ｮ邨碁℃譎る俣繧偵ｂ縺ｨ縺ｫ縲∝ｿ隕√↑縺縺代き繧ｦ繝ｳ繝亥､繧貞｢怜刈縺輔○繧九
+ /// 繧ｫ繧ｦ繝ｳ繝亥､縺檎ｵゆｺ蛟､縺ｫ驕斐＠縺ｦ縺繧句ｴ蜷医ｯ縲√◎繧御ｻ･荳雁｢怜刈縺励↑縺ｼ育ｵゆｺ蛟､繧堤ｶｭ謖√☆繧具ｼ峨
+ ///
+ public void t騾ｲ陦慧b()
+ {
+ if ((this.timerdb != null) && (this.n迴ｾ蝨ｨ縺ｮ邨碁℃譎る俣ms != CSoundTimer.n譛ｪ菴ｿ逕ｨ))
+ {
+ double num = this.timerdb.n迴ｾ蝨ｨ譎ょ綾;
+ if (num < this.n迴ｾ蝨ｨ縺ｮ邨碁℃譎る俣ms)
+ this.n迴ｾ蝨ｨ縺ｮ邨碁℃譎る俣ms = (float)num;
+
+ while ((num - this.n迴ｾ蝨ｨ縺ｮ邨碁℃譎る俣ms) >= this.n髢馴囈)
+ {
+ if (++this.n迴ｾ蝨ｨ縺ｮ蛟､ > this.n邨ゆｺ蛟､)
+ this.n迴ｾ蝨ｨ縺ｮ蛟､ = (int)this.n邨ゆｺ蛟､;
+
+ this.n迴ｾ蝨ｨ縺ｮ邨碁℃譎る俣ms += (float)this.n髢馴囈;
+ }
+ }
+ }
+
+ ///
+ /// 蜑榊屓縺ｮ t騾ｲ陦鍬oop() 縺ｮ蜻ｼ縺ｳ蜃ｺ縺励°繧峨ｮ邨碁℃譎る俣繧偵ｂ縺ｨ縺ｫ縲∝ｿ隕√↑縺縺代き繧ｦ繝ｳ繝亥､繧貞｢怜刈縺輔○繧九
+ /// 繧ｫ繧ｦ繝ｳ繝亥､縺檎ｵゆｺ蛟､縺ｫ驕斐＠縺ｦ縺繧句ｴ蜷医ｯ縲∵ｬ｡縺ｮ蠅怜刈繧ｿ繧､繝溘Φ繧ｰ縺ｧ髢句ｧ句､縺ｫ謌ｻ繧具ｼ亥､縺後Ν繝ｼ繝励☆繧具ｼ峨
+ ///
+ public void t騾ｲ陦鍬oop()
+ {
+ if ((this.timer != null) && (this.n迴ｾ蝨ｨ縺ｮ邨碁℃譎る俣ms != CTimer.n譛ｪ菴ｿ逕ｨ))
+ {
+ long num = this.timer.n迴ｾ蝨ｨ譎ょ綾;
+ if (num < this.n迴ｾ蝨ｨ縺ｮ邨碁℃譎る俣ms)
+ this.n迴ｾ蝨ｨ縺ｮ邨碁℃譎る俣ms = num;
+
+ while ((num - this.n迴ｾ蝨ｨ縺ｮ邨碁℃譎る俣ms) >= this.n髢馴囈)
+ {
+ if (++this.n迴ｾ蝨ｨ縺ｮ蛟､ > this.n邨ゆｺ蛟､)
+ this.n迴ｾ蝨ｨ縺ｮ蛟､ = (int)this.n髢句ｧ句､;
+
+ this.n迴ｾ蝨ｨ縺ｮ邨碁℃譎る俣ms += (float)this.n髢馴囈;
+ }
+ }
+ }
+
+ ///
+ /// 蜑榊屓縺ｮ t騾ｲ陦鍬oop() 縺ｮ蜻ｼ縺ｳ蜃ｺ縺励°繧峨ｮ邨碁℃譎る俣繧偵ｂ縺ｨ縺ｫ縲∝ｿ隕√↑縺縺代き繧ｦ繝ｳ繝亥､繧貞｢怜刈縺輔○繧九
+ /// 繧ｫ繧ｦ繝ｳ繝亥､縺檎ｵゆｺ蛟､縺ｫ驕斐＠縺ｦ縺繧句ｴ蜷医ｯ縲∵ｬ｡縺ｮ蠅怜刈繧ｿ繧､繝溘Φ繧ｰ縺ｧ髢句ｧ句､縺ｫ謌ｻ繧具ｼ亥､縺後Ν繝ｼ繝励☆繧具ｼ峨
+ ///
+ public void t騾ｲ陦鍬oopDb()
+ {
+ if ((this.timerdb != null) && (this.n迴ｾ蝨ｨ縺ｮ邨碁℃譎る俣ms != CSoundTimer.n譛ｪ菴ｿ逕ｨ))
+ {
+ double num = this.timerdb.n迴ｾ蝨ｨ譎ょ綾;
+ if (num < this.n迴ｾ蝨ｨ縺ｮ邨碁℃譎る俣ms)
+ this.n迴ｾ蝨ｨ縺ｮ邨碁℃譎る俣ms = (float)num;
+
+ while ((num - this.n迴ｾ蝨ｨ縺ｮ邨碁℃譎る俣ms) >= this.n髢馴囈)
+ {
+ if (++this.n迴ｾ蝨ｨ縺ｮ蛟､ > this.n邨ゆｺ蛟､)
+ this.n迴ｾ蝨ｨ縺ｮ蛟､ = (int)this.n髢句ｧ句､;
+
+ this.n迴ｾ蝨ｨ縺ｮ邨碁℃譎る俣ms += (float)this.n髢馴囈;
+ }
+ }
+ }
+
+ ///
+ /// 繧ｫ繧ｦ繝ｳ繝医ｒ蛛懈ｭ｢縺吶ｋ縲
+ /// 縺薙ｌ莉･髯阪↓ t騾ｲ陦() 繧 t騾ｲ陦鍬oop() 繧貞他縺ｳ蜃ｺ縺励※繧ゆｽ輔ｂ蜃ｦ逅縺輔ｌ縺ｪ縺縲
+ ///
+ public void t蛛懈ｭ｢()
+ {
+ this.n迴ｾ蝨ｨ縺ｮ邨碁℃譎る俣ms = CTimer.n譛ｪ菴ｿ逕ｨ;
+ }
+
+ public void t髢馴囈蛟､螟画峩(double Value)
+ {
+ this._n髢馴囈 = Value;
+ }
+
+ // 縺昴ｮ莉
+
+ #region [ 蠢懃畑ｼ壹く繝ｼ縺ｮ蜿榊ｾｩ蜈･蜉帙ｒ繧ｨ繝溘Η繝ｬ繝ｼ繧ｷ繝ｧ繝ｳ縺吶ｋ ]
+ //-----------------
+
+ ///
+ /// 縲恵繧ｭ繝ｼ謚ｼ荳九榊ｼ墓焚縺 true 縺ｮ髢謎ｸｭ縲√荊繧ｭ繝ｼ蜃ｦ逅縲阪ョ繝ｪ繧ｲ繝ｼ繝亥ｼ墓焚繧貞他縺ｳ蜃ｺ縺吶
+ /// 縺溘□縺励2蝗樒岼縺ｮ蜻ｼ縺ｳ蜃ｺ縺励ｯ1蝗樒岼縺九ｉ 200ms 縺ｮ髢薙ｒ髢九¢縺ｦ縺九ｉ陦後＞縲3蝗樒岼莉･髯阪ｮ蜻ｼ縺ｳ蜃ｺ縺励ｯ縺昴ｌ縺槭ｌ 30ms 縺ｮ髢馴囈縺ｧ蜻ｼ縺ｳ蜃ｺ縺吶
+ /// 縲恵繧ｭ繝ｼ謚ｼ荳九阪′ false 縺ｮ蝣ｴ蜷医ｯ菴輔ｂ縺帙★縲∝他縺ｳ蜃ｺ縺怜屓謨ｰ繧 0 縺ｫ繝ｪ繧ｻ繝繝医☆繧九
+ ///
+ /// 繧ｭ繝ｼ縺梧款荳九＆繧後※縺繧句ｴ蜷医ｯ true縲
+ /// 繧ｭ繝ｼ縺梧款荳九＆繧後※縺繧句ｴ蜷医↓螳溯｡後☆繧句ｦ逅縲
+ public void t繧ｭ繝ｼ蜿榊ｾｩ(bool b繧ｭ繝ｼ謚ｼ荳, DG繧ｭ繝ｼ蜃ｦ逅 t繧ｭ繝ｼ蜃ｦ逅)
+ {
+ const int n1蝗樒岼 = 0;
+ const int n2蝗樒岼 = 1;
+ const int n3蝗樒岼莉･髯 = 2;
+
+ if (b繧ｭ繝ｼ謚ｼ荳)
+ {
+ switch (this.n迴ｾ蝨ｨ縺ｮ蛟､)
+ {
+ case n1蝗樒岼:
+
+ t繧ｭ繝ｼ蜃ｦ逅();
+ this.n迴ｾ蝨ｨ縺ｮ蛟､ = n2蝗樒岼;
+ this.n迴ｾ蝨ｨ縺ｮ邨碁℃譎る俣ms = this.timer.n迴ｾ蝨ｨ譎ょ綾;
+ return;
+
+ case n2蝗樒岼:
+
+ if ((this.timer.n迴ｾ蝨ｨ譎ょ綾 - this.n迴ｾ蝨ｨ縺ｮ邨碁℃譎る俣ms) > 200)
+ {
+ t繧ｭ繝ｼ蜃ｦ逅();
+ this.n迴ｾ蝨ｨ縺ｮ邨碁℃譎る俣ms = this.timer.n迴ｾ蝨ｨ譎ょ綾;
+ this.n迴ｾ蝨ｨ縺ｮ蛟､ = n3蝗樒岼莉･髯;
+ }
+ return;
+
+ case n3蝗樒岼莉･髯:
+
+ if ((this.timer.n迴ｾ蝨ｨ譎ょ綾 - this.n迴ｾ蝨ｨ縺ｮ邨碁℃譎る俣ms) > 30)
+ {
+ t繧ｭ繝ｼ蜃ｦ逅();
+ this.n迴ｾ蝨ｨ縺ｮ邨碁℃譎る俣ms = this.timer.n迴ｾ蝨ｨ譎ょ綾;
+ }
+ return;
+ }
+ }
+ else
+ {
+ this.n迴ｾ蝨ｨ縺ｮ蛟､ = n1蝗樒岼;
+ }
+ }
+ public delegate void DG繧ｭ繝ｼ蜃ｦ逅();
+
+ //-----------------
+ #endregion
+
+ #region [ private ]
+ //-----------------
+ private CTimer timer;
+ private CSoundTimer timerdb;
+ private double n髢馴囈;
+ //-----------------
+ #endregion
+ }
+}
diff --git a/FDK19/繧ｳ繝ｼ繝/00.蜈ｱ騾/CCpuCores.cs b/FDK19/繧ｳ繝ｼ繝/00.蜈ｱ騾/CCpuCores.cs
new file mode 100644
index 00000000..02ecccfc
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/00.蜈ｱ騾/CCpuCores.cs
@@ -0,0 +1,26 @@
+ｻｿusing System;
+using System.Collections.Generic;
+using System.Text;
+using System.Runtime.InteropServices;
+
+namespace FDK
+{
+ public static class CpuCores
+ {
+ [DllImport("kernel32")]
+ public static extern void GetSystemInfo(ref SYSTEM_INFO ptmpsi);
+ [StructLayout(LayoutKind.Sequential)]
+ public struct SYSTEM_INFO {
+ public uint dwOemId;
+ public uint dwPageSize;
+ public uint lpMinimumApplicationAddress;
+ public uint lpMaximumApplicationAddress;
+ public uint dwActiveProcessorMask;
+ public uint dwNumberOfProcessors;
+ public uint dwProcessorType;
+ public uint dwAllocationGranularity;
+ public uint dwProcessorLevel;
+ public uint dwProcessorRevision;
+ }
+ }
+}
diff --git a/FDK19/繧ｳ繝ｼ繝/00.蜈ｱ騾/CFPS.cs b/FDK19/繧ｳ繝ｼ繝/00.蜈ｱ騾/CFPS.cs
new file mode 100644
index 00000000..1d67b950
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/00.蜈ｱ騾/CFPS.cs
@@ -0,0 +1,64 @@
+ｻｿusing System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace FDK
+{
+ public class CFPS
+ {
+ // 繝励Ο繝代ユ繧｣
+
+ public int n迴ｾ蝨ｨ縺ｮFPS
+ {
+ get;
+ private set;
+ }
+ public bool bFPS縺ｮ蛟､縺悟､牙喧縺励◆
+ {
+ get;
+ private set;
+ }
+
+
+ // 繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ
+
+ public CFPS()
+ {
+ this.n迴ｾ蝨ｨ縺ｮFPS = 0;
+ this.timer = new CTimer( CTimer.E遞ｮ蛻･.MultiMedia );
+ this.蝓ｺ轤ｹ譎ょ綾ms = this.timer.n迴ｾ蝨ｨ譎ょ綾;
+ this.蜀驛ｨFPS = 0;
+ this.bFPS縺ｮ蛟､縺悟､牙喧縺励◆ = false;
+ }
+
+
+ // 繝｡繧ｽ繝繝
+
+ public void t繧ｫ繧ｦ繝ｳ繧ｿ譖ｴ譁ｰ()
+ {
+ this.timer.t譖ｴ譁ｰ();
+ this.bFPS縺ｮ蛟､縺悟､牙喧縺励◆ = false;
+
+ const long INTERVAL = 1000;
+ while( ( this.timer.n迴ｾ蝨ｨ譎ょ綾 - this.蝓ｺ轤ｹ譎ょ綾ms ) >= INTERVAL )
+ {
+ this.n迴ｾ蝨ｨ縺ｮFPS = this.蜀驛ｨFPS;
+ this.蜀驛ｨFPS = 0;
+ this.bFPS縺ｮ蛟､縺悟､牙喧縺励◆ = true;
+ this.蝓ｺ轤ｹ譎ょ綾ms += INTERVAL;
+ }
+ this.蜀驛ｨFPS++;
+ }
+
+
+ // 縺昴ｮ莉
+
+ #region [ private ]
+ //-----------------
+ private CTimer timer;
+ private long 蝓ｺ轤ｹ譎ょ綾ms;
+ private int 蜀驛ｨFPS;
+ //-----------------
+ #endregion
+ }
+}
diff --git a/FDK19/繧ｳ繝ｼ繝/00.蜈ｱ騾/CIniFile.cs b/FDK19/繧ｳ繝ｼ繝/00.蜈ｱ騾/CIniFile.cs
new file mode 100644
index 00000000..a6422a6c
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/00.蜈ｱ騾/CIniFile.cs
@@ -0,0 +1,134 @@
+ｻｿusing System;
+using System.Collections.Generic;
+using System.Text;
+using System.IO;
+using System.Diagnostics;
+
+namespace FDK
+{
+ ///
+ /// 豎守畑逧縺ｪ .ini繝輔ぃ繧､繝ｫ繧呈桶縺縲
+ ///
+ public class CIniFile
+ {
+ // 繝励Ο繝代ユ繧｣
+
+ public string str繝輔ぃ繧､繝ｫ蜷
+ {
+ get;
+ private set;
+ }
+ public List Sections
+ {
+ get;
+ set;
+ }
+ public class CSection
+ {
+ public string str繧ｻ繧ｯ繧ｷ繝ｧ繝ｳ蜷 = "";
+ public List> list繝代Λ繝｡繝ｼ繧ｿ繝ｪ繧ｹ繝 = new List>();
+ }
+
+
+ // 繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ
+
+ public CIniFile()
+ {
+ this.str繝輔ぃ繧､繝ｫ蜷 = "";
+ this.Sections = new List();
+ }
+ public CIniFile( string str繝輔ぃ繧､繝ｫ蜷 )
+ :this()
+ {
+ this.t隱ｭ縺ｿ霎ｼ縺ｿ( str繝輔ぃ繧､繝ｫ蜷 );
+ }
+
+
+ // 繝｡繧ｽ繝繝
+
+ public void t隱ｭ縺ｿ霎ｼ縺ｿ( string str繝輔ぃ繧､繝ｫ蜷 )
+ {
+ this.str繝輔ぃ繧､繝ｫ蜷 = str繝輔ぃ繧､繝ｫ蜷;
+
+ StreamReader sr = null;
+ CSection section = null;
+ try
+ {
+ sr = new StreamReader( this.str繝輔ぃ繧､繝ｫ蜷, Encoding.GetEncoding( "Shift_JIS" ) ); // 繝輔ぃ繧､繝ｫ縺悟ｭ伜惠縺励↑縺蝣ｴ蜷医ｯ萓句､也匱逕溘
+
+ string line;
+ while( ( line = sr.ReadLine() ) != null )
+ {
+ line = line.Replace( '\t', ' ' ).TrimStart( new char[] { '\t', ' ' } );
+ if( string.IsNullOrEmpty( line ) || line[ 0 ] == ';' ) // ';'莉･髯阪ｯ繧ｳ繝｡繝ｳ繝医→縺励※辟｡隕
+ continue;
+
+ if( line[ 0 ] == '[' )
+ {
+ #region [ 繧ｻ繧ｯ繧ｷ繝ｧ繝ｳ縺ｮ螟画峩 ]
+ //-----------------------------
+ var builder = new StringBuilder( 32 );
+ int num = 1;
+ while( ( num < line.Length ) && ( line[ num ] != ']' ) )
+ builder.Append( line[ num++ ] );
+
+ // 螟画焚 section 縺御ｽｿ逕ｨ荳ｭ縺ｮ蝣ｴ蜷医ｯ縲´ist 縺ｫ霑ｽ蜉縺励※譁ｰ縺励＞ section 繧剃ｽ懈舌☆繧九
+ if( section != null )
+ this.Sections.Add( section );
+
+ section = new CSection();
+ section.str繧ｻ繧ｯ繧ｷ繝ｧ繝ｳ蜷 = builder.ToString();
+ //-----------------------------
+ #endregion
+
+ continue;
+ }
+
+ string[] strArray = line.Split( new char[] { '=' } );
+ if( strArray.Length != 2 )
+ continue;
+
+ string key = strArray[ 0 ].Trim();
+ string value = strArray[ 1 ].Trim();
+
+ if( section != null && !string.IsNullOrEmpty( key ) && !string.IsNullOrEmpty( value ) )
+ section.list繝代Λ繝｡繝ｼ繧ｿ繝ｪ繧ｹ繝.Add( new KeyValuePair( key, value ) );
+ }
+
+ if( section != null )
+ this.Sections.Add( section );
+ }
+ finally
+ {
+ if( sr != null )
+ sr.Close();
+ }
+ }
+ public void t譖ｸ縺榊ｺ縺( string str繝輔ぃ繧､繝ｫ蜷 )
+ {
+ this.str繝輔ぃ繧､繝ｫ蜷 = str繝輔ぃ繧､繝ｫ蜷;
+ this.t譖ｸ縺榊ｺ縺();
+ }
+ public void t譖ｸ縺榊ｺ縺()
+ {
+ StreamWriter sw = null;
+ try
+ {
+ sw = new StreamWriter( this.str繝輔ぃ繧､繝ｫ蜷, false, Encoding.GetEncoding( "Shift_JIS" ) ); // 繧ｪ繝ｼ繝励Φ螟ｱ謨励ｮ蝣ｴ蜷医ｯ萓句､也匱逕溘
+
+ foreach( CSection section in this.Sections )
+ {
+ sw.WriteLine( "[{0}]", section.str繧ｻ繧ｯ繧ｷ繝ｧ繝ｳ蜷 );
+
+ foreach( KeyValuePair kvp in section.list繝代Λ繝｡繝ｼ繧ｿ繝ｪ繧ｹ繝 )
+ sw.WriteLine( "{0}={1}", kvp.Key, kvp.Value );
+ }
+ }
+ finally
+ {
+ if( sw != null )
+ sw.Close();
+ }
+ }
+ }
+}
diff --git a/FDK19/繧ｳ繝ｼ繝/00.蜈ｱ騾/CJudgeTextEncoding.cs b/FDK19/繧ｳ繝ｼ繝/00.蜈ｱ騾/CJudgeTextEncoding.cs
new file mode 100644
index 00000000..9d2952e5
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/00.蜈ｱ騾/CJudgeTextEncoding.cs
@@ -0,0 +1,81 @@
+ｻｿusing System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.IO;
+using System.Diagnostics;
+
+namespace TJAPlayer3
+{
+ public class CJudgeTextEncoding
+ {
+ ///
+ /// Hnc8讒倥ｮReadJEnc繧剃ｽｿ逕ｨ縺励※譁蟄励さ繝ｼ繝峨ｮ蛻､蛻･繧偵☆繧九
+ ///
+ public static Encoding JudgeFileEncoding(string path)
+ {
+ if (!File.Exists(path)) return null;
+ Encoding enc;
+ FileInfo file = new FileInfo(path);
+
+ using (Hnx8.ReadJEnc.FileReader reader = new Hnx8.ReadJEnc.FileReader(file))
+ {
+ // 蛻､蛻･隱ｭ縺ｿ蜃ｺ縺怜ｮ溯｡後ょ愛蛻･邨先棡縺ｯRead繝｡繧ｽ繝繝峨ｮ謌ｻ繧雁､縺ｧ謚頑升縺ｧ縺阪∪縺
+ Hnx8.ReadJEnc.CharCode c = reader.Read(file);
+ // 謌ｻ繧雁､縺ｮName繝励Ο繝代ユ繧｣縺九ｉ譁蟄励さ繝ｼ繝牙錐繧貞叙蠕励〒縺阪∪縺
+ string name = c.Name;
+ Console.WriteLine("縲" + name + "縲" + file.Name);
+ // GetEncoding()繧貞他縺ｳ蜃ｺ縺吶→縲√お繝ｳ繧ｳ繝ｼ繝繧｣繝ｳ繧ｰ繧貞叙蠕励〒縺阪∪縺
+ enc = c.GetEncoding();
+ }
+ Debug.Print(path + " Encoding=" + enc.CodePage);
+
+ if (enc == null)
+ {
+ enc = Encoding.GetEncoding(932);
+ }
+ return enc;
+ }
+ ///
+ /// Hnc8讒倥ｮReadJEnc繧剃ｽｿ逕ｨ縺励※繝繧ｭ繧ｹ繝医ヵ繧｡繧､繝ｫ繧定ｪｭ縺ｿ霎ｼ繧縲
+ /// 謾ｹ陦梧枚蟄励ｯ縲∝享謇九↓\n縺ｫ邨ｱ荳縺吶ｋ
+ ///
+ ///
+ ///
+ public static string ReadTextFile(string path)
+ {
+ if (!File.Exists(path)) return null;
+ string str = null;
+ FileInfo file = new FileInfo(path);
+
+ using (Hnx8.ReadJEnc.FileReader reader = new Hnx8.ReadJEnc.FileReader(file))
+ {
+ reader.Read(file);
+ str = reader.Text;
+ }
+
+ str = str.Replace(JudgeNewLine(str), "\n");
+
+ return str;
+ }
+
+ ///
+ /// Environment.NewLine縺ｯ繝励Λ繝繝医ヵ繧ｩ繝ｼ繝萓晏ｭ倥〒縺ゅｋ縲
+ /// 縺縺後√ヵ繧｡繧､繝ｫ縺斐→縺ｫ謾ｹ陦後さ繝ｼ繝峨ｯ驕輔≧縺ｮ縺ｧ縲∽ｽｿ逕ｨ縺吶∋縺阪〒縺ｯ縺ｪ縺縲
+ /// 縺ｪ縺ｮ縺ｧ縲∝享謇九↓謾ｹ陦梧枚蟄励ｒ蛻､譁ｭ縺吶ｋ縲
+ ///
+ ///
+ ///
+ public static string JudgeNewLine(string str)
+ {
+ if (str.Contains("\r\n"))
+ return ("\r\n");
+
+ if (str.Contains("\r"))
+ return ("\r");
+
+ return ("\n");
+ }
+
+ }
+}
\ No newline at end of file
diff --git a/FDK19/繧ｳ繝ｼ繝/00.蜈ｱ騾/COS.cs b/FDK19/繧ｳ繝ｼ繝/00.蜈ｱ騾/COS.cs
new file mode 100644
index 00000000..cb339761
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/00.蜈ｱ騾/COS.cs
@@ -0,0 +1,35 @@
+ｻｿusing System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace FDK
+{
+ public static class COS
+ {
+ ///
+ /// OS縺傾P莉･蜑阪↑繧映alse, Vista莉･髯阪↑繧液rue繧定ｿ斐☆
+ ///
+ ///
+ public static bool bIsVistaOrLater
+ {
+ get
+ {
+ //繝励Λ繝繝医ヵ繧ｩ繝ｼ繝縺ｮ蜿門ｾ
+ System.OperatingSystem os = System.Environment.OSVersion;
+ if ( os.Platform != PlatformID.Win32NT ) // NT邉ｻ縺ｧ縺ｪ縺代ｌ縺ｰ縲々P莉･蜑阪°縲￣C Windows邉ｻ莉･螟悶ｮOS縺ｮ縺溘ａ縲〃ista莉･髯阪〒縺ｯ縺ｪ縺縲ゅｈ縺｣縺ｦfalse繧定ｿ斐☆縲
+ {
+ return false;
+ }
+
+ if ( os.Version.Major >= 6 )
+ {
+ return true;
+ }
+ else
+ {
+ return false;
+ }
+ }
+ }
+ }
+}
diff --git a/FDK19/繧ｳ繝ｼ繝/00.蜈ｱ騾/CPowerManagement.cs b/FDK19/繧ｳ繝ｼ繝/00.蜈ｱ騾/CPowerManagement.cs
new file mode 100644
index 00000000..a746a413
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/00.蜈ｱ騾/CPowerManagement.cs
@@ -0,0 +1,28 @@
+ｻｿusing System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace FDK
+{
+ ///
+ /// 繧ｷ繧ｹ繝繝縺ｨ繝｢繝九ち縺ｮ逵髮ｻ蜉帛宛蠕｡繧定｡後≧
+ ///
+ public static class CPowerManagement
+ {
+ ///
+ /// 譛ｬ菴/繝｢繝九ち縺ｮ逵髮ｻ蜉帙Δ繝ｼ繝臥ｧｻ陦後ｒ謚第ｭ｢縺吶ｋ
+ ///
+ public static void tDisableMonitorSuspend()
+ {
+ CWin32.SetThreadExecutionState( CWin32.ExecutionState.SystemRequired | CWin32.ExecutionState.DisplayRequired );
+ }
+
+ ///
+ /// 譛ｬ菴/繝｢繝九ち縺ｮ逵髮ｻ蜉帙Δ繝ｼ繝臥ｧｻ陦梧椛蛻ｶ繧定ｧ｣髯､縺吶ｋ
+ ///
+ public static void tEnableMonitorSuspend()
+ {
+ CWin32.SetThreadExecutionState( CWin32.ExecutionState.Continuous ); // 繧ｹ繝ｪ繝ｼ繝玲椛豁｢迥ｶ諷九ｒ隗｣髯､
+ }
+ }
+}
diff --git a/FDK19/繧ｳ繝ｼ繝/00.蜈ｱ騾/CSendMessage.cs b/FDK19/繧ｳ繝ｼ繝/00.蜈ｱ騾/CSendMessage.cs
new file mode 100644
index 00000000..80d84109
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/00.蜈ｱ騾/CSendMessage.cs
@@ -0,0 +1,33 @@
+ｻｿusing System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using System.Diagnostics;
+using System.Text;
+
+namespace FDK
+{
+ public static class CSendMessage
+ {
+
+ [DllImport( "USER32.dll" )]
+ static extern uint SendMessage( IntPtr window, int msg, IntPtr wParam, ref SampleFramework.COPYDATASTRUCT lParam );
+
+
+ public static uint sendmessage( IntPtr MainWindowHandle, IntPtr FromWindowHandle, string arg)
+ {
+ uint len = (uint) arg.Length;
+
+ SampleFramework.COPYDATASTRUCT cds;
+ cds.dwData = IntPtr.Zero; // 菴ｿ逕ｨ縺励↑縺
+ cds.lpData = Marshal.StringToHGlobalUni( arg ); // 繝繧ｭ繧ｹ繝医ｮ繝昴う繝ｳ繧ｿ繝ｼ繧偵そ繝繝
+ cds.cbData = ( len + 1 ) * 2; // 髟ｷ縺輔ｒ繧ｻ繝繝
+
+ //譁蟄怜励ｒ騾√ｋ
+ uint result = SendMessage( MainWindowHandle, SampleFramework.WindowConstants.WM_COPYDATA, FromWindowHandle, ref cds );
+
+ Marshal.FreeHGlobal( cds.lpData );
+
+ return result;
+ }
+ }
+}
diff --git a/FDK19/繧ｳ繝ｼ繝/00.蜈ｱ騾/CTimer.cs b/FDK19/繧ｳ繝ｼ繝/00.蜈ｱ騾/CTimer.cs
new file mode 100644
index 00000000..d9e9fbb4
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/00.蜈ｱ騾/CTimer.cs
@@ -0,0 +1,162 @@
+ｻｿusing System;
+using System.Collections.Generic;
+using System.Text;
+using System.Runtime.InteropServices;
+using System.Diagnostics;
+using DirectShowLib;
+
+namespace FDK
+{
+ public class CTimer : CTimerBase
+ {
+ public enum E遞ｮ蛻･
+ {
+ Unknown = -1,
+ PerformanceCounter = 0,
+ MultiMedia = 1,
+ GetTickCount = 2,
+ }
+ public E遞ｮ蛻･ e繧ｿ繧､繝樒ｨｮ蛻･
+ {
+ get;
+ protected set;
+ }
+
+
+ public override long n繧ｷ繧ｹ繝繝譎ょ綾ms
+ {
+ get
+ {
+ switch( this.e繧ｿ繧､繝樒ｨｮ蛻･ )
+ {
+ case E遞ｮ蛻･.PerformanceCounter:
+ {
+ double num = 0.0;
+ if( this.n迴ｾ蝨ｨ縺ｮ蜻ｨ豕｢謨ｰ != 0L )
+ {
+ long x = 0L;
+ QueryPerformanceCounter( ref x );
+ num = ( (double) x ) / ( ( (double) this.n迴ｾ蝨ｨ縺ｮ蜻ｨ豕｢謨ｰ ) / 1000.0 );
+ }
+ return (long) num;
+ }
+ case E遞ｮ蛻･.MultiMedia:
+ return (long) timeGetTime();
+
+ case E遞ｮ蛻･.GetTickCount:
+ return (long) Environment.TickCount;
+ }
+ return 0;
+ }
+ }
+
+ public CTimer( E遞ｮ蛻･ e繧ｿ繧､繝樒ｨｮ蛻･ )
+ :base()
+ {
+ this.e繧ｿ繧､繝樒ｨｮ蛻･ = e繧ｿ繧､繝樒ｨｮ蛻･;
+
+ if( n蜿らｧ繧ｫ繧ｦ繝ｳ繝[ (int) this.e繧ｿ繧､繝樒ｨｮ蛻･ ] == 0 )
+ {
+ switch( this.e繧ｿ繧､繝樒ｨｮ蛻･ )
+ {
+ case E遞ｮ蛻･.PerformanceCounter:
+ if( !this.b遒ｺ隱阪→險ｭ螳喟PerformanceCounter() && !this.b遒ｺ隱阪→險ｭ螳喟MultiMedia() )
+ this.b遒ｺ隱阪→險ｭ螳喟GetTickCount();
+ break;
+
+ case E遞ｮ蛻･.MultiMedia:
+ if( !this.b遒ｺ隱阪→險ｭ螳喟MultiMedia() && !this.b遒ｺ隱阪→險ｭ螳喟PerformanceCounter() )
+ this.b遒ｺ隱阪→險ｭ螳喟GetTickCount();
+ break;
+
+ case E遞ｮ蛻･.GetTickCount:
+ this.b遒ｺ隱阪→險ｭ螳喟GetTickCount();
+ break;
+
+ default:
+ throw new ArgumentException( string.Format( "譛ｪ遏･縺ｮ繧ｿ繧､繝樒ｨｮ蛻･縺ｧ縺吶[{0}]", this.e繧ｿ繧､繝樒ｨｮ蛻･ ) );
+ }
+ }
+
+ base.t繝ｪ繧ｻ繝繝();
+
+ n蜿らｧ繧ｫ繧ｦ繝ｳ繝[ (int) this.e繧ｿ繧､繝樒ｨｮ蛻･ ]++;
+ }
+
+ public override void Dispose()
+ {
+ if( this.e繧ｿ繧､繝樒ｨｮ蛻･ == E遞ｮ蛻･.Unknown )
+ return;
+
+ int type = (int) this.e繧ｿ繧､繝樒ｨｮ蛻･;
+
+ n蜿らｧ繧ｫ繧ｦ繝ｳ繝[ type ] = Math.Max( n蜿らｧ繧ｫ繧ｦ繝ｳ繝[ type ] - 1, 0 );
+
+ if( n蜿らｧ繧ｫ繧ｦ繝ｳ繝[ type ] == 0 )
+ {
+ if( this.e繧ｿ繧､繝樒ｨｮ蛻･ == E遞ｮ蛻･.MultiMedia )
+ timeEndPeriod( this.timeCaps.wPeriodMin );
+ }
+
+ this.e繧ｿ繧､繝樒ｨｮ蛻･ = E遞ｮ蛻･.Unknown;
+ }
+
+ #region [ protected ]
+ //-----------------
+ protected long n迴ｾ蝨ｨ縺ｮ蜻ｨ豕｢謨ｰ;
+ protected static int[] n蜿らｧ繧ｫ繧ｦ繝ｳ繝 = new int[ 3 ];
+ protected TimeCaps timeCaps;
+
+ protected bool b遒ｺ隱阪→險ｭ螳喟GetTickCount()
+ {
+ this.e繧ｿ繧､繝樒ｨｮ蛻･ = E遞ｮ蛻･.GetTickCount;
+ return true;
+ }
+ protected bool b遒ｺ隱阪→險ｭ螳喟MultiMedia()
+ {
+ this.timeCaps = new TimeCaps();
+ if( ( timeGetDevCaps( out this.timeCaps, (uint) Marshal.SizeOf( typeof( TimeCaps ) ) ) == 0 ) && ( this.timeCaps.wPeriodMin < 10 ) )
+ {
+ this.e繧ｿ繧､繝樒ｨｮ蛻･ = E遞ｮ蛻･.MultiMedia;
+ timeBeginPeriod( this.timeCaps.wPeriodMin );
+ return true;
+ }
+ return false;
+ }
+ protected bool b遒ｺ隱阪→險ｭ螳喟PerformanceCounter()
+ {
+ if( QueryPerformanceFrequency( ref this.n迴ｾ蝨ｨ縺ｮ蜻ｨ豕｢謨ｰ ) != 0 )
+ {
+ this.e繧ｿ繧､繝樒ｨｮ蛻･ = E遞ｮ蛻･.PerformanceCounter;
+ return true;
+ }
+ return false;
+ }
+ //-----------------
+ #endregion
+
+ #region [ DllImport ]
+ //-----------------
+ [DllImport( "kernel32.dll" )]
+ protected static extern short QueryPerformanceCounter( ref long x );
+ [DllImport( "kernel32.dll" )]
+ protected static extern short QueryPerformanceFrequency( ref long x );
+ [DllImport( "winmm.dll" )]
+ protected static extern void timeBeginPeriod( uint x );
+ [DllImport( "winmm.dll" )]
+ protected static extern void timeEndPeriod( uint x );
+ [DllImport( "winmm.dll" )]
+ protected static extern uint timeGetDevCaps( out TimeCaps timeCaps, uint size );
+ [DllImport( "winmm.dll" )]
+ protected static extern uint timeGetTime();
+
+ [StructLayout( LayoutKind.Sequential )]
+ protected struct TimeCaps
+ {
+ public uint wPeriodMin;
+ public uint wPeriodMax;
+ }
+ //-----------------
+ #endregion
+ }
+}
diff --git a/FDK19/繧ｳ繝ｼ繝/00.蜈ｱ騾/CTimerBase.cs b/FDK19/繧ｳ繝ｼ繝/00.蜈ｱ騾/CTimerBase.cs
new file mode 100644
index 00000000..1e96177d
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/00.蜈ｱ騾/CTimerBase.cs
@@ -0,0 +1,179 @@
+ｻｿusing System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace FDK
+{
+ ///
+ /// 繧ｿ繧､繝槭ｮ謚ｽ雎｡繧ｯ繝ｩ繧ｹ縲
+ /// 縺薙ｮ繧ｯ繝ｩ繧ｹ繧堤ｶ呎価縺励｛verride 縺励◆繧ｯ繝ｩ繧ｹ繧剃ｽ懈舌☆繧九％縺ｨ縺ｧ縲∽ｻｻ諢上ｮ繧ｯ繝ｭ繝繧ｯ繧呈戟縺､繧ｿ繧､繝槭ｒ菴懈舌〒縺阪ｋ縲
+ ///
+ public abstract class CTimerBase : IDisposable
+ {
+ public const long n譛ｪ菴ｿ逕ｨ = -1;
+
+ // 縺薙ｮｼ偵▽繧 override 縺吶ｋ縲
+ public abstract long n繧ｷ繧ｹ繝繝譎ょ綾ms
+ {
+ get;
+ }
+ public double db繧ｷ繧ｹ繝繝譎ょ綾ms
+ {
+ get;
+ set;
+ }
+ public abstract void Dispose();
+
+ #region [ DTXMania逕ｨ縺ｫ縲∬ｪ槫ｰｾ縺ｫms縺ｮ縺､縺九↑縺螳｣險繧定ｿｽ蜉 ]
+ public long n繧ｷ繧ｹ繝繝譎ょ綾
+ {
+ get { return n繧ｷ繧ｹ繝繝譎ょ綾ms; }
+ }
+ public long n迴ｾ蝨ｨ譎ょ綾
+ {
+ get { return n迴ｾ蝨ｨ譎ょ綾ms; }
+ set { n迴ｾ蝨ｨ譎ょ綾ms = value; }
+ }
+ public long n蜑榊屓繝ｪ繧ｻ繝繝医＠縺滓凾縺ｮ繧ｷ繧ｹ繝繝譎ょ綾
+ {
+ get { return n蜑榊屓繝ｪ繧ｻ繝繝医＠縺滓凾縺ｮ繧ｷ繧ｹ繝繝譎ょ綾ms; }
+ }
+
+ //double
+ public double db繧ｷ繧ｹ繝繝譎ょ綾
+ {
+ get { return db繧ｷ繧ｹ繝繝譎ょ綾ms; }
+ }
+ public double db迴ｾ蝨ｨ譎ょ綾
+ {
+ get { return db迴ｾ蝨ｨ譎ょ綾ms; }
+ set { db迴ｾ蝨ｨ譎ょ綾ms = value; }
+ }
+ public double db蜑榊屓繝ｪ繧ｻ繝繝医＠縺滓凾縺ｮ繧ｷ繧ｹ繝繝譎ょ綾
+ {
+ get { return db蜑榊屓繝ｪ繧ｻ繝繝医＠縺滓凾縺ｮ繧ｷ繧ｹ繝繝譎ょ綾ms; }
+ }
+ #endregion
+
+ public long n迴ｾ蝨ｨ譎ょ綾ms
+ {
+ get
+ {
+ if( this.n蛛懈ｭ｢謨ｰ > 0 )
+ return ( this.n荳譎ょ●豁｢繧ｷ繧ｹ繝繝譎ょ綾ms - this.n蜑榊屓繝ｪ繧ｻ繝繝医＠縺滓凾縺ｮ繧ｷ繧ｹ繝繝譎ょ綾ms );
+
+ return ( this.n譖ｴ譁ｰ繧ｷ繧ｹ繝繝譎ょ綾ms - this.n蜑榊屓繝ｪ繧ｻ繝繝医＠縺滓凾縺ｮ繧ｷ繧ｹ繝繝譎ょ綾ms );
+ }
+ set
+ {
+ if( this.n蛛懈ｭ｢謨ｰ > 0 )
+ this.n蜑榊屓繝ｪ繧ｻ繝繝医＠縺滓凾縺ｮ繧ｷ繧ｹ繝繝譎ょ綾ms = this.n荳譎ょ●豁｢繧ｷ繧ｹ繝繝譎ょ綾ms - value;
+ else
+ this.n蜑榊屓繝ｪ繧ｻ繝繝医＠縺滓凾縺ｮ繧ｷ繧ｹ繝繝譎ょ綾ms = this.n譖ｴ譁ｰ繧ｷ繧ｹ繝繝譎ょ綾ms - value;
+ }
+ }
+ public long n繝ｪ繧｢繝ｫ繧ｿ繧､繝迴ｾ蝨ｨ譎ょ綾ms
+ {
+ get
+ {
+ if( this.n蛛懈ｭ｢謨ｰ > 0 )
+ return ( this.n荳譎ょ●豁｢繧ｷ繧ｹ繝繝譎ょ綾ms - this.n蜑榊屓繝ｪ繧ｻ繝繝医＠縺滓凾縺ｮ繧ｷ繧ｹ繝繝譎ょ綾ms );
+
+ return ( this.n繧ｷ繧ｹ繝繝譎ょ綾ms - this.n蜑榊屓繝ｪ繧ｻ繝繝医＠縺滓凾縺ｮ繧ｷ繧ｹ繝繝譎ょ綾ms );
+ }
+ }
+ public long n蜑榊屓繝ｪ繧ｻ繝繝医＠縺滓凾縺ｮ繧ｷ繧ｹ繝繝譎ょ綾ms
+ {
+ get;
+ protected set;
+ }
+
+
+ public double db迴ｾ蝨ｨ譎ょ綾ms
+ {
+ get
+ {
+ if( this.n蛛懈ｭ｢謨ｰ > 0 )
+ return ( this.db荳譎ょ●豁｢繧ｷ繧ｹ繝繝譎ょ綾ms - this.db蜑榊屓繝ｪ繧ｻ繝繝医＠縺滓凾縺ｮ繧ｷ繧ｹ繝繝譎ょ綾ms );
+
+ return ( this.db譖ｴ譁ｰ繧ｷ繧ｹ繝繝譎ょ綾ms - this.db蜑榊屓繝ｪ繧ｻ繝繝医＠縺滓凾縺ｮ繧ｷ繧ｹ繝繝譎ょ綾ms );
+ }
+ set
+ {
+ if( this.n蛛懈ｭ｢謨ｰ > 0 )
+ this.db蜑榊屓繝ｪ繧ｻ繝繝医＠縺滓凾縺ｮ繧ｷ繧ｹ繝繝譎ょ綾ms = this.db荳譎ょ●豁｢繧ｷ繧ｹ繝繝譎ょ綾ms - value;
+ else
+ this.db蜑榊屓繝ｪ繧ｻ繝繝医＠縺滓凾縺ｮ繧ｷ繧ｹ繝繝譎ょ綾ms = this.db譖ｴ譁ｰ繧ｷ繧ｹ繝繝譎ょ綾ms - value;
+ }
+ }
+ public double db繝ｪ繧｢繝ｫ繧ｿ繧､繝迴ｾ蝨ｨ譎ょ綾ms
+ {
+ get
+ {
+ if( this.n蛛懈ｭ｢謨ｰ > 0 )
+ return ( this.db荳譎ょ●豁｢繧ｷ繧ｹ繝繝譎ょ綾ms - this.db蜑榊屓繝ｪ繧ｻ繝繝医＠縺滓凾縺ｮ繧ｷ繧ｹ繝繝譎ょ綾ms );
+
+ return ( this.db繧ｷ繧ｹ繝繝譎ょ綾ms - this.db蜑榊屓繝ｪ繧ｻ繝繝医＠縺滓凾縺ｮ繧ｷ繧ｹ繝繝譎ょ綾ms );
+ }
+ }
+ public double db蜑榊屓繝ｪ繧ｻ繝繝医＠縺滓凾縺ｮ繧ｷ繧ｹ繝繝譎ょ綾ms
+ {
+ get;
+ protected set;
+ }
+
+ public bool b蛛懈ｭ｢縺励※縺縺ｪ縺
+ {
+ get
+ {
+ return ( this.n蛛懈ｭ｢謨ｰ == 0 );
+ }
+ }
+
+ public void t繝ｪ繧ｻ繝繝()
+ {
+ this.t譖ｴ譁ｰ();
+ this.n蜑榊屓繝ｪ繧ｻ繝繝医＠縺滓凾縺ｮ繧ｷ繧ｹ繝繝譎ょ綾ms = this.n譖ｴ譁ｰ繧ｷ繧ｹ繝繝譎ょ綾ms;
+ this.n荳譎ょ●豁｢繧ｷ繧ｹ繝繝譎ょ綾ms = this.n譖ｴ譁ｰ繧ｷ繧ｹ繝繝譎ょ綾ms;
+ this.n蛛懈ｭ｢謨ｰ = 0;
+ }
+ public void t荳譎ょ●豁｢()
+ {
+ if( this.n蛛懈ｭ｢謨ｰ == 0 )
+ {
+ this.n荳譎ょ●豁｢繧ｷ繧ｹ繝繝譎ょ綾ms = this.n譖ｴ譁ｰ繧ｷ繧ｹ繝繝譎ょ綾ms;
+ this.db荳譎ょ●豁｢繧ｷ繧ｹ繝繝譎ょ綾ms = this.db譖ｴ譁ｰ繧ｷ繧ｹ繝繝譎ょ綾ms;
+ }
+
+ this.n蛛懈ｭ｢謨ｰ++;
+ }
+ public void t譖ｴ譁ｰ()
+ {
+ this.n譖ｴ譁ｰ繧ｷ繧ｹ繝繝譎ょ綾ms = this.n繧ｷ繧ｹ繝繝譎ょ綾ms;
+ this.db譖ｴ譁ｰ繧ｷ繧ｹ繝繝譎ょ綾ms = this.db繧ｷ繧ｹ繝繝譎ょ綾ms;
+ }
+ public void t蜀埼幕()
+ {
+ if( this.n蛛懈ｭ｢謨ｰ > 0 )
+ {
+ this.n蛛懈ｭ｢謨ｰ--;
+ if( this.n蛛懈ｭ｢謨ｰ == 0 )
+ {
+ this.t譖ｴ譁ｰ();
+ this.n蜑榊屓繝ｪ繧ｻ繝繝医＠縺滓凾縺ｮ繧ｷ繧ｹ繝繝譎ょ綾ms += this.n譖ｴ譁ｰ繧ｷ繧ｹ繝繝譎ょ綾ms - this.n荳譎ょ●豁｢繧ｷ繧ｹ繝繝譎ょ綾ms;
+ this.db蜑榊屓繝ｪ繧ｻ繝繝医＠縺滓凾縺ｮ繧ｷ繧ｹ繝繝譎ょ綾ms += this.db譖ｴ譁ｰ繧ｷ繧ｹ繝繝譎ょ綾ms - this.db荳譎ょ●豁｢繧ｷ繧ｹ繝繝譎ょ綾ms;
+ }
+ }
+ }
+
+ #region [ protected ]
+ //-----------------
+ protected long n荳譎ょ●豁｢繧ｷ繧ｹ繝繝譎ょ綾ms = 0;
+ protected long n譖ｴ譁ｰ繧ｷ繧ｹ繝繝譎ょ綾ms = 0;
+ protected double db荳譎ょ●豁｢繧ｷ繧ｹ繝繝譎ょ綾ms = 0;
+ protected double db譖ｴ譁ｰ繧ｷ繧ｹ繝繝譎ょ綾ms = 0;
+ protected int n蛛懈ｭ｢謨ｰ = 0;
+ //-----------------
+ #endregion
+ }
+}
diff --git a/FDK19/繧ｳ繝ｼ繝/00.蜈ｱ騾/CTraceLogListener.cs b/FDK19/繧ｳ繝ｼ繝/00.蜈ｱ騾/CTraceLogListener.cs
new file mode 100644
index 00000000..d89ff96c
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/00.蜈ｱ騾/CTraceLogListener.cs
@@ -0,0 +1,157 @@
+ｻｿusing System;
+using System.Collections.Generic;
+using System.Text;
+using System.IO;
+using System.Diagnostics;
+
+namespace FDK
+{
+ public class CTraceLogListener : TraceListener
+ {
+ public CTraceLogListener( StreamWriter stream )
+ {
+ this.streamWriter = stream;
+ }
+
+ public override void Flush()
+ {
+ if( this.streamWriter != null )
+ {
+ try
+ {
+ this.streamWriter.Flush();
+ }
+ catch( ObjectDisposedException )
+ {
+ }
+ }
+ }
+ public override void TraceEvent( TraceEventCache eventCache, string source, TraceEventType eventType, int id, string message )
+ {
+ if( this.streamWriter != null )
+ {
+ try
+ {
+ this.t繧､繝吶Φ繝育ｨｮ蛻･繧貞ｺ蜉帙☆繧( eventType );
+ this.t繧､繝ｳ繝繝ｳ繝医ｒ蜃ｺ蜉帙☆繧();
+ this.streamWriter.WriteLine( message );
+ }
+ catch( ObjectDisposedException )
+ {
+ }
+ }
+ }
+ public override void TraceEvent( TraceEventCache eventCache, string source, TraceEventType eventType, int id, string format, params object[] args )
+ {
+ if( this.streamWriter != null )
+ {
+ try
+ {
+ this.t繧､繝吶Φ繝育ｨｮ蛻･繧貞ｺ蜉帙☆繧( eventType );
+ this.t繧､繝ｳ繝繝ｳ繝医ｒ蜃ｺ蜉帙☆繧();
+ this.streamWriter.WriteLine( string.Format( format, args ) );
+ }
+ catch( ObjectDisposedException )
+ {
+ }
+ }
+ }
+ public override void Write( string message )
+ {
+ if( this.streamWriter != null )
+ {
+ try
+ {
+ this.streamWriter.Write( message );
+ }
+ catch( ObjectDisposedException )
+ {
+ }
+ }
+ }
+ public override void WriteLine( string message )
+ {
+ if( this.streamWriter != null )
+ {
+ try
+ {
+ this.streamWriter.WriteLine( message );
+ }
+ catch( ObjectDisposedException )
+ {
+ }
+ }
+ }
+
+ protected override void Dispose( bool disposing )
+ {
+ if( this.streamWriter != null )
+ {
+ try
+ {
+ this.streamWriter.Close();
+ }
+ catch
+ {
+ }
+ this.streamWriter = null;
+ }
+ base.Dispose( disposing );
+ }
+
+ #region [ private ]
+ //-----------------
+ private StreamWriter streamWriter;
+
+ private void t繧､繝吶Φ繝育ｨｮ蛻･繧貞ｺ蜉帙☆繧( TraceEventType eventType )
+ {
+ if( this.streamWriter != null )
+ {
+ try
+ {
+ var now = DateTime.Now;
+ this.streamWriter.Write( string.Format( "{0:D4}/{1:D2}/{2:D2} {3:D2}:{4:D2}:{5:D2}.{6:D3} ", new object[] { now.Year, now.Month, now.Day, now.Hour, now.Minute, now.Second, now.Millisecond } ) );
+ switch( eventType )
+ {
+ case TraceEventType.Error:
+ this.streamWriter.Write( "[ERROR] " );
+ return;
+
+ case ( TraceEventType.Error | TraceEventType.Critical ):
+ return;
+
+ case TraceEventType.Warning:
+ this.streamWriter.Write( "[WARNING] " );
+ return;
+
+ case TraceEventType.Information:
+ break;
+
+ default:
+ return;
+ }
+ this.streamWriter.Write( "[INFO] " );
+ }
+ catch( ObjectDisposedException )
+ {
+ }
+ }
+ }
+ private void t繧､繝ｳ繝繝ｳ繝医ｒ蜃ｺ蜉帙☆繧()
+ {
+ if( ( this.streamWriter != null ) && ( base.IndentLevel > 0 ) )
+ {
+ try
+ {
+ for( int i = 0; i < base.IndentLevel; i++ )
+ this.streamWriter.Write( " " );
+ }
+ catch( ObjectDisposedException )
+ {
+ }
+ }
+ }
+ //-----------------
+ #endregion
+ }
+}
diff --git a/FDK19/繧ｳ繝ｼ繝/00.蜈ｱ騾/CWin32.cs b/FDK19/繧ｳ繝ｼ繝/00.蜈ｱ騾/CWin32.cs
new file mode 100644
index 00000000..94b272ff
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/00.蜈ｱ騾/CWin32.cs
@@ -0,0 +1,661 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Runtime.InteropServices;
+using System.Drawing;
+
+namespace FDK
+{
+ public class CWin32
+ {
+ #region [ Win32 螳壽焚 ]
+ //-----------------
+ public const int S_OK = 0x00000000;
+ public const int S_FALSE = 0x00000001;
+ public const int E_FAIL = unchecked( (int) 0x80004005 );
+ public const int E_ABORT = unchecked( (int) 0x80004004 );
+
+ public const int BROADCAST_QUERY_DENY = 0x424d5144;
+
+ public const uint CALLBACK_FUNCTION = 0x30000;
+ public const uint ES_CONTINUOUS = 0x80000000;
+ public const uint ES_DISPLAY_REQUIRED = 2;
+ public const uint ES_SYSTEM_REQUIRED = 1;
+ public const uint ES_USER_PRESENT = 4;
+
+ public const int GWL_EXSTYLE = -20;
+ public const int GWL_HINSTANCE = -6;
+ public const int GWL_HWNDPARENT = -8;
+ public const int GWL_ID = -12;
+ public const int GWL_STYLE = -16;
+ public const int GWL_USERDATA = -21;
+ public const int GWL_WNDPROC = -4;
+
+ public static readonly IntPtr HWND_NOTOPMOST = new IntPtr( -2 );
+ public static readonly IntPtr HWND_TOPMOST = new IntPtr( -1 );
+ public const uint MAXPNAMELEN = 0x20;
+
+ #region [ MIDI繝｡繝繧ｻ繝ｼ繧ｸ ]
+ public const uint MIM_CLOSE = 0x3c2;
+ public const uint MIM_DATA = 0x3c3;
+ public const uint MIM_ERROR = 0x3c5;
+ public const uint MIM_LONGDATA = 0x3c4;
+ public const uint MIM_LONGERROR = 0x3c6;
+ public const uint MIM_OPEN = 0x3c1;
+ #endregion
+
+ public const int MONITOR_DEFAULTTOPRIMARY = 1;
+
+ public const int PBT_APMQUERYSTANDBY = 1;
+ public const int PBT_APMQUERYSUSPEND = 0;
+
+ public const int SC_MONITORPOWER = 0xf170;
+ public const int SC_SCREENSAVE = 0xf140;
+
+ public const int SIZE_MAXIMIZED = 2;
+ public const int SIZE_MINIMIZED = 1;
+ public const int SIZE_RESTORED = 0;
+
+ public const uint SWP_FRAMECHANGED = 0x20;
+ public const uint SWP_HIDEWINDOW = 0x80;
+ public const uint SWP_NOACTIVATE = 0x10;
+ public const uint SWP_NOCOPYBITS = 0x100;
+ public const uint SWP_NOMOVE = 2;
+ public const uint SWP_NOOWNERZORDER = 0x200;
+ public const uint SWP_NOREDRAW = 8;
+ public const uint SWP_NOSENDCHANGING = 0x400;
+ public const uint SWP_NOSIZE = 1;
+ public const uint SWP_NOZORDER = 4;
+ public const uint SWP_SHOWWINDOW = 0x40;
+
+ public const uint PM_NOREMOVE = 0;
+ public const uint PM_REMOVE = 1;
+
+ #region [ DirectShow, VFW 髢｢騾｣ ]
+ //-----------------
+ public const int S_WARN_OUTPUTRESET = 0x00009DD4;
+ public const int E_NOTINTREE = unchecked( (int) 0x80040400 );
+ public const int E_RENDER_ENGINE_IS_BROKEN = unchecked( (int) 0x80040401 );
+ public const int E_MUST_INIT_RENDERER = unchecked( (int) 0x80040402 );
+ public const int E_NOTDETERMINED = unchecked( (int) 0x80040403 );
+ public const int E_NO_TIMELINE = unchecked( (int) 0x80040404 );
+
+ public const int VFW_E_INVALIDMEDIATYPE = unchecked( (int) 0x80040200 );
+ public const int VFW_E_INVALIDSUBTYPE = unchecked( (int) 0x80040201 );
+ public const int VFW_E_NEED_OWNER = unchecked( (int) 0x80040202 );
+ public const int VFW_E_ENUM_OUT_OF_SYNC = unchecked( (int) 0x80040203 );
+ public const int VFW_E_ALREADY_CONNECTED = unchecked( (int) 0x80040204 );
+ public const int VFW_E_FILTER_ACTIVE = unchecked( (int) 0x80040205 );
+ public const int VFW_E_NO_TYPES = unchecked( (int) 0x80040206 );
+ public const int VFW_E_NO_ACCEPTABLE_TYPES = unchecked( (int) 0x80040207 );
+ public const int VFW_E_INVALID_DIRECTION = unchecked( (int) 0x80040208 );
+ public const int VFW_E_NOT_CONNECTED = unchecked( (int) 0x80040209 );
+ public const int VFW_E_NO_ALLOCATOR = unchecked( (int) 0x8004020A );
+ public const int VFW_E_RUNTIME_ERROR = unchecked( (int) 0x8004020B );
+ public const int VFW_E_BUFFER_NOTSET = unchecked( (int) 0x8004020C );
+ public const int VFW_E_BUFFER_OVERFLOW = unchecked( (int) 0x8004020D );
+ public const int VFW_E_BADALIGN = unchecked( (int) 0x8004020E );
+ public const int VFW_E_ALREADY_COMMITTED = unchecked( (int) 0x8004020F );
+ public const int VFW_E_BUFFERS_OUTSTANDING = unchecked( (int) 0x80040210 );
+ public const int VFW_E_NOT_COMMITTED = unchecked( (int) 0x80040211 );
+ public const int VFW_E_SIZENOTSET = unchecked( (int) 0x80040212 );
+ public const int VFW_E_NO_CLOCK = unchecked( (int) 0x80040213 );
+ public const int VFW_E_NO_SINK = unchecked( (int) 0x80040214 );
+ public const int VFW_E_NO_INTERFACE = unchecked( (int) 0x80040215 );
+ public const int VFW_E_NOT_FOUND = unchecked( (int) 0x80040216 );
+ public const int VFW_E_CANNOT_CONNECT = unchecked( (int) 0x80040217 );
+ public const int VFW_E_CANNOT_RENDER = unchecked( (int) 0x80040218 );
+ public const int VFW_E_CHANGING_FORMAT = unchecked( (int) 0x80040219 );
+ public const int VFW_E_NO_COLOR_KEY_SET = unchecked( (int) 0x8004021A );
+ public const int VFW_E_NOT_OVERLAY_CONNECTION = unchecked( (int) 0x8004021B );
+ public const int VFW_E_NOT_SAMPLE_CONNECTION = unchecked( (int) 0x8004021C );
+ public const int VFW_E_PALETTE_SET = unchecked( (int) 0x8004021D );
+ public const int VFW_E_COLOR_KEY_SET = unchecked( (int) 0x8004021E );
+ public const int VFW_E_NO_COLOR_KEY_FOUND = unchecked( (int) 0x8004021F );
+ public const int VFW_E_NO_PALETTE_AVAILABLE = unchecked( (int) 0x80040220 );
+ public const int VFW_E_NO_DISPLAY_PALETTE = unchecked( (int) 0x80040221 );
+ public const int VFW_E_TOO_MANY_COLORS = unchecked( (int) 0x80040222 );
+ public const int VFW_E_STATE_CHANGED = unchecked( (int) 0x80040223 );
+ public const int VFW_E_NOT_STOPPED = unchecked( (int) 0x80040224 );
+ public const int VFW_E_NOT_PAUSED = unchecked( (int) 0x80040225 );
+ public const int VFW_E_NOT_RUNNING = unchecked( (int) 0x80040226 );
+ public const int VFW_E_WRONG_STATE = unchecked( (int) 0x80040227 );
+ public const int VFW_E_START_TIME_AFTER_END = unchecked( (int) 0x80040228 );
+ public const int VFW_E_INVALID_RECT = unchecked( (int) 0x80040229 );
+ public const int VFW_E_TYPE_NOT_ACCEPTED = unchecked( (int) 0x8004022A );
+ public const int VFW_E_SAMPLE_REJECTED = unchecked( (int) 0x8004022B );
+ public const int VFW_E_SAMPLE_REJECTED_EOS = unchecked( (int) 0x8004022C );
+ public const int VFW_E_DUPLICATE_NAME = unchecked( (int) 0x8004022D );
+ public const int VFW_S_DUPLICATE_NAME = 0x0004022D;
+ public const int VFW_E_TIMEOUT = unchecked( (int) 0x8004022E );
+ public const int VFW_E_INVALID_FILE_FORMAT = unchecked( (int) 0x8004022F );
+ public const int VFW_E_ENUM_OUT_OF_RANGE = unchecked( (int) 0x80040230 );
+ public const int VFW_E_CIRCULAR_GRAPH = unchecked( (int) 0x80040231 );
+ public const int VFW_E_NOT_ALLOWED_TO_SAVE = unchecked( (int) 0x80040232 );
+ public const int VFW_E_TIME_ALREADY_PASSED = unchecked( (int) 0x80040233 );
+ public const int VFW_E_ALREADY_CANCELLED = unchecked( (int) 0x80040234 );
+ public const int VFW_E_CORRUPT_GRAPH_FILE = unchecked( (int) 0x80040235 );
+ public const int VFW_E_ADVISE_ALREADY_SET = unchecked( (int) 0x80040236 );
+ public const int VFW_S_STATE_INTERMEDIATE = 0x00040237;
+ public const int VFW_E_NO_MODEX_AVAILABLE = unchecked( (int) 0x80040238 );
+ public const int VFW_E_NO_ADVISE_SET = unchecked( (int) 0x80040239 );
+ public const int VFW_E_NO_FULLSCREEN = unchecked( (int) 0x8004023A );
+ public const int VFW_E_IN_FULLSCREEN_MODE = unchecked( (int) 0x8004023B );
+ public const int VFW_E_UNKNOWN_FILE_TYPE = unchecked( (int) 0x80040240 );
+ public const int VFW_E_CANNOT_LOAD_SOURCE_FILTER = unchecked( (int) 0x80040241 );
+ public const int VFW_S_PARTIAL_RENDER = 0x00040242;
+ public const int VFW_E_FILE_TOO_SHORT = unchecked( (int) 0x80040243 );
+ public const int VFW_E_INVALID_FILE_VERSION = unchecked( (int) 0x80040244 );
+ public const int VFW_S_SOME_DATA_IGNORED = 0x00040245;
+ public const int VFW_S_CONNECTIONS_DEFERRED = 0x00040246;
+ public const int VFW_E_INVALID_CLSID = unchecked( (int) 0x80040247 );
+ public const int VFW_E_INVALID_MEDIA_TYPE = unchecked( (int) 0x80040248 );
+ public const int VFW_E_SAMPLE_TIME_NOT_SET = unchecked( (int) 0x80040249 );
+ public const int VFW_S_RESOURCE_NOT_NEEDED = 0x00040250;
+ public const int VFW_E_MEDIA_TIME_NOT_SET = unchecked( (int) 0x80040251 );
+ public const int VFW_E_NO_TIME_FORMAT_SET = unchecked( (int) 0x80040252 );
+ public const int VFW_E_MONO_AUDIO_HW = unchecked( (int) 0x80040253 );
+ public const int VFW_S_MEDIA_TYPE_IGNORED = 0x00040254;
+ public const int VFW_E_NO_DECOMPRESSOR = unchecked( (int) 0x80040255 );
+ public const int VFW_E_NO_AUDIO_HARDWARE = unchecked( (int) 0x80040256 );
+ public const int VFW_S_VIDEO_NOT_RENDERED = 0x00040257;
+ public const int VFW_S_AUDIO_NOT_RENDERED = 0x00040258;
+ public const int VFW_E_RPZA = unchecked( (int) 0x80040259 );
+ public const int VFW_S_RPZA = 0x0004025A;
+ public const int VFW_E_PROCESSOR_NOT_SUITABLE = unchecked( (int) 0x8004025B );
+ public const int VFW_E_UNSUPPORTED_AUDIO = unchecked( (int) 0x8004025C );
+ public const int VFW_E_UNSUPPORTED_VIDEO = unchecked( (int) 0x8004025D );
+ public const int VFW_E_MPEG_NOT_CONSTRAINED = unchecked( (int) 0x8004025E );
+ public const int VFW_E_NOT_IN_GRAPH = unchecked( (int) 0x8004025F );
+ public const int VFW_S_ESTIMATED = 0x00040260;
+ public const int VFW_E_NO_TIME_FORMAT = unchecked( (int) 0x80040261 );
+ public const int VFW_E_READ_ONLY = unchecked( (int) 0x80040262 );
+ public const int VFW_S_RESERVED = 0x00040263;
+ public const int VFW_E_BUFFER_UNDERFLOW = unchecked( (int) 0x80040264 );
+ public const int VFW_E_UNSUPPORTED_STREAM = unchecked( (int) 0x80040265 );
+ public const int VFW_E_NO_TRANSPORT = unchecked( (int) 0x80040266 );
+ public const int VFW_S_STREAM_OFF = 0x00040267;
+ public const int VFW_S_CANT_CUE = 0x00040268;
+ public const int VFW_E_BAD_VIDEOCD = unchecked( (int) 0x80040269 );
+ public const int VFW_S_NO_STOP_TIME = 0x00040270;
+ public const int VFW_E_OUT_OF_VIDEO_MEMORY = unchecked( (int) 0x80040271 );
+ public const int VFW_E_VP_NEGOTIATION_FAILED = unchecked( (int) 0x80040272 );
+ public const int VFW_E_DDRAW_CAPS_NOT_SUITABLE = unchecked( (int) 0x80040273 );
+ public const int VFW_E_NO_VP_HARDWARE = unchecked( (int) 0x80040274 );
+ public const int VFW_E_NO_CAPTURE_HARDWARE = unchecked( (int) 0x80040275 );
+ public const int VFW_E_DVD_OPERATION_INHIBITED = unchecked( (int) 0x80040276 );
+ public const int VFW_E_DVD_INVALIDDOMAIN = unchecked( (int) 0x80040277 );
+ public const int VFW_E_DVD_NO_BUTTON = unchecked( (int) 0x80040278 );
+ public const int VFW_E_DVD_GRAPHNOTREADY = unchecked( (int) 0x80040279 );
+ public const int VFW_E_DVD_RENDERFAIL = unchecked( (int) 0x8004027A );
+ public const int VFW_E_DVD_DECNOTENOUGH = unchecked( (int) 0x8004027B );
+ public const int VFW_E_DVD_NOT_IN_KARAOKE_MODE = unchecked( (int) 0x8004028B );
+ public const int VFW_E_FRAME_STEP_UNSUPPORTED = unchecked( (int) 0x8004028E );
+ public const int VFW_E_PIN_ALREADY_BLOCKED_ON_THIS_THREAD = unchecked( (int) 0x80040293 );
+ public const int VFW_E_PIN_ALREADY_BLOCKED = unchecked( (int) 0x80040294 );
+ public const int VFW_E_CERTIFICATION_FAILURE = unchecked( (int) 0x80040295 );
+ public const int VFW_E_BAD_KEY = unchecked( (int) 0x800403F2 );
+ //-----------------
+ #endregion
+
+ #region [ Windows繝｡繝繧ｻ繝ｼ繧ｸ ]
+ public const uint WM_ACTIVATEAPP = 0x1c;
+ public const uint WM_COPYDATA = 0x4a;
+ public const uint WM_CLOSE = 0x10;
+ public const uint WM_POWERBROADCAST = 0x218;
+ public const uint WM_SIZE = 5;
+ public const uint WM_SYSCOMMAND = 0x112;
+ public const uint WM_SYSKEYDOWN = 260;
+ public const uint WM_APP = 0x00008000;
+ public const uint WM_QUIT = 0x12;
+ public const uint WPF_RESTORETOMAXIMIZED = 2;
+ #endregion
+
+ #region [ WindowsStyle 繝輔Λ繧ｰ]
+ public const long WS_BORDER = 0x800000L;
+ public const long WS_CAPTION = 0xc00000L;
+ public const long WS_CHILD = 0x40000000L;
+ public const long WS_CHILDWINDOW = 0x40000000L;
+ public const long WS_CLIPCHILDREN = 0x2000000L;
+ public const long WS_CLIPSIBLINGS = 0x4000000L;
+ public const long WS_DISABLED = 0x8000000L;
+ public const long WS_DLGFRAME = 0x400000L;
+ public const long WS_GROUP = 0x20000L;
+ public const long WS_HSCROLL = 0x100000L;
+ public const long WS_ICONIC = 0x20000000L;
+ public const long WS_MAXIMIZE = 0x1000000L;
+ public const long WS_MAXIMIZEBOX = 0x10000L;
+ public const long WS_MINIMIZE = 0x20000000L;
+ public const long WS_MINIMIZEBOX = 0x20000L;
+ public const long WS_OVERLAPPED = 0L;
+ public const long WS_OVERLAPPEDWINDOW = 0xcf0000L;
+ public const long WS_POPUP = 0x80000000L;
+ public const long WS_POPUPWINDOW = 0x80880000L;
+ public const long WS_SIZEBOX = 0x40000L;
+ public const long WS_SYSMENU = 0x80000L;
+ public const long WS_TABSTOP = 0x10000L;
+ public const long WS_THICKFRAME = 0x40000L;
+ public const long WS_TILED = 0L;
+ public const long WS_TILEDWINDOW = 0xcf0000L;
+ public const long WS_VISIBLE = 0x10000000L;
+ public const long WS_VSCROLL = 0x200000L;
+ public const long WS_EX_ACCEPTFILES = 0x10L;
+ public const long WS_EX_APPWINDOW = 0x40000L;
+ public const long WS_EX_CLIENTEDGE = 0x200L;
+ public const long WS_EX_COMPOSITED = 0x2000000L;
+ public const long WS_EX_CONTEXTHELP = 0x400L;
+ public const long WS_EX_CONTROLPARENT = 0x10000L;
+ public const long WS_EX_DLGMODALFRAME = 1L;
+ public const long WS_EX_LAYERED = 0x80000L;
+ public const long WS_EX_LAYOUTRTL = 0x400000L;
+ public const long WS_EX_LEFT = 0L;
+ public const long WS_EX_LEFTSCROLLBAR = 0x4000L;
+ public const long WS_EX_LTRREADING = 0L;
+ public const long WS_EX_MDICHILD = 0x40L;
+ public const long WS_EX_NOACTIVATE = 0x8000000L;
+ public const long WS_EX_NOINHERITLAYOUT = 0x100000L;
+ public const long WS_EX_NOPARENTNOTIFY = 4L;
+ public const long WS_EX_OVERLAPPEDWINDOW = 0x300L;
+ public const long WS_EX_PALETTEWINDOW = 0x188L;
+ public const long WS_EX_RIGHT = 0x1000L;
+ public const long WS_EX_RIGHTSCROLLBAR = 0L;
+ public const long WS_EX_RTLREADING = 0x2000L;
+ public const long WS_EX_STATICEDGE = 0x20000L;
+ public const long WS_EX_TOOLWINDOW = 0x80L;
+ public const long WS_EX_TOPMOST = 8L;
+ public const long WS_EX_TRANSPARENT = 0x20L;
+ public const long WS_EX_WINDOWEDGE = 0x100L;
+ #endregion
+
+
+ public enum EShowWindow
+ {
+ ForceMinimize = 11,
+ Hide = 0,
+ Maximize = 3,
+ Minimize = 6,
+ Normal = 1,
+ Restore = 9,
+ Show = 5,
+ ShowDefault = 10,
+ ShowMaximized = 3,
+ ShowMinimized = 2,
+ ShowMinNoActive = 7,
+ ShowNA = 8,
+ ShowNoActivate = 4
+ }
+ public enum MMSYSERR
+ {
+ NOERROR,
+ ERROR,
+ BADDEVICEID,
+ NOTENABLED,
+ ALLOCATED,
+ INVALHANDLE,
+ NODRIVER,
+ NOMEM,
+ NOTSUPPORTED,
+ BADERRNUM,
+ INVALFLAG,
+ INVALPARAM,
+ HANDLEBUSY,
+ INVALIDALIAS,
+ BADDB,
+ KEYNOTFOUND,
+ READERROR,
+ WRITEERROR,
+ DELETEERROR,
+ VALNOTFOUND,
+ NODRIVERCB,
+ MOREDATA
+ }
+ [FlagsAttribute]
+ internal enum ExecutionState : uint
+ {
+ Null = 0, // 髢｢謨ｰ縺悟､ｱ謨励＠縺滓凾縺ｮ謌ｻ繧雁､
+ SystemRequired = 1, // 繧ｹ繧ｿ繝ｳ繝舌う繧呈椛豁｢
+ DisplayRequired = 2, // 逕ｻ髱｢OFF繧呈椛豁｢
+ Continuous = 0x80000000, // 蜉ｹ譫懊ｒ豌ｸ邯壹＆縺帙ｋ縲ゅ⊇縺九が繝励す繝ｧ繝ｳ縺ｨ菴ｵ逕ｨ縺吶ｋ縲
+ }
+ //-----------------
+ #endregion
+
+ #region [ Win32 髢｢謨ｰ ]
+ //-----------------
+ [return: MarshalAs( UnmanagedType.Bool )]
+ [DllImport( "user32.dll", CharSet = CharSet.Auto, SetLastError = true )]
+ public static extern bool AdjustWindowRect( ref RECT lpRect, uint dwStyle, [MarshalAs( UnmanagedType.Bool )] bool bMenu );
+ [return: MarshalAs( UnmanagedType.Bool )]
+ [DllImport( "user32.dll", CharSet = CharSet.Auto, SetLastError = true )]
+ public static extern bool GetClientRect( IntPtr hWnd, out RECT lpRect );
+ [DllImport( "user32.dll", CharSet = CharSet.Auto, SetLastError = true )]
+ public static extern uint GetWindowLong( IntPtr hWnd, int nIndex );
+ [return: MarshalAs( UnmanagedType.Bool )]
+ [DllImport( "user32.dll", CharSet = CharSet.Auto, SetLastError = true )]
+ public static extern bool GetWindowPlacement( IntPtr hWnd, ref WINDOWPLACEMENT lpwndpl );
+ [return: MarshalAs( UnmanagedType.Bool )]
+ [DllImport( "user32.dll", CharSet = CharSet.Auto )]
+ public static extern bool IsIconic( IntPtr hWnd );
+ [return: MarshalAs( UnmanagedType.Bool )]
+ [DllImport( "user32.dll", CharSet = CharSet.Auto )]
+ public static extern bool IsWindowVisible( IntPtr hWnd );
+ [return: MarshalAs( UnmanagedType.Bool )]
+ [DllImport( "user32.dll", CharSet = CharSet.Auto )]
+ public static extern bool IsZoomed( IntPtr hWnd );
+ [DllImport("winmm.dll")]
+ public static extern uint midiInClose(IntPtr hMidiIn);
+ [DllImport("winmm.dll")]
+ public static extern uint midiInGetDevCaps(uint uDeviceID, ref MIDIINCAPS lpMidiInCaps, uint cbMidiInCaps);
+ [DllImport("winmm.dll")]
+ public static extern uint midiInGetID(IntPtr hMidiIn, ref IntPtr puDeviceID);
+ [DllImport("winmm.dll")]
+ public static extern uint midiInGetNumDevs();
+ [DllImport("winmm.dll")]
+ public static extern uint midiInOpen(ref IntPtr phMidiIn, uint uDeviceID, MidiInProc dwCallback, IntPtr dwInstance, int fdwOpen);
+ [DllImport("winmm.dll")]
+ public static extern uint midiInReset(IntPtr hMidiIn);
+ [DllImport("winmm.dll")]
+ public static extern uint midiInStart(IntPtr hMidiIn);
+ [DllImport("winmm.dll")]
+ public static extern uint midiInStop(IntPtr hMidiIn);
+ [DllImport( "user32.dll", CharSet = CharSet.Auto )]
+ public static extern IntPtr MonitorFromWindow( IntPtr hwnd, uint dwFlags );
+ [return: MarshalAs( UnmanagedType.Bool )]
+ [DllImport( "user32.dll", CharSet = CharSet.Auto )]
+ public static extern bool PeekMessage( out WindowMessage message, IntPtr hwnd, uint messageFilterMin, uint messageFilterMax, uint flags );
+ [DllImport( "kernel32.dll", CharSet = CharSet.Auto )]
+ public static extern uint SetThreadExecutionState( uint esFlags );
+ [DllImport( "Kernel32.Dll" )]
+ public static unsafe extern void CopyMemory( void* pDest, void* pSrc, uint numOfBytes );
+
+ [DllImport( "user32.dll", CharSet = CharSet.Auto, SetLastError = true )]
+ public static extern uint SetWindowLong( IntPtr hWnd, int nIndex, uint dwNewLong );
+ [return: MarshalAs( UnmanagedType.Bool )]
+ [DllImport( "user32.dll", CharSet = CharSet.Auto, SetLastError = true )]
+ public static extern bool SetWindowPlacement( IntPtr hWnd, ref WINDOWPLACEMENT lpwndpl );
+ [return: MarshalAs( UnmanagedType.Bool )]
+ [DllImport( "user32.dll", CharSet = CharSet.Auto, SetLastError = true )]
+ public static extern bool SetWindowPos( IntPtr hWnd, IntPtr hWndInsertAfter, int X, int Y, int cx, int cy, uint uFlags );
+ [return: MarshalAs( UnmanagedType.Bool )]
+ [DllImport( "user32.dll", CharSet = CharSet.Auto )]
+ public static extern bool ShowWindow( IntPtr hWnd, EShowWindow nCmdShow );
+ [return: MarshalAs( UnmanagedType.Bool )]
+ [DllImport( "user32.dll", CharSet = CharSet.Auto, SetLastError = true )]
+ public static extern bool SystemParametersInfo( uint uiAction, uint uiParam, IntPtr pvParam, uint fWinIni );
+ [DllImport( "kernel32.dll" )]
+ public static extern void GetSystemInfo( ref SYSTEM_INFO ptmpsi );
+ [DllImport( "kernel32.dll" )]
+ internal static extern ExecutionState SetThreadExecutionState( ExecutionState esFlags );
+ //-----------------
+ #endregion
+
+ #region [ Win32 讒矩菴 ]
+ //-----------------
+ [StructLayout( LayoutKind.Sequential )]
+ private struct FILTERKEYS
+ {
+ public int cbSize;
+ public int dwFlags;
+ }
+
+ [StructLayout( LayoutKind.Sequential )]
+ public struct MIDIINCAPS
+ {
+ public ushort wMid;
+ public ushort wPid;
+ public uint vDriverVersion;
+ [MarshalAs( UnmanagedType.ByValTStr, SizeConst = 0x20 )]
+ public string szPname;
+ public uint dwSupport;
+ }
+
+ [StructLayout( LayoutKind.Sequential )]
+ public struct RECT
+ {
+ public int left;
+ public int top;
+ public int right;
+ public int bottom;
+ }
+
+ [StructLayout( LayoutKind.Sequential )]
+ private struct STICKYKEYS
+ {
+ public int cbSize;
+ public int dwFlags;
+ }
+
+ [StructLayout( LayoutKind.Sequential )]
+ private struct TOGGLEKEYS
+ {
+ public int cbSize;
+ public int dwFlags;
+ }
+
+ [StructLayout( LayoutKind.Sequential )]
+ public struct WAVEFORMATEX
+ {
+ public ushort wFormatTag;
+ public ushort nChannels;
+ public uint nSamplesPerSec;
+ public uint nAvgBytesPerSec;
+ public ushort nBlockAlign;
+ public ushort wBitsPerSample;
+ public ushort cbSize;
+ }
+
+ [StructLayout( LayoutKind.Sequential )]
+ public struct WindowMessage
+ {
+ public IntPtr hWnd;
+ public uint msg;
+ public IntPtr wParam;
+ public IntPtr lParam;
+ public uint time;
+ public Point p;
+ }
+
+ [StructLayout( LayoutKind.Sequential )]
+ public struct WINDOWPLACEMENT
+ {
+ public int length;
+ public int flags;
+ public CWin32.EShowWindow showCmd;
+ public Point ptMinPosition;
+ public Point ptMaxPosition;
+ public CWin32.RECT rcNormalPosition;
+ public static int Length
+ {
+ get
+ {
+ return Marshal.SizeOf( typeof( CWin32.WINDOWPLACEMENT ) );
+ }
+ }
+ }
+ [StructLayout( LayoutKind.Sequential )]
+ public struct SYSTEM_INFO
+ {
+ public uint dwOemId;
+ public uint dwPageSize;
+ public uint lpMinimumApplicationAddress;
+ public uint lpMaximumApplicationAddress;
+ public uint dwActiveProcessorMask;
+ public uint dwNumberOfProcessors;
+ public uint dwProcessorType;
+ public uint dwAllocationGranularity;
+ public uint dwProcessorLevel;
+ public uint dwProcessorRevision;
+ }
+ //-----------------
+ #endregion
+
+
+ // 繝励Ο繝代ユ繧｣
+
+ public static bool b繧｢繝励Μ縺栗dle迥ｶ諷九〒縺ゅｋ
+ {
+ get
+ {
+ WindowMessage message;
+ return !PeekMessage( out message, IntPtr.Zero, 0, 0, 0 );
+ }
+ }
+
+
+ // 繧ｭ繝ｼ繝懊ｼ繝峨ｮ迚ｹ谿頑ｩ溯ｽ縺ｮ蛻ｶ蠕｡
+
+ public static class C繝医げ繝ｫ繧ｭ繝ｼ讖溯ｽ
+ {
+ public static void t辟｡蜉ｹ蛹悶☆繧()
+ {
+ if( ( stored.dwFlags & 1L ) == 0L )
+ {
+ CWin32.TOGGLEKEYS structure = new CWin32.TOGGLEKEYS();
+ structure.dwFlags = stored.dwFlags;
+ structure.cbSize = stored.cbSize;
+ structure.dwFlags &= -5;
+ structure.dwFlags &= -9;
+ int cb = Marshal.SizeOf( structure );
+ IntPtr ptr = Marshal.AllocCoTaskMem( cb );
+ Marshal.StructureToPtr( structure, ptr, false );
+ CWin32.SystemParametersInfo( 0x35, (uint) cb, ptr, 0 );
+ Marshal.FreeCoTaskMem( ptr );
+ }
+ }
+ public static void t蠕ｩ蜈縺吶ｋ()
+ {
+ int cb = Marshal.SizeOf( stored );
+ IntPtr ptr = Marshal.AllocCoTaskMem( cb );
+ Marshal.StructureToPtr( stored, ptr, false );
+ CWin32.SystemParametersInfo( 0x35, (uint) cb, ptr, 0 );
+ Marshal.FreeCoTaskMem( ptr );
+ }
+
+ #region [ private ]
+ //-----------------
+ static C繝医げ繝ｫ繧ｭ繝ｼ讖溯ｽ()
+ {
+ int cb = Marshal.SizeOf( stored );
+ IntPtr ptr = Marshal.AllocCoTaskMem( cb );
+ Marshal.StructureToPtr( stored, ptr, false );
+ CWin32.SystemParametersInfo( 0x34, (uint) cb, ptr, 0 );
+ stored = (CWin32.TOGGLEKEYS) Marshal.PtrToStructure( ptr, typeof( CWin32.TOGGLEKEYS ) );
+ Marshal.FreeCoTaskMem( ptr );
+ }
+
+ private const uint SPI_GETTOGGLEKEYS = 0x34;
+ private const uint SPI_SETTOGGLEKEYS = 0x35;
+ private static CWin32.TOGGLEKEYS stored = new CWin32.TOGGLEKEYS();
+ private const uint TKF_CONFIRMHOTKEY = 8;
+ private const uint TKF_HOTKEYACTIVE = 4;
+ private const uint TKF_TOGGLEKEYSON = 1;
+ //-----------------
+ #endregion
+ }
+ public static class C繝輔ぅ繝ｫ繧ｿ繧ｭ繝ｼ讖溯ｽ
+ {
+ public static void t辟｡蜉ｹ蛹悶☆繧()
+ {
+ if( ( stored.dwFlags & 1L ) == 0L )
+ {
+ CWin32.FILTERKEYS structure = new CWin32.FILTERKEYS();
+ structure.dwFlags = stored.dwFlags;
+ structure.cbSize = stored.cbSize;
+ structure.dwFlags &= -5;
+ structure.dwFlags &= -9;
+ int cb = Marshal.SizeOf( structure );
+ IntPtr ptr = Marshal.AllocCoTaskMem( cb );
+ Marshal.StructureToPtr( structure, ptr, false );
+ CWin32.SystemParametersInfo( 0x3b, (uint) cb, ptr, 0 );
+ Marshal.FreeCoTaskMem( ptr );
+ }
+ }
+ public static void t蠕ｩ蜈縺吶ｋ()
+ {
+ int cb = Marshal.SizeOf( stored );
+ IntPtr ptr = Marshal.AllocCoTaskMem( cb );
+ Marshal.StructureToPtr( stored, ptr, false );
+ CWin32.SystemParametersInfo( 0x3b, (uint) cb, ptr, 0 );
+ Marshal.FreeCoTaskMem( ptr );
+ }
+
+ #region [ private ]
+ //-----------------
+ static C繝輔ぅ繝ｫ繧ｿ繧ｭ繝ｼ讖溯ｽ()
+ {
+ stored.cbSize = 0;
+ stored.dwFlags = 0;
+ int cb = Marshal.SizeOf( stored );
+ IntPtr ptr = Marshal.AllocCoTaskMem( cb );
+ Marshal.StructureToPtr( stored, ptr, false );
+ CWin32.SystemParametersInfo( 50, (uint) cb, ptr, 0 );
+ stored = (CWin32.FILTERKEYS) Marshal.PtrToStructure( ptr, typeof( CWin32.FILTERKEYS ) );
+ Marshal.FreeCoTaskMem( ptr );
+ }
+
+ private const uint FKF_CONFIRMHOTKEY = 8;
+ private const uint FKF_FILTERKEYSON = 1;
+ private const uint FKF_HOTKEYACTIVE = 4;
+ private const uint SPI_GETFILTERKEYS = 50;
+ private const uint SPI_SETFILTERKEYS = 0x3b;
+ private static CWin32.FILTERKEYS stored = new CWin32.FILTERKEYS();
+ //-----------------
+ #endregion
+ }
+ public static class C蝗ｺ螳壹く繝ｼ讖溯ｽ
+ {
+ public static void t辟｡蜉ｹ蛹悶☆繧()
+ {
+ if( ( stored.dwFlags & 1L ) == 0L )
+ {
+ CWin32.STICKYKEYS structure = new CWin32.STICKYKEYS();
+ structure.dwFlags = stored.dwFlags;
+ structure.cbSize = stored.cbSize;
+ structure.dwFlags &= -5;
+ structure.dwFlags &= -9;
+ int cb = Marshal.SizeOf( structure );
+ IntPtr ptr = Marshal.AllocCoTaskMem( cb );
+ Marshal.StructureToPtr( structure, ptr, false );
+ CWin32.SystemParametersInfo( 0x3b, (uint) cb, ptr, 0 );
+ Marshal.FreeCoTaskMem( ptr );
+ }
+ }
+ public static void t蠕ｩ蜈縺吶ｋ()
+ {
+ int cb = Marshal.SizeOf( stored );
+ IntPtr ptr = Marshal.AllocCoTaskMem( cb );
+ Marshal.StructureToPtr( stored, ptr, false );
+ CWin32.SystemParametersInfo( 0x3b, (uint) cb, ptr, 0 );
+ Marshal.FreeCoTaskMem( ptr );
+ }
+
+ #region [ private ]
+ //-----------------
+ static C蝗ｺ螳壹く繝ｼ讖溯ｽ()
+ {
+ stored.cbSize = 0;
+ stored.dwFlags = 0;
+ int cb = Marshal.SizeOf( stored );
+ IntPtr ptr = Marshal.AllocCoTaskMem( cb );
+ Marshal.StructureToPtr( stored, ptr, false );
+ CWin32.SystemParametersInfo( 0x3a, (uint) cb, ptr, 0 );
+ stored = (CWin32.STICKYKEYS) Marshal.PtrToStructure( ptr, typeof( CWin32.STICKYKEYS ) );
+ Marshal.FreeCoTaskMem( ptr );
+ }
+
+ private const uint SKF_CONFIRMHOTKEY = 8;
+ private const uint SKF_HOTKEYACTIVE = 4;
+ private const uint SKF_STICKYKEYSON = 1;
+ private const uint SPI_GETSTICKYKEYS = 0x3a;
+ private const uint SPI_SETSTICKYKEYS = 0x3b;
+ private static CWin32.STICKYKEYS stored = new CWin32.STICKYKEYS();
+ //-----------------
+ #endregion
+ }
+
+
+ // Win32 繝｡繝繧ｻ繝ｼ繧ｸ蜃ｦ逅繝繝ｪ繧ｲ繝ｼ繝
+
+ public delegate void MidiInProc(IntPtr hMidiIn, uint wMsg, IntPtr dwInstance, IntPtr dwParam1, IntPtr dwParam2);
+ }
+}
diff --git a/FDK19/繧ｳ繝ｼ繝/00.蜈ｱ騾/C荳螳夐俣髫泌ｦ逅.cs b/FDK19/繧ｳ繝ｼ繝/00.蜈ｱ騾/C荳螳夐俣髫泌ｦ逅.cs
new file mode 100644
index 00000000..60d2accf
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/00.蜈ｱ騾/C荳螳夐俣髫泌ｦ逅.cs
@@ -0,0 +1,61 @@
+ｻｿusing System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace FDK
+{
+ ///
+ /// 荳螳壹ｮ髢馴囈縺ｧ蜃ｦ逅繧定｡後≧繝繝ｳ繝励Ξ繝ｼ繝医ヱ繧ｿ繝ｼ繝ｳ縺ｮ螳夂ｾｩ縲
+ /// 縺溘→縺医ｰ縲》騾ｲ陦() 縺ｧ 5ms 縺斐→縺ｫ陦後≧蜃ｦ逅繧貞燕蝗槭ｮt騾ｲ陦()縺ｮ蜻ｼ縺ｳ蜃ｺ縺励°繧 15ms 蠕後↓蜻ｼ縺ｳ蜃ｺ縺励◆蝣ｴ蜷医ｯ縲∝ｦ逅縺 3蝗 螳溯｡後＆繧後ｋ縲
+ ///
+ public class C荳螳夐俣髫泌ｦ逅 : IDisposable
+ {
+ public delegate void dg蜃ｦ逅();
+ public void t騾ｲ陦( long n髢馴囈ms, dg蜃ｦ逅 dg蜃ｦ逅 )
+ {
+ // 繧ｿ繧､繝樊峩譁ｰ
+
+ if( this.timer == null )
+ return;
+ this.timer.t譖ｴ譁ｰ();
+
+
+ // 蛻昴ａ縺ｦ縺ｮ騾ｲ陦悟ｦ逅
+
+ if( this.n蜑榊屓縺ｮ譎ょ綾 == CTimer.n譛ｪ菴ｿ逕ｨ )
+ this.n蜑榊屓縺ｮ譎ょ綾 = this.timer.n迴ｾ蝨ｨ譎ょ綾ms;
+
+
+ // 繧ｿ繧､繝槭′荳蝗槭ｊ縺励※縺励∪縺｣縺滓凾縺ｮ縺溘ａ窶ｦ窶ｦ
+
+ if( this.timer.n迴ｾ蝨ｨ譎ょ綾ms < this.n蜑榊屓縺ｮ譎ょ綾 )
+ this.n蜑榊屓縺ｮ譎ょ綾 = this.timer.n迴ｾ蝨ｨ譎ょ綾ms;
+
+
+ // 譎る俣蜀縺ｮ蜃ｦ逅繧貞ｮ溯｡後
+
+ while( ( this.timer.n迴ｾ蝨ｨ譎ょ綾ms - this.n蜑榊屓縺ｮ譎ょ綾 ) >= n髢馴囈ms )
+ {
+ dg蜃ｦ逅();
+
+ this.n蜑榊屓縺ｮ譎ょ綾 += n髢馴囈ms;
+ }
+ }
+
+ #region [ IDisposable 螳溯｣ ]
+ //-----------------
+ public void Dispose()
+ {
+ C蜈ｱ騾.tDispose縺吶ｋ( ref this.timer );
+ }
+ //-----------------
+ #endregion
+
+ #region [ protected ]
+ //-----------------
+ protected CTimer timer = new CTimer( CTimer.E遞ｮ蛻･.MultiMedia );
+ protected long n蜑榊屓縺ｮ譎ょ綾 = CTimer.n譛ｪ菴ｿ逕ｨ;
+ //-----------------
+ #endregion
+ }
+}
diff --git a/FDK19/繧ｳ繝ｼ繝/00.蜈ｱ騾/C蜈ｱ騾.cs b/FDK19/繧ｳ繝ｼ繝/00.蜈ｱ騾/C蜈ｱ騾.cs
new file mode 100644
index 00000000..6de72ecc
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/00.蜈ｱ騾/C蜈ｱ騾.cs
@@ -0,0 +1,180 @@
+ｻｿusing System;
+using System.Collections.Generic;
+using System.Text;
+using System.Diagnostics;
+using System.Windows.Forms;
+using System.IO;
+using System.Runtime.InteropServices;
+
+namespace FDK
+{
+ public class C蜈ｱ騾
+ {
+ // 隗｣謾ｾ
+
+ public static void tDispose縺吶ｋ( ref T obj )
+ {
+ if( obj == null )
+ return;
+
+ var d = obj as IDisposable;
+
+ if( d != null )
+ {
+ d.Dispose();
+ obj = default( T );
+ }
+ }
+ public static void tDispose縺吶ｋ( T obj )
+ {
+ if( obj == null )
+ return;
+
+ var d = obj as IDisposable;
+
+ if( d != null )
+ d.Dispose();
+ }
+ public static void tCOM繧ｪ繝悶ず繧ｧ繧ｯ繝医ｒ隗｣謾ｾ縺吶ｋ( ref T obj )
+ {
+ if( obj != null )
+ {
+ try
+ {
+ Marshal.ReleaseComObject( obj );
+ }
+ catch
+ {
+ // COM縺後槭ロ繝ｼ繧ｸ繝峨さ繝ｼ繝峨〒譖ｸ縺九ｌ縺ｦ縺繧句ｴ蜷医ヽeleaseComObject 縺ｯ萓句､悶ｒ逋ｺ逕溘＆縺帙ｋ縲
+ // http://www.infoq.com/jp/news/2010/03/ReleaseComObject-Dangerous
+ }
+
+ obj = default( T );
+ }
+ }
+
+ public static void t螳悟ｨ縺ｪ繧ｬ繝吶ｼ繧ｸ繧ｳ繝ｬ繧ｯ繧ｷ繝ｧ繝ｳ繧貞ｮ滓命縺吶ｋ()
+ {
+ GC.Collect(); // 繧｢繧ｯ繧ｻ繧ｹ荳榊庄閭ｽ縺ｪ繧ｪ繝悶ず繧ｧ繧ｯ繝医ｒ髯､蜴ｻ縺励√ヵ繧｡繧､繝翫Λ繧､縺懊ｼ繧ｷ繝ｧ繝ｳ螳滓命縲
+ GC.WaitForPendingFinalizers(); // 繝輔ぃ繧､繝翫Λ繧､繧ｼ繝ｼ繧ｷ繝ｧ繝ｳ縺檎ｵゅｏ繧九∪縺ｧ繧ｹ繝ｬ繝繝峨ｒ蠕讖溘
+ GC.Collect(); // 繝輔ぃ繧､繝翫Λ繧､繧ｺ縺輔ｌ縺溘ｰ縺九ｊ縺ｮ繧ｪ繝悶ず繧ｧ繧ｯ繝医↓髢｢騾｣縺吶ｋ繝｡繝｢繝ｪ繧帝幕謾ｾ縲
+
+ // 蜃ｺ螻: http://msdn.microsoft.com/ja-jp/library/ms998547.aspx#scalenetchapt05_topic10
+ }
+
+
+ // 繝ｭ繧ｰ
+
+ public static void LogBlock( string str蜃ｦ逅蜷, MethodInvoker method )
+ {
+ Trace.TraceInformation( "--------------------" );
+ Trace.TraceInformation( "髢句ｧ - " + str蜃ｦ逅蜷 );
+ Trace.Indent();
+ try
+ {
+ method();
+ }
+ finally
+ {
+ Trace.Unindent();
+ Trace.TraceInformation( "邨ゆｺ - " + str蜃ｦ逅蜷 );
+ Trace.TraceInformation( "--------------------" );
+ }
+ }
+ public static void t萓句､悶ｮ隧ｳ邏ｰ繧偵Ο繧ｰ縺ｫ蜃ｺ蜉帙☆繧( Exception e )
+ {
+ Trace.WriteLine( "---萓句､悶％縺薙°繧----" );
+ Trace.WriteLine( e.ToString() );
+ Trace.WriteLine( "---萓句､悶％縺薙∪縺ｧ----" );
+ }
+
+
+ // IO
+
+ public static string t謖螳壹＠縺滓僑蠑ｵ蟄舌ｒ謖√▽繝輔ぃ繧､繝ｫ繧呈､懃ｴ｢縺玲怙蛻昴↓隕九▽縺代◆繝輔ぃ繧､繝ｫ縺ｮ邨ｶ蟇ｾ繝代せ繧定ｿ斐☆( string str繝輔か繝ｫ繝繝代せ, List list諡｡蠑ｵ蟄舌Μ繧ｹ繝 )
+ {
+ string[] files = Directory.GetFiles( str繝輔か繝ｫ繝繝代せ ); // GetFiles() 縺ｯ螳悟ｨ繝代せ繧定ｿ斐☆縲
+
+
+ // 繝輔ぃ繧､繝ｫ鬆繧医ｊ諡｡蠑ｵ蟄宣繧貞━蜈医＠縺ｦ讀懃ｴ｢縺吶ｋ縲や 諡｡蠑ｵ蟄舌Μ繧ｹ繝医ｮ蜑肴婿縺ｮ諡｡蠑ｵ蟄舌⊇縺ｩ蜈医↓逋ｺ隕九＆繧後ｋ繧医≧縺ｫ縺吶ｋ縺溘ａ縲
+
+ foreach( string ext in list諡｡蠑ｵ蟄舌Μ繧ｹ繝 )
+ {
+ foreach( string file in files )
+ {
+ string fileExt = Path.GetExtension( file );
+
+ if( fileExt.Equals( ext, StringComparison.OrdinalIgnoreCase ) )
+ return file; // 縺ゅ▲縺
+ }
+ }
+
+ return null; // 縺ｪ縺九▲縺
+ }
+
+ public static void tXML繝輔ぃ繧､繝ｫ繧定ｪｭ縺ｿ霎ｼ繧( string strXML繝輔ぃ繧､繝ｫ蜷, out T xmlObject )
+ {
+ xmlObject = default( T );
+
+ FileStream fs = null;
+ StreamReader sr = null;
+ try
+ {
+ fs = new FileStream( strXML繝輔ぃ繧､繝ｫ蜷, FileMode.Open, FileAccess.Read, FileShare.ReadWrite ); // FileShare 繧剃ｻ倥¢縺ｨ縺九↑縺縺ｨ縲，lose() 蠕後ｂ繝ｭ繝繧ｯ縺後°縺九ｋ縲
+ sr = new StreamReader( fs, Encoding.UTF8 );
+ var xmlsl = new System.Xml.Serialization.XmlSerializer( typeof( T ) );
+ xmlObject = (T) xmlsl.Deserialize( sr );
+ }
+ finally
+ {
+ if( sr != null )
+ sr.Close(); // fr 繧ゆｸ邱偵↓Close()縺輔ｌ繧
+ }
+ }
+ public static void tXML繝輔ぃ繧､繝ｫ繧剃ｿ晏ｭ倥☆繧( string strXML繝輔ぃ繧､繝ｫ蜷, T xmlObject )
+ {
+ FileStream fs = null;
+ StreamWriter sw = null;
+ try
+ {
+ fs = new FileStream( strXML繝輔ぃ繧､繝ｫ蜷, FileMode.Create, FileAccess.Write, FileShare.ReadWrite ); // FileShare 繧剃ｻ倥¢縺ｨ縺九↑縺縺ｨ縲，lose() 蠕後ｂ繝ｭ繝繧ｯ縺後°縺九ｋ縲
+ sw = new StreamWriter( fs, Encoding.UTF8 );
+ var xmlsl = new System.Xml.Serialization.XmlSerializer( typeof( T ) );
+ xmlsl.Serialize( sw, xmlObject );
+ }
+ finally
+ {
+ if( sw != null )
+ sw.Close(); // fs 繧ゆｸ邱偵↓Close()縺輔ｌ繧
+ }
+ }
+
+
+ // 謨ｰ蟄ｦ
+
+ public static double DegreeToRadian( double angle )
+ {
+ return ( ( Math.PI * angle ) / 180.0 );
+ }
+ public static double RadianToDegree( double angle )
+ {
+ return ( angle * 180.0 / Math.PI );
+ }
+ public static float DegreeToRadian( float angle )
+ {
+ return (float) DegreeToRadian( (double) angle );
+ }
+ public static float RadianToDegree( float angle )
+ {
+ return (float) RadianToDegree( (double) angle );
+ }
+
+ public static bool bToggleBoolian( ref bool bFlag )
+ {
+ if( bFlag == true ) bFlag = false;
+ else if( bFlag == false ) bFlag = true;
+
+ return true;
+ }
+ }
+}
diff --git a/FDK19/繧ｳ繝ｼ繝/00.蜈ｱ騾/C螟画鋤.cs b/FDK19/繧ｳ繝ｼ繝/00.蜈ｱ騾/C螟画鋤.cs
new file mode 100644
index 00000000..4e8b5ef3
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/00.蜈ｱ騾/C螟画鋤.cs
@@ -0,0 +1,252 @@
+ｻｿusing System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace FDK
+{
+ public class C螟画鋤
+ {
+ // 繝励Ο繝代ユ繧｣
+
+ public static readonly string str16騾ｲ謨ｰ譁蟄 = "0123456789ABCDEFabcdef";
+ public static readonly string str36騾ｲ謨ｰ譁蟄 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+
+
+ // 繝｡繧ｽ繝繝
+
+ public static bool bONorOFF( char c )
+ {
+ return ( c != '0' );
+ }
+
+ public static double DegreeToRadian( double angle )
+ {
+ return ( ( Math.PI * angle ) / 180.0 );
+ }
+ public static double RadianToDegree( double angle )
+ {
+ return ( angle * 180.0 / Math.PI );
+ }
+ public static float DegreeToRadian( float angle )
+ {
+ return (float) DegreeToRadian( (double) angle );
+ }
+ public static float RadianToDegree( float angle )
+ {
+ return (float) RadianToDegree( (double) angle );
+ }
+
+ public static int n蛟､繧堤ｯ蝗ｲ蜀縺ｫ荳ｸ繧√※霑斐☆( int n蛟､, int n譛蟆丞､, int n譛螟ｧ蛟､ )
+ {
+ if( n蛟､ < n譛蟆丞､ )
+ return n譛蟆丞､;
+
+ if( n蛟､ > n譛螟ｧ蛟､ )
+ return n譛螟ｧ蛟､;
+
+ return n蛟､;
+ }
+ public static int n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ遽蝗ｲ蜀縺ｫ荳ｸ繧√※霑斐☆( string str謨ｰ蛟､譁蟄怜, int n譛蟆丞､, int n譛螟ｧ蛟､, int n蜿門ｾ怜､ｱ謨玲凾縺ｮ繝繝輔か繝ｫ繝亥､ )
+ {
+ int num;
+ if( ( int.TryParse( str謨ｰ蛟､譁蟄怜, out num ) && ( num >= n譛蟆丞､ ) ) && ( num <= n譛螟ｧ蛟､ ) )
+ return num;
+
+ return n蜿門ｾ怜､ｱ謨玲凾縺ｮ繝繝輔か繝ｫ繝亥､;
+ }
+
+ public static double db蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ遽蝗ｲ蜀縺ｫ荳ｸ繧√※霑斐☆( string str謨ｰ蛟､譁蟄怜, double db譛蟆丞､, double db譛螟ｧ蛟､, double db蜿門ｾ怜､ｱ謨玲凾縺ｮ繝繝輔か繝ｫ繝亥､ )
+ {
+ double num;
+ if( ( double.TryParse( str謨ｰ蛟､譁蟄怜, out num ) && ( num >= db譛蟆丞､ ) ) && ( num <= db譛螟ｧ蛟､ ) )
+ return num;
+
+ return db蜿門ｾ怜､ｱ謨玲凾縺ｮ繝繝輔か繝ｫ繝亥､;
+ }
+
+ // #23568 2010.11.04 ikanick add
+ public static int n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ遽蝗ｲ蜀縺ｫ縺｡繧繧薙→荳ｸ繧√※霑斐☆(string str謨ｰ蛟､譁蟄怜, int n譛蟆丞､, int n譛螟ｧ蛟､, int n蜿門ｾ怜､ｱ謨玲凾縺ｮ繝繝輔か繝ｫ繝亥､)
+ {
+ // 1 縺ｨ驕輔▲縺ｦ遽蝗ｲ螟悶ｮ蝣ｴ蜷医■繧繧薙→荳ｸ繧√※霑斐＠縺ｾ縺吶
+ int num;
+ if (int.TryParse(str謨ｰ蛟､譁蟄怜, out num)) {
+ if ((num >= n譛蟆丞､) && (num <= n譛螟ｧ蛟､))
+ return num;
+ if ( num < n譛蟆丞､ )
+ return n譛蟆丞､;
+ if ( num > n譛螟ｧ蛟､ )
+ return n譛螟ｧ蛟､;
+ }
+
+ return n蜿門ｾ怜､ｱ謨玲凾縺ｮ繝繝輔か繝ｫ繝亥､;
+ }
+ // --------------------縺薙％縺ｾ縺ｧ-------------------------/
+ public static int n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ霑斐☆( string str謨ｰ蛟､譁蟄怜, int n蜿門ｾ怜､ｱ謨玲凾縺ｮ繝繝輔か繝ｫ繝亥､ )
+ {
+ int num;
+ if( !int.TryParse( str謨ｰ蛟､譁蟄怜, out num ) )
+ num = n蜿門ｾ怜､ｱ謨玲凾縺ｮ繝繝輔か繝ｫ繝亥､;
+
+ return num;
+ }
+
+ public static int n16騾ｲ謨ｰ2譯√ｮ譁蟄怜励ｒ謨ｰ蛟､縺ｫ螟画鋤縺励※霑斐☆( string strNum )
+ {
+ if( strNum.Length < 2 )
+ return -1;
+
+ int digit2 = str16騾ｲ謨ｰ譁蟄.IndexOf( strNum[ 0 ] );
+ if( digit2 < 0 )
+ return -1;
+
+ if( digit2 >= 16 )
+ digit2 -= (16 - 10); // A,B,C... -> 1,2,3...
+
+ int digit1 = str16騾ｲ謨ｰ譁蟄.IndexOf( strNum[ 1 ] );
+ if( digit1 < 0 )
+ return -1;
+
+ if( digit1 >= 16 )
+ digit1 -= (16 - 10);
+
+ return digit2 * 16 + digit1;
+ }
+ public static int n36騾ｲ謨ｰ2譯√ｮ譁蟄怜励ｒ謨ｰ蛟､縺ｫ螟画鋤縺励※霑斐☆( string strNum )
+ {
+ if( strNum.Length < 2 )
+ return -1;
+
+ int digit2 = str36騾ｲ謨ｰ譁蟄.IndexOf( strNum[ 0 ] );
+ if( digit2 < 0 )
+ return -1;
+
+ if( digit2 >= 36 )
+ digit2 -= (36 - 10); // A,B,C... -> 1,2,3...
+
+ int digit1 = str36騾ｲ謨ｰ譁蟄.IndexOf( strNum[ 1 ] );
+ if( digit1 < 0 )
+ return -1;
+
+ if( digit1 >= 36 )
+ digit1 -= (36 - 10);
+
+ return digit2 * 36 + digit1;
+ }
+ public static int n蟆冗ｯ逡ｪ蜿ｷ縺ｮ譁蟄怜3譯√ｒ謨ｰ蛟､縺ｫ螟画鋤縺励※霑斐☆( string strNum )
+ {
+ if( strNum.Length >= 3 )
+ {
+ int digit3 = str36騾ｲ謨ｰ譁蟄.IndexOf( strNum[ 0 ] );
+ if( digit3 < 0 )
+ return -1;
+
+ if( digit3 >= 36 ) // 3譯∫岼縺ｯ36騾ｲ謨ｰ
+ digit3 -= (36 - 10);
+
+ int digit2 = str16騾ｲ謨ｰ譁蟄.IndexOf( strNum[ 1 ] ); // 2譯∫岼縺ｯ10騾ｲ謨ｰ
+ if( ( digit2 < 0 ) || ( digit2 > 9 ) )
+ return -1;
+
+ int digit1 = str16騾ｲ謨ｰ譁蟄.IndexOf( strNum[ 2 ] ); // 1譯∫岼繧10騾ｲ謨ｰ
+ if( ( digit1 >= 0 ) && ( digit1 <= 9 ) )
+ return digit3 * 100 + digit2 * 10 + digit1;
+ }
+ return -1;
+ }
+
+ public static string str蟆冗ｯ逡ｪ蜿ｷ繧呈枚蟄怜3譯√↓螟画鋤縺励※霑斐☆( int num )
+ {
+ if( ( num < 0 ) || ( num >= 3600 ) ) // 3600 == Z99 + 1
+ return "000";
+
+ int digit4 = num / 100;
+ int digit2 = ( num % 100 ) / 10;
+ int digit1 = ( num % 100 ) % 10;
+ char ch3 = str36騾ｲ謨ｰ譁蟄夕 digit4 ];
+ char ch2 = str16騾ｲ謨ｰ譁蟄夕 digit2 ];
+ char ch1 = str16騾ｲ謨ｰ譁蟄夕 digit1 ];
+ return ( ch3.ToString() + ch2.ToString() + ch1.ToString() );
+ }
+ public static string str謨ｰ蛟､繧16騾ｲ謨ｰ2譯√↓螟画鋤縺励※霑斐☆( int num )
+ {
+ if( ( num < 0 ) || ( num >= 0x100 ) )
+ return "00";
+
+ char ch2 = str16騾ｲ謨ｰ譁蟄夕 num / 0x10 ];
+ char ch1 = str16騾ｲ謨ｰ譁蟄夕 num % 0x10 ];
+ return ( ch2.ToString() + ch1.ToString() );
+ }
+ public static string str謨ｰ蛟､繧36騾ｲ謨ｰ2譯√↓螟画鋤縺励※霑斐☆( int num )
+ {
+ if( ( num < 0 ) || ( num >= 36 * 36 ) )
+ return "00";
+
+ char ch2 = str36騾ｲ謨ｰ譁蟄夕 num / 36 ];
+ char ch1 = str36騾ｲ謨ｰ譁蟄夕 num % 36 ];
+ return ( ch2.ToString() + ch1.ToString() );
+ }
+
+ public static int[] ar驟榊怜ｽ｢蠑上ｮstring繧段nt驟榊励↓螟画鋤縺励※霑斐☆( string str )
+ {
+ //0,1,2 ...縺ｮ蠖｢蠑上〒譖ｸ縺九ｌ縺殱tring繧段nt驟榊励↓螟画鋤縺吶ｋ縲
+ //荳蠢懷ｮ溯｣縺ｯ縺励◆繧ゅｮ縺ｮ縲∽ｾ句､門ｦ逅縺ｪ縺ｩ縺ｯ縺ｾ縺螳梧舌＠縺ｦ縺縺ｪ縺縲
+ //str = "0,1,2";
+ if( String.IsNullOrEmpty( str ) )
+ return null;
+
+ string[] strArray = str.Split( ',' );
+ List listIntArray;
+ listIntArray = new List();
+
+ for( int n = 0; n < strArray.Length; n++ )
+ {
+ int n霑ｽ蜉縺吶ｋ謨ｰ蛟､ = Convert.ToInt32( strArray[ n ] );
+ listIntArray.Add( n霑ｽ蜉縺吶ｋ謨ｰ蛟､ );
+ }
+ int[] nArray = new int[] { 1 };
+ nArray = listIntArray.ToArray();
+
+ return nArray;
+ }
+
+
+ ///
+ /// 逋ｾ蛻邇謨ｰ蛟､繧255谿ｵ髫取焚蛟､縺ｫ螟画鋤縺吶ｋ繝｡繧ｽ繝繝峨る乗主ｺｦ逕ｨ縲
+ ///
+ ///
+ ///
+ public static int nParsentTo255( double num )
+ {
+ return (int)(255.0 * num);
+ }
+
+ ///
+ /// 255谿ｵ髫取焚蛟､繧堤卆蛻邇縺ｫ螟画鋤縺吶ｋ繝｡繧ｽ繝繝峨
+ ///
+ ///
+ ///
+ public static int n255ToParsent( int num )
+ {
+ return (int)(100.0 / num);
+ }
+
+ public static SlimDX.Color4 n255ToColor4( int nR, int nG, int nB )
+ {
+ float fR = n255ToParsent( nR );
+ float fG = n255ToParsent( nG );
+ float fB = n255ToParsent( nB );
+
+ return new SlimDX.Color4( fR, fG, fB );
+ }
+
+ #region [ private ]
+ //-----------------
+
+ // private 繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ縺ｧ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ逕滓舌ｒ遖∵ｭ｢縺吶ｋ縲
+ private C螟画鋤()
+ {
+ }
+ //-----------------
+ #endregion
+ }
+}
diff --git a/FDK19/繧ｳ繝ｼ繝/00.蜈ｱ騾/ExtensionMethods/DoubleExtensions.cs b/FDK19/繧ｳ繝ｼ繝/00.蜈ｱ騾/ExtensionMethods/DoubleExtensions.cs
new file mode 100644
index 00000000..d7e94c11
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/00.蜈ｱ騾/ExtensionMethods/DoubleExtensions.cs
@@ -0,0 +1,12 @@
+ｻｿusing System;
+
+namespace FDK.ExtensionMethods
+{
+ public static class DoubleExtensions
+ {
+ public static double Clamp(this double value, double min, double max)
+ {
+ return Math.Min(Math.Max(value, min), max);
+ }
+ }
+}
\ No newline at end of file
diff --git a/FDK19/繧ｳ繝ｼ繝/00.蜈ｱ騾/ExtensionMethods/Int32Extensions.cs b/FDK19/繧ｳ繝ｼ繝/00.蜈ｱ騾/ExtensionMethods/Int32Extensions.cs
new file mode 100644
index 00000000..019d3f5d
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/00.蜈ｱ騾/ExtensionMethods/Int32Extensions.cs
@@ -0,0 +1,12 @@
+ｻｿusing System;
+
+namespace FDK.ExtensionMethods
+{
+ public static class Int32Extensions
+ {
+ public static int Clamp(this int value, int min, int max)
+ {
+ return Math.Min(Math.Max(value, min), max);
+ }
+ }
+}
diff --git a/FDK19/繧ｳ繝ｼ繝/01.繝輔Ξ繝ｼ繝繝ｯ繝ｼ繧ｯ/Core/Game.cs b/FDK19/繧ｳ繝ｼ繝/01.繝輔Ξ繝ｼ繝繝ｯ繝ｼ繧ｯ/Core/Game.cs
new file mode 100644
index 00000000..64932ff0
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/01.繝輔Ξ繝ｼ繝繝ｯ繝ｼ繧ｯ/Core/Game.cs
@@ -0,0 +1,569 @@
+ｻｿ/*
+* Copyright (c) 2007-2009 SlimDX Group
+*
+* Permission is hereby granted, free of charge, to any person obtaining a copy
+* of this software and associated documentation files (the "Software"), to deal
+* in the Software without restriction, including without limitation the rights
+* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+* copies of the Software, and to permit persons to whom the Software is
+* furnished to do so, subject to the following conditions:
+*
+* The above copyright notice and this permission notice shall be included in
+* all copies or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+* THE SOFTWARE.
+*/
+using System;
+using System.ComponentModel;
+using System.Threading;
+using System.Windows.Forms;
+using SlimDX;
+using SlimDX.Direct3D9;
+using System.Collections.ObjectModel;
+
+namespace SampleFramework
+{
+ ///
+ /// Presents an easy to use wrapper for making games and samples.
+ ///
+ public abstract class Game : IDisposable
+ {
+ GameClock clock = new GameClock();
+ GameTime gameTime = new GameTime();
+ TimeSpan maximumElapsedTime = TimeSpan.FromMilliseconds(500.0);
+ TimeSpan totalGameTime;
+ TimeSpan accumulatedElapsedGameTime;
+ TimeSpan lastFrameElapsedGameTime;
+ TimeSpan lastFrameElapsedRealTime;
+ TimeSpan targetElapsedTime = TimeSpan.FromTicks(166667);
+ TimeSpan inactiveSleepTime = TimeSpan.FromMilliseconds(20.0);
+ int updatesSinceRunningSlowly1 = int.MaxValue;
+ int updatesSinceRunningSlowly2 = int.MaxValue;
+ bool forceElapsedTimeToZero;
+ bool drawRunningSlowly;
+ long lastUpdateFrame;
+ float lastUpdateTime;
+
+ ///
+ /// Occurs when the game is disposed.
+ ///
+ public event EventHandler Disposed;
+
+ ///
+ /// Occurs when the game is activated.
+ ///
+ public event EventHandler Activated;
+
+ ///
+ /// Occurs when the game is deactivated.
+ ///
+ public event EventHandler Deactivated;
+
+ ///
+ /// Occurs when the game is exiting.
+ ///
+ public event EventHandler Exiting;
+
+ ///
+ /// Occurs when a drawing frame is about to start.
+ ///
+ public event CancelEventHandler FrameStart;
+
+ ///
+ /// Occurs when a drawing frame ends.
+ ///
+ public event EventHandler FrameEnd;
+
+ ///
+ /// Gets or sets the inactive sleep time.
+ ///
+ /// The inactive sleep time.
+ public TimeSpan InactiveSleepTime
+ {
+ get { return inactiveSleepTime; }
+ set
+ {
+ // error checking
+ if (value < TimeSpan.Zero)
+ throw new ArgumentOutOfRangeException("value", "Inactive sleep time cannot be less than zero.");
+ inactiveSleepTime = value;
+ }
+ }
+
+ ///
+ /// Gets or sets the target elapsed time.
+ ///
+ /// The target elapsed time.
+ public TimeSpan TargetElapsedTime
+ {
+ get { return targetElapsedTime; }
+ set
+ {
+ // error checking
+ if (value <= TimeSpan.Zero)
+ throw new ArgumentOutOfRangeException("value", "Target elapsed time must be greater than zero.");
+ targetElapsedTime = value;
+ }
+ }
+
+ ///
+ /// Gets or sets a value indicating whether the game is using a fixed time step.
+ ///
+ ///
+ /// true if the game is using a fixed time step; otherwise, false.
+ ///
+ public bool IsFixedTimeStep
+ {
+ get;
+ set;
+ }
+
+ ///
+ /// Gets a value indicating whether this is exiting.
+ ///
+ /// true if exiting; otherwise, false.
+ public bool IsExiting
+ {
+ get;
+ private set;
+ }
+
+ ///
+ /// Gets or sets a value indicating whether this instance is running.
+ ///
+ ///
+ /// true if this instance is running; otherwise, false.
+ ///
+ public bool IsRunning
+ {
+ get;
+ private set;
+ }
+
+ ///
+ /// Gets the game window.
+ ///
+ /// The game window.
+ public GameWindow Window
+ {
+ get;
+ private set;
+ }
+
+ ///
+ /// Gets the graphics device manager.
+ ///
+ /// The graphics device manager.
+ public GraphicsDeviceManager GraphicsDeviceManager
+ {
+ get;
+ private set;
+ }
+
+ ///
+ /// Gets or sets a value indicating whether this is active.
+ ///
+ /// true if active; otherwise, false.
+ public bool IsActive
+ {
+ get;
+ private set;
+ }
+
+ ///
+ /// Initializes the class.
+ ///
+ static Game()
+ {
+ // configure SlimDX
+ Configuration.ThrowOnError = true;
+ Configuration.AddResultWatch(ResultCode.DeviceLost, ResultWatchFlags.AlwaysIgnore);
+ Configuration.AddResultWatch(ResultCode.WasStillDrawing, ResultWatchFlags.AlwaysIgnore);
+
+#if DEBUG
+ Configuration.DetectDoubleDispose = true;
+ Configuration.EnableObjectTracking = true;
+#else
+ Configuration.DetectDoubleDispose = false;
+ Configuration.EnableObjectTracking = false;
+#endif
+
+ // setup the application
+ Application.EnableVisualStyles();
+ Application.SetCompatibleTextRenderingDefault(false);
+ }
+
+ ///
+ /// Initializes a new instance of the class.
+ ///
+ protected Game()
+ {
+ IsFixedTimeStep = true;
+
+ Window = new GameWindow();
+ Window.ApplicationActivated += Window_ApplicationActivated;
+ Window.ApplicationDeactivated += Window_ApplicationDeactivated;
+ Window.Suspend += Window_Suspend;
+ Window.Resume += Window_Resume;
+ Window.Paint += Window_Paint;
+
+ GraphicsDeviceManager = new GraphicsDeviceManager(this);
+ }
+
+ ///
+ /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
+ ///
+ public void Dispose()
+ {
+ // GraphicsDeviceManager.Dispose will come around and call the Dispose(bool)
+ // overload, so we don't need to do it here. It's convoluted, but it works well.
+ if (GraphicsDeviceManager != null)
+ GraphicsDeviceManager.Dispose();
+ GraphicsDeviceManager = null;
+
+ if (Disposed != null)
+ Disposed(this, EventArgs.Empty);
+
+ GC.SuppressFinalize(this);
+ }
+
+ ///
+ /// Exits the game.
+ ///
+ public void Exit()
+ {
+ // request the game to terminate
+ IsExiting = true;
+ }
+
+ ///
+ /// Runs the game.
+ ///
+ public void Run()
+ {
+ IsRunning = true;
+
+ try
+ {
+ gameTime.ElapsedGameTime = 0;
+ gameTime.ElapsedRealTime = 0;
+ gameTime.TotalGameTime = (float)totalGameTime.TotalSeconds;
+ gameTime.TotalRealTime = (float)clock.CurrentTime.TotalSeconds;
+ gameTime.IsRunningSlowly = false;
+
+ Update(gameTime);
+
+ Application.Idle += Application_Idle;
+ Application.Run(Window);
+ }
+ finally
+ {
+ Application.Idle -= Application_Idle;
+ IsRunning = false;
+ OnExiting(EventArgs.Empty);
+ }
+ }
+
+ ///
+ /// Performs one complete frame for the game.
+ ///
+ public void Tick()
+ {
+ // if we are exiting, do nothing
+ if (IsExiting)
+ return;
+
+ // if we are inactive, sleep for a bit
+ //if (!IsActive)
+ // Thread.Sleep((int)InactiveSleepTime.TotalMilliseconds);
+
+ clock.Step();
+
+ gameTime.TotalRealTime = (float)clock.CurrentTime.TotalSeconds;
+ gameTime.ElapsedRealTime = (float)clock.ElapsedTime.TotalSeconds;
+ lastFrameElapsedRealTime += clock.ElapsedTime;
+ TimeSpan elapsedAdjustedTime = clock.ElapsedAdjustedTime;
+ if (elapsedAdjustedTime < TimeSpan.Zero)
+ elapsedAdjustedTime = TimeSpan.Zero;
+
+ if (forceElapsedTimeToZero)
+ {
+ gameTime.ElapsedRealTime = 0;
+ lastFrameElapsedRealTime = elapsedAdjustedTime = TimeSpan.Zero;
+ forceElapsedTimeToZero = false;
+ }
+
+ // cap the adjusted time
+ if (elapsedAdjustedTime > maximumElapsedTime)
+ elapsedAdjustedTime = maximumElapsedTime;
+
+ // check if we are using a fixed or variable time step
+ if (IsFixedTimeStep)
+ {
+ accumulatedElapsedGameTime += elapsedAdjustedTime;
+ long ratio = accumulatedElapsedGameTime.Ticks / TargetElapsedTime.Ticks;
+ accumulatedElapsedGameTime = TimeSpan.FromTicks(accumulatedElapsedGameTime.Ticks % TargetElapsedTime.Ticks);
+ lastFrameElapsedGameTime = TimeSpan.Zero;
+ if (ratio == 0)
+ return;
+ TimeSpan targetElapsedTime = TargetElapsedTime;
+
+ if (ratio > 1)
+ {
+ updatesSinceRunningSlowly2 = updatesSinceRunningSlowly1;
+ updatesSinceRunningSlowly1 = 0;
+ }
+ else
+ {
+ if (updatesSinceRunningSlowly1 < int.MaxValue)
+ updatesSinceRunningSlowly1++;
+ if (updatesSinceRunningSlowly2 < int.MaxValue)
+ updatesSinceRunningSlowly2++;
+ }
+
+ drawRunningSlowly = updatesSinceRunningSlowly2 < 20;
+
+ // update until it's time to draw the next frame
+ while (ratio > 0 && !IsExiting)
+ {
+ ratio -= 1;
+
+ try
+ {
+ gameTime.ElapsedGameTime = (float)targetElapsedTime.TotalSeconds;
+ gameTime.TotalGameTime = (float)totalGameTime.TotalSeconds;
+ gameTime.IsRunningSlowly = drawRunningSlowly;
+
+ Update(gameTime);
+ }
+ finally
+ {
+ lastFrameElapsedGameTime += targetElapsedTime;
+ totalGameTime += targetElapsedTime;
+ }
+ }
+ }
+ else
+ {
+ drawRunningSlowly = false;
+ updatesSinceRunningSlowly1 = int.MaxValue;
+ updatesSinceRunningSlowly2 = int.MaxValue;
+
+ // make sure we shouldn't be exiting
+ if (!IsExiting)
+ {
+ try
+ {
+ gameTime.ElapsedGameTime = 0;
+ lastFrameElapsedGameTime = elapsedAdjustedTime;
+ gameTime.TotalGameTime = (float)totalGameTime.TotalSeconds;
+ gameTime.IsRunningSlowly = false;
+
+ Update(gameTime);
+ }
+ finally
+ {
+ totalGameTime += elapsedAdjustedTime;
+ }
+ }
+ }
+
+ DrawFrame();
+
+ // refresh the FPS counter once per second
+ lastUpdateFrame++;
+ if ((float)clock.CurrentTime.TotalSeconds - lastUpdateTime > 1.0f)
+ {
+ gameTime.FramesPerSecond = (float)lastUpdateFrame / (float)(clock.CurrentTime.TotalSeconds - lastUpdateTime);
+ lastUpdateTime = (float)clock.CurrentTime.TotalSeconds;
+ lastUpdateFrame = 0;
+ }
+ }
+
+ ///
+ /// Resets the elapsed time.
+ ///
+ public void ResetElapsedTime()
+ {
+ forceElapsedTimeToZero = true;
+ updatesSinceRunningSlowly1 = int.MaxValue;
+ updatesSinceRunningSlowly2 = int.MaxValue;
+ }
+
+ ///
+ /// Allows the game to perform logic processing.
+ ///
+ /// The time passed since the last update.
+ protected virtual void Update(GameTime gameTime)
+ {
+ }
+
+ ///
+ /// Called when a frame is ready to be drawn.
+ ///
+ /// The time passed since the last frame.
+ protected virtual void Draw(GameTime gameTime)
+ {
+ }
+
+ ///
+ /// Initializes the game.
+ ///
+ protected internal virtual void Initialize()
+ {
+ }
+
+ ///
+ /// Loads graphical resources.
+ ///
+ protected internal virtual void LoadContent()
+ {
+ }
+
+ ///
+ /// Unloads graphical resources.
+ ///
+ protected internal virtual void UnloadContent()
+ {
+ }
+
+ ///
+ /// Releases unmanaged and - optionally - managed resources
+ ///
+ /// true to release both managed and unmanaged resources; false to release only unmanaged resources.
+ protected internal virtual void Dispose(bool disposing)
+ {
+
+ }
+
+ ///
+ /// Raises the event.
+ ///
+ /// The instance containing the event data.
+ protected virtual void OnActivated(EventArgs e)
+ {
+ if (Activated != null)
+ Activated(this, e);
+ }
+
+ ///
+ /// Raises the event.
+ ///
+ /// The instance containing the event data.
+ protected virtual void OnDeactivated(EventArgs e)
+ {
+ if (Deactivated != null)
+ Deactivated(this, e);
+ }
+
+ ///
+ /// Raises the event.
+ ///
+ /// The instance containing the event data.
+ protected virtual void OnExiting(EventArgs e)
+ {
+ if (Exiting != null)
+ Exiting(this, e);
+ }
+
+ ///
+ /// Raises the event.
+ ///
+ /// The instance containing the event data.
+ protected virtual void OnFrameStart(CancelEventArgs e)
+ {
+ if (FrameStart != null)
+ FrameStart(this, e);
+ }
+
+ ///
+ /// Raises the event.
+ ///
+ /// The instance containing the event data.
+ protected virtual void OnFrameEnd(EventArgs e)
+ {
+ if (FrameEnd != null)
+ FrameEnd(this, e);
+ }
+
+ void DrawFrame()
+ {
+ try
+ {
+ if ( !IsExiting /* && !Window.IsMinimized */ ) // #28230 2012.5.1 yyagi
+ {
+ CancelEventArgs e = new CancelEventArgs(false);
+ OnFrameStart(e);
+ if (!e.Cancel)
+ {
+ gameTime.TotalRealTime = (float)clock.CurrentTime.TotalSeconds;
+ gameTime.ElapsedRealTime = (float)lastFrameElapsedRealTime.TotalSeconds;
+ gameTime.TotalGameTime = (float)totalGameTime.TotalSeconds;
+ gameTime.ElapsedGameTime = (float)lastFrameElapsedGameTime.TotalSeconds;
+ gameTime.IsRunningSlowly = drawRunningSlowly;
+
+ Draw(gameTime);
+
+ OnFrameEnd(EventArgs.Empty);
+ }
+ }
+ }
+ finally
+ {
+ lastFrameElapsedGameTime = TimeSpan.Zero;
+ lastFrameElapsedRealTime = TimeSpan.Zero;
+ }
+ }
+
+ void Application_Idle(object sender, EventArgs e)
+ {
+ NativeMessage message;
+ while (!NativeMethods.PeekMessage(out message, IntPtr.Zero, 0, 0, 0))
+ {
+ if (IsExiting)
+ Window.Close();
+ else
+ Tick();
+ }
+ }
+
+ void Window_ApplicationDeactivated(object sender, EventArgs e)
+ {
+ if (IsActive)
+ {
+ IsActive = false;
+ OnDeactivated(EventArgs.Empty);
+ }
+ }
+
+ void Window_ApplicationActivated(object sender, EventArgs e)
+ {
+ if (!IsActive)
+ {
+ IsActive = true;
+ OnActivated(EventArgs.Empty);
+ }
+ }
+
+ void Window_Paint(object sender, PaintEventArgs e)
+ {
+ DrawFrame();
+ }
+
+ void Window_Resume(object sender, EventArgs e)
+ {
+ clock.Resume();
+ }
+
+ void Window_Suspend(object sender, EventArgs e)
+ {
+ clock.Suspend();
+ }
+ }
+}
diff --git a/FDK19/繧ｳ繝ｼ繝/01.繝輔Ξ繝ｼ繝繝ｯ繝ｼ繧ｯ/Core/GameClock.cs b/FDK19/繧ｳ繝ｼ繝/01.繝輔Ξ繝ｼ繝繝ｯ繝ｼ繧ｯ/Core/GameClock.cs
new file mode 100644
index 00000000..fe201f18
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/01.繝輔Ξ繝ｼ繝繝ｯ繝ｼ繧ｯ/Core/GameClock.cs
@@ -0,0 +1,153 @@
+ｻｿ/*
+* Copyright (c) 2007-2009 SlimDX Group
+*
+* Permission is hereby granted, free of charge, to any person obtaining a copy
+* of this software and associated documentation files (the "Software"), to deal
+* in the Software without restriction, including without limitation the rights
+* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+* copies of the Software, and to permit persons to whom the Software is
+* furnished to do so, subject to the following conditions:
+*
+* The above copyright notice and this permission notice shall be included in
+* all copies or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+* THE SOFTWARE.
+*/
+using System;
+using System.Diagnostics;
+
+namespace SampleFramework
+{
+ class GameClock
+ {
+ long baseRealTime;
+ long lastRealTime;
+ bool lastRealTimeValid;
+ int suspendCount;
+ long suspendStartTime;
+ long timeLostToSuspension;
+ TimeSpan currentTimeBase;
+ TimeSpan currentTimeOffset;
+
+ public TimeSpan CurrentTime
+ {
+ get { return currentTimeBase + currentTimeOffset; }
+ }
+
+ public TimeSpan ElapsedTime
+ {
+ get;
+ private set;
+ }
+
+ public TimeSpan ElapsedAdjustedTime
+ {
+ get;
+ private set;
+ }
+
+ public static long Frequency
+ {
+ get { return Stopwatch.Frequency; }
+ }
+
+ public GameClock()
+ {
+ Reset();
+ }
+
+ public void Reset()
+ {
+ currentTimeBase = TimeSpan.Zero;
+ currentTimeOffset = TimeSpan.Zero;
+ baseRealTime = Stopwatch.GetTimestamp();
+ lastRealTimeValid = false;
+ }
+
+ public void Suspend()
+ {
+ suspendCount++;
+ if (suspendCount == 1)
+ suspendStartTime = Stopwatch.GetTimestamp();
+ }
+
+ ///
+ /// Resumes a previously suspended clock.
+ ///
+ public void Resume()
+ {
+ suspendCount--;
+ if (suspendCount <= 0)
+ {
+ timeLostToSuspension += Stopwatch.GetTimestamp() - suspendStartTime;
+ suspendStartTime = 0;
+ }
+ }
+
+ public void Step()
+ {
+ long counter = Stopwatch.GetTimestamp();
+
+ if (!lastRealTimeValid)
+ {
+ lastRealTime = counter;
+ lastRealTimeValid = true;
+ }
+
+ try
+ {
+ currentTimeOffset = CounterToTimeSpan(counter - baseRealTime);
+ }
+ catch (OverflowException)
+ {
+ // update the base value and try again to adjust for overflow
+ currentTimeBase += currentTimeOffset;
+ baseRealTime = lastRealTime;
+
+ try
+ {
+ // get the current offset
+ currentTimeOffset = CounterToTimeSpan(counter - baseRealTime);
+ }
+ catch (OverflowException)
+ {
+ // account for overflow
+ baseRealTime = counter;
+ currentTimeOffset = TimeSpan.Zero;
+ }
+ }
+
+ try
+ {
+ ElapsedTime = CounterToTimeSpan(counter - lastRealTime);
+ }
+ catch (OverflowException)
+ {
+ ElapsedTime = TimeSpan.Zero;
+ }
+
+ try
+ {
+ ElapsedAdjustedTime = CounterToTimeSpan(counter - (lastRealTime + timeLostToSuspension));
+ timeLostToSuspension = 0;
+ }
+ catch (OverflowException)
+ {
+ ElapsedAdjustedTime = TimeSpan.Zero;
+ }
+
+ lastRealTime = counter;
+ }
+
+ static TimeSpan CounterToTimeSpan(long delta)
+ {
+ return TimeSpan.FromTicks((delta * 10000000) / Frequency);
+ }
+ }
+}
diff --git a/FDK19/繧ｳ繝ｼ繝/01.繝輔Ξ繝ｼ繝繝ｯ繝ｼ繧ｯ/Core/GameTime.cs b/FDK19/繧ｳ繝ｼ繝/01.繝輔Ξ繝ｼ繝繝ｯ繝ｼ繧ｯ/Core/GameTime.cs
new file mode 100644
index 00000000..904caf26
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/01.繝輔Ξ繝ｼ繝繝ｯ繝ｼ繧ｯ/Core/GameTime.cs
@@ -0,0 +1,120 @@
+ｻｿ/*
+* Copyright (c) 2007-2009 SlimDX Group
+*
+* Permission is hereby granted, free of charge, to any person obtaining a copy
+* of this software and associated documentation files (the "Software"), to deal
+* in the Software without restriction, including without limitation the rights
+* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+* copies of the Software, and to permit persons to whom the Software is
+* furnished to do so, subject to the following conditions:
+*
+* The above copyright notice and this permission notice shall be included in
+* all copies or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+* THE SOFTWARE.
+*/
+
+namespace SampleFramework
+{
+ ///
+ /// Contains the current timing state of the game.
+ ///
+ public class GameTime
+ {
+ private float m_FramesPerSecond;
+ ///
+ /// Gets the current frames-per-second measure.
+ ///
+ /// The current frames-per-second measure.
+ public float FramesPerSecond
+ {
+ get { return m_FramesPerSecond; }
+ internal set { m_FramesPerSecond = value; }
+ }
+
+ private float m_ElapsedGameTime;
+ ///
+ /// Gets the elapsed game time, in seconds.
+ ///
+ /// The elapsed game time.
+ public float ElapsedGameTime
+ {
+ get { return m_ElapsedGameTime; }
+ internal set { m_ElapsedGameTime = value; }
+ }
+
+ private float m_ElapsedRealTime;
+ ///
+ /// Gets the elapsed real time, in seconds.
+ ///
+ /// The elapsed real time.
+ public float ElapsedRealTime
+ {
+ get { return m_ElapsedRealTime; }
+ internal set { m_ElapsedRealTime = value; }
+ }
+
+ private float m_TotalGameTime;
+ ///
+ /// Gets the total game time, in seconds.
+ ///
+ /// The total game time.
+ public float TotalGameTime
+ {
+ get { return m_TotalGameTime; }
+ internal set { m_TotalGameTime = value; }
+ }
+
+ private float m_TotalRealTime;
+ ///
+ /// Gets the total real time, in seconds.
+ ///
+ /// The total real time.
+ public float TotalRealTime
+ {
+ get { return m_TotalRealTime; }
+ internal set { m_TotalRealTime = value; }
+ }
+
+ private bool m_IsRunningSlowly;
+ ///
+ /// Gets or sets a value indicating whether this instance is running slowly.
+ ///
+ ///
+ /// true if this instance is running slowly; otherwise, false.
+ ///
+ public bool IsRunningSlowly
+ {
+ get { return m_IsRunningSlowly; }
+ internal set { m_IsRunningSlowly = value; }
+ }
+
+ ///
+ /// Initializes a new instance of the class.
+ ///
+ public GameTime()
+ {
+ }
+
+ ///
+ /// Initializes a new instance of the class.
+ ///
+ /// The total real time.
+ /// The elapsed real time.
+ /// The total game time.
+ /// The elapsed game time.
+ public GameTime(float totalRealTime, float elapsedRealTime, float totalGameTime, float elapsedGameTime)
+ {
+ TotalRealTime = totalRealTime;
+ ElapsedRealTime = elapsedRealTime;
+ TotalGameTime = totalGameTime;
+ ElapsedGameTime = elapsedGameTime;
+ }
+ }
+}
diff --git a/FDK19/繧ｳ繝ｼ繝/01.繝輔Ξ繝ｼ繝繝ｯ繝ｼ繧ｯ/Core/GameWindow.cs b/FDK19/繧ｳ繝ｼ繝/01.繝輔Ξ繝ｼ繝繝ｯ繝ｼ繧ｯ/Core/GameWindow.cs
new file mode 100644
index 00000000..e4cf1509
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/01.繝輔Ξ繝ｼ繝繝ｯ繝ｼ繧ｯ/Core/GameWindow.cs
@@ -0,0 +1,634 @@
+ｻｿ/*
+* Copyright (c) 2007-2009 SlimDX Group
+*
+* Permission is hereby granted, free of charge, to any person obtaining a copy
+* of this software and associated documentation files (the "Software"), to deal
+* in the Software without restriction, including without limitation the rights
+* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+* copies of the Software, and to permit persons to whom the Software is
+* furnished to do so, subject to the following conditions:
+*
+* The above copyright notice and this permission notice shall be included in
+* all copies or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+* THE SOFTWARE.
+*/
+using System;
+using System.ComponentModel;
+using System.Drawing;
+using System.IO;
+using System.Reflection;
+using System.Security.Permissions;
+using System.Windows.Forms;
+using System.Runtime.InteropServices;
+using System.Diagnostics;
+using SampleFramework.Properties;
+
+namespace SampleFramework
+{
+ ///
+ /// Implements a specialized window for games and rendering.
+ ///
+ public class GameWindow : Form
+ {
+ const int DefaultWidth = 800;
+ const int DefaultHeight = 600;
+ const string DefaultTitle = "Game";
+
+ Size cachedSize;
+ bool minimized;
+ bool maximized;
+ bool inSizeMove;
+
+ ///
+ /// Occurs when the application is suspended.
+ ///
+ public event EventHandler Suspend;
+
+ ///
+ /// Occurs when the application is resumed.
+ ///
+ public event EventHandler Resume;
+
+ ///
+ /// Occurs when the user resizes the window.
+ ///
+ public event EventHandler UserResized;
+
+ ///
+ /// Occurs when the screen on which the window resides is changed.
+ ///
+ public event EventHandler ScreenChanged;
+
+ ///
+ /// Occurs when the application is activated.
+ ///
+ public event EventHandler ApplicationActivated;
+
+ ///
+ /// Occurs when the application is deactivated.
+ ///
+ public event EventHandler ApplicationDeactivated;
+
+ ///
+ /// Occurs when the system is suspended.
+ ///
+ public event EventHandler SystemSuspend;
+
+ ///
+ /// Occurs when the system is resumed.
+ ///
+ public event EventHandler SystemResume;
+
+ ///
+ /// Occurs when a screen saver is about to be activated.
+ ///
+ public event CancelEventHandler Screensaver;
+
+ ///
+ /// Gets a value indicating whether this instance is minimized.
+ ///
+ ///
+ /// true if this instance is minimized; otherwise, false.
+ ///
+ public bool IsMinimized
+ {
+ get { return minimized; }
+ }
+
+ ///
+ /// Gets a value indicating whether this instance is maximized.
+ ///
+ ///
+ /// true if this instance is maximized; otherwise, false.
+ ///
+ public bool IsMaximized
+ {
+ get { return maximized; }
+ }
+
+ ///
+ /// Gets or sets a value indicating whether System Menu is enabled.
+ ///
+ /// true if System Menu is enabled; otherwise, false.
+ public bool EnableSystemMenu // #28200 2012.5.1 yyagi
+ {
+ get;
+ set;
+ }
+ public string strMessage // #28821 2014.1.23 yyagi
+ {
+ get;
+ private set;
+ }
+ public bool IsReceivedMessage
+ {
+ get;
+ set;
+ }
+
+ private Screen m_Screen;
+ ///
+ /// Gets the screen on which the window resides.
+ ///
+ /// The screen.
+ public Screen Screen
+ {
+ get { return m_Screen; }
+ private set { m_Screen = value; }
+ }
+
+ ///
+ /// Initializes a new instance of the class.
+ ///
+ public GameWindow()
+ {
+ MinimumSize = new Size(200, 200);
+
+ Screen = ScreenFromHandle(Handle);
+
+ //Icon = GetDefaultIcon();
+ Text = GetDefaultTitle();
+ strMessage = "";
+ }
+
+ ///
+ /// Raises the event.
+ ///
+ /// The instance containing the event data.
+ protected virtual void OnSuspend(EventArgs e)
+ {
+ if (Suspend != null)
+ Suspend(this, e);
+ }
+
+ ///
+ /// Raises the event.
+ ///
+ /// The instance containing the event data.
+ protected virtual void OnResume(EventArgs e)
+ {
+ if (Resume != null)
+ Resume(this, e);
+ }
+
+ ///
+ /// Raises the event.
+ ///
+ /// The instance containing the event data.
+ protected virtual void OnUserResized(EventArgs e)
+ {
+ if (UserResized != null)
+ UserResized(this, e);
+ }
+
+ ///
+ /// Raises the event.
+ ///
+ /// The instance containing the event data.
+ protected virtual void OnScreenChanged(EventArgs e)
+ {
+ if (ScreenChanged != null)
+ ScreenChanged(this, e);
+ }
+
+ ///
+ /// Raises the event.
+ ///
+ /// The instance containing the event data.
+ protected virtual void OnApplicationActivated(EventArgs e)
+ {
+ if (ApplicationActivated != null)
+ ApplicationActivated(this, e);
+ }
+
+ ///
+ /// Raises the event.
+ ///
+ /// The instance containing the event data.
+ protected virtual void OnApplicationDeactivated(EventArgs e)
+ {
+ if (ApplicationDeactivated != null)
+ ApplicationDeactivated(this, e);
+ }
+
+ ///
+ /// Raises the event.
+ ///
+ /// The instance containing the event data.
+ protected virtual void OnSystemSuspend(EventArgs e)
+ {
+ if (SystemSuspend != null)
+ SystemSuspend(this, e);
+ }
+
+ ///
+ /// Raises the event.
+ ///
+ /// The instance containing the event data.
+ protected virtual void OnSystemResume(EventArgs e)
+ {
+ if (SystemResume != null)
+ SystemResume(this, e);
+ }
+
+ ///
+ /// Raises the event.
+ ///
+ /// The instance containing the event data.
+ protected virtual void OnScreensaver(CancelEventArgs e)
+ {
+ if (Screensaver != null)
+ Screensaver(this, e);
+ }
+
+ ///
+ /// Raises the event.
+ ///
+ /// An that contains the event data.
+ protected override void OnLoad(EventArgs e)
+ {
+ base.OnLoad(e);
+
+ cachedSize = Size;
+ }
+
+ ///
+ /// Raises the event.
+ ///
+ /// A that contains the event data.
+ protected override void OnResizeBegin(EventArgs e)
+ {
+ base.OnResizeBegin(e);
+
+ // suspend any processing until we are done being minimized
+ inSizeMove = true;
+ cachedSize = Size;
+ OnSuspend(EventArgs.Empty);
+ }
+
+ ///
+ /// Raises the event.
+ ///
+ /// A that contains the event data.
+ protected override void OnResizeEnd(EventArgs e)
+ {
+ base.OnResizeEnd(e);
+
+ // check for screen and size changes
+ OnUserResized(EventArgs.Empty);
+ UpdateScreen();
+ inSizeMove = false;
+
+ // resume application processing
+ OnResume(EventArgs.Empty);
+ }
+
+
+ #region #23510 2010.11.14 yyagi add: 邵ｦ讓ｪ豈泌崋螳壹〒縺ｮ繧ｦ繧､繝ｳ繝峨え繧ｵ繧､繧ｺ螟画峩 螳壽焚螳夂ｾｩ from http://www.vcskicks.com/maintain-aspect-ratio.php
+ //double so division keeps decimal points
+ const double widthRatio = SampleFramework.GameWindowSize.Width;
+ const double heightRatio = SampleFramework.GameWindowSize.Height;
+ const int WM_SIZING = 0x214;
+ const int WMSZ_LEFT = 1;
+ const int WMSZ_RIGHT = 2;
+ const int WMSZ_TOP = 3;
+ const int WMSZ_TOPLEFT = 4;
+ const int WMSZ_TOPRIGHT = 5;
+ const int WMSZ_BOTTOM = 6;
+ const int WMSZ_BOTTOMLEFT = 7;
+ const int WMSZ_BOTTOMRIGHT = 8;
+
+ public struct RECT
+ {
+ public int Left;
+ public int Top;
+ public int Right;
+ public int Bottom;
+ }
+ #endregion
+
+
+
+ ///
+ /// Handles raw window messages.
+ ///
+ /// The raw message.
+ [SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.UnmanagedCode)]
+ protected override void WndProc(ref Message m)
+ {
+ if (m.Msg == WindowConstants.WM_SIZE)
+ {
+ if (m.WParam == WindowConstants.SIZE_MINIMIZED)
+ {
+ minimized = true;
+ maximized = false;
+
+ OnSuspend(EventArgs.Empty);
+ }
+ else
+ {
+ Rectangle client = NativeMethods.GetClientRectangle(m.HWnd);
+ if (client.Height == 0)
+ {
+ // rapidly clicking the task bar to minimize and restore a window
+ // can cause a WM_SIZE message with SIZE_RESTORED when
+ // the window has actually become minimized due to rapid change
+ // so just ignore this message
+ }
+ else if (m.WParam == WindowConstants.SIZE_MAXIMIZED)
+ {
+ if (minimized)
+ OnResume(EventArgs.Empty);
+
+ minimized = false;
+ maximized = true;
+
+ OnUserResized(EventArgs.Empty);
+ UpdateScreen();
+ }
+ else if (m.WParam == WindowConstants.SIZE_RESTORED)
+ {
+ if (minimized)
+ OnResume(EventArgs.Empty);
+
+ minimized = false;
+ maximized = false;
+
+ if (!inSizeMove && Size != cachedSize)
+ {
+ OnUserResized(EventArgs.Empty);
+ UpdateScreen();
+ cachedSize = Size;
+ }
+ }
+ }
+ }
+ else if (m.Msg == WindowConstants.WM_ACTIVATEAPP)
+ {
+ if (m.WParam != IntPtr.Zero)
+ OnApplicationActivated(EventArgs.Empty);
+ else
+ OnApplicationDeactivated(EventArgs.Empty);
+ }
+ else if (m.Msg == WindowConstants.WM_POWERBROADCAST)
+ {
+ if (m.WParam == WindowConstants.PBT_APMQUERYSUSPEND)
+ {
+ OnSystemSuspend(EventArgs.Empty);
+ m.Result = (IntPtr)1;
+ return;
+ }
+ else if (m.WParam == WindowConstants.PBT_APMRESUMESUSPEND)
+ {
+ OnSystemResume(EventArgs.Empty);
+ m.Result = (IntPtr)1;
+ return;
+ }
+ }
+ else if (m.Msg == WindowConstants.WM_SYSCOMMAND)
+ {
+ long wparam = m.WParam.ToInt64() & 0xFFF0;
+ if (wparam == WindowConstants.SC_MONITORPOWER || wparam == WindowConstants.SC_SCREENSAVE)
+ {
+ CancelEventArgs e = new CancelEventArgs();
+ OnScreensaver(e);
+ if (e.Cancel)
+ {
+ m.Result = IntPtr.Zero;
+ return;
+ }
+ }
+ #region #28200 2012.5.1 yyagi: Disable system menu
+ if ( ( m.WParam.ToInt32() & 0xFFFF ) == 0xF100 && !EnableSystemMenu ) // SC_KEYMENU
+ {
+ m.Result = IntPtr.Zero;
+ return;
+ }
+ #endregion
+ #region #23510 2010.11.13 yyagi: reset to 640x480
+ if ((m.WParam.ToInt32() & 0xFFFF) == MENU_VIEW)
+ {
+ base.ClientSize = new Size(SampleFramework.GameWindowSize.Width, SampleFramework.GameWindowSize.Height);
+ this.OnResizeEnd(new EventArgs()); // #23510 2010.11.20 yyagi: to set window size to Config.ini
+ }
+ #endregion
+ }
+ #region #28821 2014.1.23 yyagi (WM_COPYDATA)
+ else if ( m.Msg == WindowConstants.WM_COPYDATA )
+ {
+//Trace.WriteLine( "FDK;msg received" );
+ COPYDATASTRUCT cds = (COPYDATASTRUCT) Marshal.PtrToStructure( m.LParam, typeof( COPYDATASTRUCT ) );
+ strMessage = Marshal.PtrToStringUni( cds.lpData );
+ IsReceivedMessage = true;
+//Trace.WriteLine( "FDK;msg=" + strMessage + ", len=" + strMessage.Length + ", truelen=" + cds.cbData );
+ }
+ #endregion
+ #region #23510 2010.11.16 yyagi add: 邵ｦ讓ｪ豈泌崋螳壹〒縺ｮ繧ｦ繧､繝ｳ繝峨え繧ｵ繧､繧ｺ螟画峩 from http://d.hatena.ne.jp/iselix/20080917/1221666614 http://hp.vector.co.jp/authors/VA016117/sizing.html
+ else if ( m.Msg == WM_SIZING )
+ {
+ RECT rc = (RECT) Marshal.PtrToStructure( m.LParam, typeof( RECT ) );
+ int w = rc.Right - rc.Left - ( Size.Width - ClientSize.Width );
+ int h = rc.Bottom - rc.Top - ( Size.Height - ClientSize.Height );
+ int dw = (int) ( h * widthRatio / heightRatio + 0.5 ) - w;
+ int dh = (int) ( w / ( widthRatio / heightRatio ) + 0.5 ) - h;
+
+ switch ( m.WParam.ToInt32() )
+ {
+ case WMSZ_LEFT:
+ case WMSZ_RIGHT:
+ rc.Bottom += dh;
+ break;
+ case WMSZ_TOP:
+ case WMSZ_BOTTOM:
+ rc.Right += dw;
+ break;
+ case WMSZ_BOTTOMRIGHT:
+ if ( dw > 0 )
+ {
+ rc.Right += dw;
+ }
+ else
+ {
+ rc.Bottom += dh;
+ }
+ break;
+ case WMSZ_TOPLEFT:
+ if ( dw > 0 )
+ {
+ rc.Left -= dw;
+ }
+ else
+ {
+ rc.Top -= dh;
+ }
+ break;
+ case WMSZ_TOPRIGHT:
+ if ( dw > 0 )
+ {
+ rc.Right += dw;
+ }
+ else
+ {
+ rc.Top -= dh;
+ }
+ break;
+ case WMSZ_BOTTOMLEFT:
+ if ( dw > 0 )
+ {
+ rc.Left -= dw;
+ }
+ else
+ {
+ rc.Bottom += dh;
+ }
+ break;
+ case 9: // #32383 2013.11.2 yyagi; exitting maximized window by using Aero snap
+ break;
+ default:
+ throw new ArgumentOutOfRangeException( "value", "Illegal WM_SIZING value." );
+ }
+ Marshal.StructureToPtr( rc, m.LParam, true );
+ }
+ #endregion
+
+
+ base.WndProc(ref m);
+ }
+
+ void UpdateScreen()
+ {
+ Screen current = Screen.FromHandle(Handle);
+ if (Screen == null || Screen.DeviceName != current.DeviceName)
+ {
+ Screen = current;
+ if (Screen != null)
+ OnScreenChanged(EventArgs.Empty);
+ }
+ }
+
+ static Screen ScreenFromHandle(IntPtr windowHandle)
+ {
+ Rectangle rectangle = NativeMethods.GetWindowRectangle(windowHandle);
+
+ Screen bestScreen = null;
+ int mostArea = 0;
+ foreach (Screen screen in Screen.AllScreens)
+ {
+ Rectangle r = Rectangle.Intersect(rectangle, screen.Bounds);
+ int area = r.Width * r.Height;
+
+ if (area > mostArea)
+ {
+ mostArea = area;
+ bestScreen = screen;
+ }
+ }
+
+ if (bestScreen == null)
+ bestScreen = Screen.PrimaryScreen;
+ return bestScreen;
+ }
+
+ static string GetAssemblyTitle(Assembly assembly)
+ {
+ if (assembly == null)
+ return null;
+
+ AssemblyTitleAttribute[] customAttributes = (AssemblyTitleAttribute[])assembly.GetCustomAttributes(typeof(AssemblyTitleAttribute), true);
+ if (customAttributes != null && customAttributes.Length > 0)
+ return customAttributes[0].Title;
+
+ return null;
+ }
+
+ static string GetDefaultTitle()
+ {
+ string assemblyTitle = GetAssemblyTitle(Assembly.GetEntryAssembly());
+ if (!string.IsNullOrEmpty(assemblyTitle))
+ return assemblyTitle;
+
+ try
+ {
+ Uri uri = new Uri(Application.ExecutablePath);
+ return Path.GetFileNameWithoutExtension(uri.LocalPath);
+ }
+ catch (ArgumentNullException e)
+ {
+ Trace.TraceError( e.ToString() );
+ Trace.TraceError( "萓句､悶′逋ｺ逕溘＠縺ｾ縺励◆縺悟ｦ逅繧堤ｶ咏ｶ壹＠縺ｾ縺吶 (6216f3e1-e1a5-45ca-bfd8-30bbc44bfa9a)" );
+ }
+ catch (UriFormatException e)
+ {
+ Trace.TraceError( e.ToString() );
+ Trace.TraceError( "萓句､悶′逋ｺ逕溘＠縺ｾ縺励◆縺悟ｦ逅繧堤ｶ咏ｶ壹＠縺ｾ縺吶 (771f37b5-0b56-4a47-933e-3c178b3e27a7)" );
+ }
+
+ return DefaultTitle;
+ }
+
+ static Icon GetDefaultIcon()
+ {
+ return (Icon)Resources.sdx_icon_black.Clone();
+ }
+
+ #region 繧ｷ繧ｹ繝繝繝｡繝九Η繝ｼ縺ｫ"640x480"繧定ｿｽ蜉 #23510 2010.11.13 yyagi add: to set "640x480" menu in systemmenu. See also http://cs2ch.blog123.fc2.com/blog-entry-80.html
+ [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
+ private struct MENUITEMINFO
+ {
+ public uint cbSize;
+ public uint fMask;
+ public uint fType;
+ public uint fState;
+ public uint wID;
+ public IntPtr hSubMenu;
+ public IntPtr hbmpChecked;
+ public IntPtr hbmpUnchecked;
+ public IntPtr dwItemData;
+ public string dwTypeData;
+ public uint cch;
+ public IntPtr hbmpItem;
+ }
+
+ [DllImport("user32", ExactSpelling = true)]
+ private static extern IntPtr GetSystemMenu(IntPtr hWnd, bool bRevert);
+ [DllImport("user32", CharSet = CharSet.Auto)]
+ private static extern bool InsertMenuItem(IntPtr hMenu, uint uItem, bool fByPosition, ref MENUITEMINFO lpmii);
+
+ private const uint MENU_VIEW = 0x9999;
+ private const uint MFT_SEPARATOR = 0x00000800;
+ private const uint MIIM_FTYPE = 0x00000100;
+ private const uint MIIM_STRING = 0x00000040;
+ private const uint MIIM_ID = 0x00000002;
+
+ protected override void OnCreateControl()
+ {
+ base.OnCreateControl();
+
+ //繧ｷ繧ｹ繝繝繝｡繝九Η繝ｼ縺ｮ繝上Φ繝峨Ν蜿門ｾ
+ IntPtr hSysMenu = GetSystemMenu(this.Handle, false);
+
+ //繧ｻ繝代Ξ繝ｼ繧ｿ繝ｼ縺ｮ謖ｿ蜈･
+ MENUITEMINFO item1 = new MENUITEMINFO();
+ item1.cbSize = (uint)Marshal.SizeOf(item1);
+ item1.fMask = MIIM_FTYPE;
+ item1.fType = MFT_SEPARATOR;
+ InsertMenuItem(hSysMenu, 5, true, ref item1);
+
+ //繝｡繝九Η繝ｼ鬆逶ｮ縺ｮ謖ｿ蜈･
+ MENUITEMINFO item2 = new MENUITEMINFO();
+ item2.cbSize = (uint)Marshal.SizeOf(item2);
+ item2.fMask = MIIM_STRING | MIIM_ID;
+ item2.wID = MENU_VIEW;
+ item2.dwTypeData = "&" + SampleFramework.GameWindowSize.Width.ToString() + "x" + SampleFramework.GameWindowSize.Height.ToString();
+ InsertMenuItem(hSysMenu, 6, true, ref item2);
+ }
+ #endregion
+ }
+}
diff --git a/FDK19/繧ｳ繝ｼ繝/01.繝輔Ξ繝ｼ繝繝ｯ繝ｼ繧ｯ/Core/GameWindow.resx b/FDK19/繧ｳ繝ｼ繝/01.繝輔Ξ繝ｼ繝繝ｯ繝ｼ繧ｯ/Core/GameWindow.resx
new file mode 100644
index 00000000..1af7de15
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/01.繝輔Ξ繝ｼ繝繝ｯ繝ｼ繧ｯ/Core/GameWindow.resx
@@ -0,0 +1,120 @@
+ｻｿ
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ text/microsoft-resx
+
+
+ 2.0
+
+
+ System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
+
+
+ System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
+
+
\ No newline at end of file
diff --git a/FDK19/繧ｳ繝ｼ繝/01.繝輔Ξ繝ｼ繝繝ｯ繝ｼ繧ｯ/Core/GameWindowSize.cs b/FDK19/繧ｳ繝ｼ繝/01.繝輔Ξ繝ｼ繝繝ｯ繝ｼ繧ｯ/Core/GameWindowSize.cs
new file mode 100644
index 00000000..2d7a1c58
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/01.繝輔Ξ繝ｼ繝繝ｯ繝ｼ繧ｯ/Core/GameWindowSize.cs
@@ -0,0 +1,10 @@
+using System;
+
+namespace SampleFramework
+{
+ public static class GameWindowSize
+ {
+ public const int Width = 1280;
+ public const int Height = 720;
+ }
+}
diff --git a/FDK19/繧ｳ繝ｼ繝/01.繝輔Ξ繝ｼ繝繝ｯ繝ｼ繧ｯ/DeviceSettings/ConversionMethods.cs b/FDK19/繧ｳ繝ｼ繝/01.繝輔Ξ繝ｼ繝繝ｯ繝ｼ繧ｯ/DeviceSettings/ConversionMethods.cs
new file mode 100644
index 00000000..60915b37
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/01.繝輔Ξ繝ｼ繝繝ｯ繝ｼ繧ｯ/DeviceSettings/ConversionMethods.cs
@@ -0,0 +1,204 @@
+ｻｿ/*
+* Copyright (c) 2007-2009 SlimDX Group
+*
+* Permission is hereby granted, free of charge, to any person obtaining a copy
+* of this software and associated documentation files (the "Software"), to deal
+* in the Software without restriction, including without limitation the rights
+* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+* copies of the Software, and to permit persons to whom the Software is
+* furnished to do so, subject to the following conditions:
+*
+* The above copyright notice and this permission notice shall be included in
+* all copies or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+* THE SOFTWARE.
+*/
+using SlimDX;
+using SlimDX.Direct3D9;
+using DXGI = SlimDX.DXGI;
+
+namespace SampleFramework
+{
+ static class ConversionMethods
+ {
+ public static int GetDepthBits(Format format)
+ {
+ switch (format)
+ {
+ case Format.D32SingleLockable:
+ case Format.D32:
+ return 32;
+
+ case Format.D24X8:
+ case Format.D24S8:
+ case Format.D24X4S4:
+ case Format.D24SingleS8:
+ return 24;
+
+ case Format.D16Lockable:
+ case Format.D16:
+ return 16;
+
+ case Format.D15S1:
+ return 15;
+
+ default:
+ return 0;
+ }
+ }
+
+ public static int GetStencilBits(Format format)
+ {
+ switch (format)
+ {
+ case Format.D15S1:
+ return 1;
+
+ case Format.D24X4S4:
+ return 4;
+
+ case Format.D24S8:
+ case Format.D24SingleS8:
+ return 8;
+
+ default:
+ return 0;
+ }
+ }
+
+ public static int GetColorBits(Format format)
+ {
+ switch (format)
+ {
+ case Format.R8G8B8:
+ case Format.A8R8G8B8:
+ case Format.A8B8G8R8:
+ case Format.X8R8G8B8:
+ return 8;
+
+ case Format.R5G6B5:
+ case Format.X1R5G5B5:
+ case Format.A1R5G5B5:
+ return 5;
+
+ case Format.A4R4G4B4:
+ case Format.X4R4G4B4:
+ return 4;
+
+ case Format.R3G3B2:
+ case Format.A8R3G3B2:
+ return 2;
+
+ case Format.A2R10G10B10:
+ case Format.A2B10G10R10:
+ return 10;
+
+ case Format.A16B16G16R16:
+ return 16;
+
+ default:
+ return 0;
+ }
+ }
+
+ public static int GetColorBits(DXGI.Format format)
+ {
+ switch (format)
+ {
+ case SlimDX.DXGI.Format.R32G32B32A32_Float:
+ case SlimDX.DXGI.Format.R32G32B32A32_SInt:
+ case SlimDX.DXGI.Format.R32G32B32A32_Typeless:
+ case SlimDX.DXGI.Format.R32G32B32A32_UInt:
+ case SlimDX.DXGI.Format.R32G32B32_Float:
+ case SlimDX.DXGI.Format.R32G32B32_SInt:
+ case SlimDX.DXGI.Format.R32G32B32_Typeless:
+ case SlimDX.DXGI.Format.R32G32B32_UInt:
+ return 32;
+
+ case SlimDX.DXGI.Format.R16G16B16A16_Float:
+ case SlimDX.DXGI.Format.R16G16B16A16_SInt:
+ case SlimDX.DXGI.Format.R16G16B16A16_SNorm:
+ case SlimDX.DXGI.Format.R16G16B16A16_Typeless:
+ case SlimDX.DXGI.Format.R16G16B16A16_UInt:
+ case SlimDX.DXGI.Format.R16G16B16A16_UNorm:
+ return 16;
+
+ case SlimDX.DXGI.Format.R10G10B10A2_Typeless:
+ case SlimDX.DXGI.Format.R10G10B10A2_UInt:
+ case SlimDX.DXGI.Format.R10G10B10A2_UNorm:
+ return 10;
+
+ case SlimDX.DXGI.Format.R8G8B8A8_SInt:
+ case SlimDX.DXGI.Format.R8G8B8A8_SNorm:
+ case SlimDX.DXGI.Format.R8G8B8A8_Typeless:
+ case SlimDX.DXGI.Format.R8G8B8A8_UInt:
+ case SlimDX.DXGI.Format.R8G8B8A8_UNorm:
+ case SlimDX.DXGI.Format.R8G8B8A8_UNorm_SRGB:
+ return 8;
+
+ case SlimDX.DXGI.Format.B5G5R5A1_UNorm:
+ case SlimDX.DXGI.Format.B5G6R5_UNorm:
+ return 5;
+
+ default:
+ return 0;
+ }
+ }
+
+ public static MultisampleType ToDirect3D9(int type)
+ {
+ return (MultisampleType)type;
+ }
+
+ public static Format ToDirect3D9(DXGI.Format format)
+ {
+ switch (format)
+ {
+ case SlimDX.DXGI.Format.R8G8B8A8_UNorm:
+ return Format.A8R8G8B8;
+ case SlimDX.DXGI.Format.B5G6R5_UNorm:
+ return Format.R5G6B5;
+ case SlimDX.DXGI.Format.B5G5R5A1_UNorm:
+ return Format.A1R5G5B5;
+ case SlimDX.DXGI.Format.A8_UNorm:
+ return Format.A8;
+ case SlimDX.DXGI.Format.R10G10B10A2_UNorm:
+ return Format.A2B10G10R10;
+ case SlimDX.DXGI.Format.B8G8R8A8_UNorm:
+ return Format.A8B8G8R8;
+ case SlimDX.DXGI.Format.R16G16_UNorm:
+ return Format.G16R16;
+ case SlimDX.DXGI.Format.R16G16B16A16_UNorm:
+ return Format.A16B16G16R16;
+ case SlimDX.DXGI.Format.R16_Float:
+ return Format.R16F;
+ case SlimDX.DXGI.Format.R16G16_Float:
+ return Format.G16R16F;
+ case SlimDX.DXGI.Format.R16G16B16A16_Float:
+ return Format.A16B16G16R16F;
+ case SlimDX.DXGI.Format.R32_Float:
+ return Format.R32F;
+ case SlimDX.DXGI.Format.R32G32_Float:
+ return Format.G32R32F;
+ case SlimDX.DXGI.Format.R32G32B32A32_Float:
+ return Format.A32B32G32R32F;
+ }
+
+ return Format.Unknown;
+ }
+
+ public static float ToFloat(Rational rational)
+ {
+ float denom = 1;
+ if (rational.Denominator != 0)
+ denom = rational.Denominator;
+ return rational.Numerator / denom;
+ }
+ }
+}
diff --git a/FDK19/繧ｳ繝ｼ繝/01.繝輔Ξ繝ｼ繝繝ｯ繝ｼ繧ｯ/DeviceSettings/DeviceSettings.cs b/FDK19/繧ｳ繝ｼ繝/01.繝輔Ξ繝ｼ繝繝ｯ繝ｼ繧ｯ/DeviceSettings/DeviceSettings.cs
new file mode 100644
index 00000000..80063121
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/01.繝輔Ξ繝ｼ繝繝ｯ繝ｼ繧ｯ/DeviceSettings/DeviceSettings.cs
@@ -0,0 +1,285 @@
+ｻｿ/*
+* Copyright (c) 2007-2009 SlimDX Group
+*
+* Permission is hereby granted, free of charge, to any person obtaining a copy
+* of this software and associated documentation files (the "Software"), to deal
+* in the Software without restriction, including without limitation the rights
+* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+* copies of the Software, and to permit persons to whom the Software is
+* furnished to do so, subject to the following conditions:
+*
+* The above copyright notice and this permission notice shall be included in
+* all copies or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+* THE SOFTWARE.
+*/
+using System;
+using SlimDX.Direct3D9;
+namespace SampleFramework
+{
+ ///
+ /// Contains settings for creating a 3D device.
+ ///
+ public class DeviceSettings : ICloneable
+ {
+ ///
+ /// Gets or sets the adapter ordinal.
+ ///
+ /// The adapter ordinal.
+ public int AdapterOrdinal
+ {
+ get;
+ set;
+ }
+
+ ///
+ /// Gets or sets the type of the device.
+ ///
+ /// The type of the device.
+ public DeviceType DeviceType
+ {
+ get;
+ set;
+ }
+
+ ///
+ /// Gets or sets the refresh rate.
+ ///
+ /// The refresh rate.
+ public int RefreshRate
+ {
+ get;
+ set;
+ }
+
+ ///
+ /// Gets or sets the width of the back buffer.
+ ///
+ /// The width of the back buffer.
+ public int BackBufferWidth
+ {
+ get;
+ set;
+ }
+
+ ///
+ /// Gets or sets the height of the back buffer.
+ ///
+ /// The height of the back buffer.
+ public int BackBufferHeight
+ {
+ get;
+ set;
+ }
+
+ ///
+ /// Gets or sets the back buffer format.
+ ///
+ /// The back buffer format.
+ public Format BackBufferFormat
+ {
+ get;
+ set;
+ }
+
+ ///
+ /// Gets or sets the back buffer count.
+ ///
+ /// The back buffer count.
+ public int BackBufferCount
+ {
+ get;
+ set;
+ }
+
+ ///
+ /// Gets or sets a value indicating whether the device is windowed.
+ ///
+ /// true if windowed; otherwise, false.
+ public bool Windowed
+ {
+ get;
+ set;
+ }
+
+ ///
+ /// Gets or sets a value indicating whether VSync is enabled.
+ ///
+ /// true if VSync is enabled; otherwise, false.
+ public bool EnableVSync
+ {
+ get;
+ set;
+ }
+
+ ///
+ /// Gets or sets a value indicating whether this is multithreaded.
+ ///
+ /// true if multithreaded; otherwise, false.
+ /// This only has an effect for Direct3D9 devices.
+ public bool Multithreaded
+ {
+ get;
+ set;
+ }
+
+ ///
+ /// Gets or sets the multisample type.
+ ///
+ /// The multisample type.
+ public MultisampleType MultisampleType
+ {
+ get;
+ set;
+ }
+
+ ///
+ /// Gets or sets the multisample quality.
+ ///
+ /// The multisample quality.
+ public int MultisampleQuality
+ {
+ get;
+ set;
+ }
+
+ ///
+ /// Gets or sets the depth stencil format.
+ ///
+ /// The depth stencil format.
+ public Format DepthStencilFormat
+ {
+ get;
+ set;
+ }
+
+ ///
+ /// Gets or sets the Direct3D9 specific settings.
+ ///
+ /// The Direct3D9 specific settings.
+ internal Direct3D9Settings Direct3D9
+ {
+ get;
+ set;
+ }
+
+ ///
+ /// Initializes a new instance of the class.
+ ///
+ public DeviceSettings()
+ {
+ // set sane defaults
+ DeviceType = DeviceType.Hardware;
+ BackBufferFormat = Format.Unknown;
+ BackBufferCount = 1;
+ MultisampleType = MultisampleType.None;
+ DepthStencilFormat = Format.Unknown;
+ Windowed = true;
+ EnableVSync = true;
+ }
+
+ ///
+ /// Creates a new object that is a copy of the current instance.
+ ///
+ ///
+ /// A new object that is a copy of this instance.
+ ///
+ public DeviceSettings Clone()
+ {
+ DeviceSettings result = new DeviceSettings();
+ result.DeviceType = DeviceType;
+ result.RefreshRate = RefreshRate;
+ result.BackBufferCount = BackBufferCount;
+ result.BackBufferFormat = BackBufferFormat;
+ result.BackBufferHeight = BackBufferHeight;
+ result.BackBufferWidth = BackBufferWidth;
+ result.DepthStencilFormat = DepthStencilFormat;
+ result.MultisampleQuality = MultisampleQuality;
+ result.MultisampleType = MultisampleType;
+ result.Windowed = Windowed;
+ result.EnableVSync = EnableVSync;
+ result.AdapterOrdinal = AdapterOrdinal;
+ result.Multithreaded = Multithreaded;
+
+ if (Direct3D9 != null)
+ result.Direct3D9 = Direct3D9.Clone();
+
+ return result;
+ }
+
+ ///
+ /// Creates a new object that is a copy of the current instance.
+ ///
+ ///
+ /// A new object that is a copy of this instance.
+ ///
+ object ICloneable.Clone()
+ {
+ return Clone();
+ }
+
+ ///
+ /// Finds valid device settings based upon the desired settings.
+ ///
+ /// The desired settings.
+ /// The best valid device settings matching the input settings.
+ public static DeviceSettings FindValidSettings( DeviceSettings settings )
+ {
+ try
+ {
+ GraphicsDeviceManager.EnsureD3D9();
+ }
+ catch( Exception e )
+ {
+ throw new NoCompatibleDevicesException( "Could not initialize Direct3D9.", e );
+ }
+
+ if( !Enumeration9.HasEnumerated )
+ Enumeration9.Enumerate();
+
+ DeviceSettings newSettings = settings.Clone();
+ Direct3D9Settings d3d9 = FindValidD3D9Settings( settings );
+ newSettings.Direct3D9 = d3d9;
+ return newSettings;
+ }
+
+ static Direct3D9Settings FindValidD3D9Settings(DeviceSettings settings)
+ {
+ Direct3D9Settings optimal = Direct3D9Settings.BuildOptimalSettings(settings);
+
+ SettingsCombo9 bestCombo = null;
+ float bestRanking = -1.0f;
+
+ foreach (AdapterInfo9 adapterInfo in Enumeration9.Adapters)
+ {
+ DisplayMode desktopMode = GraphicsDeviceManager.Direct3D9Object.GetAdapterDisplayMode(adapterInfo.AdapterOrdinal);
+ foreach (DeviceInfo9 deviceInfo in adapterInfo.Devices)
+ {
+ foreach (SettingsCombo9 combo in deviceInfo.DeviceSettings)
+ {
+ if (combo.Windowed && combo.AdapterFormat != desktopMode.Format)
+ continue;
+
+ float ranking = Direct3D9Settings.RankSettingsCombo(combo, optimal, desktopMode);
+ if (ranking > bestRanking)
+ {
+ bestCombo = combo;
+ bestRanking = ranking;
+ }
+ }
+ }
+ }
+
+ if (bestCombo == null)
+ throw new NoCompatibleDevicesException("No compatible Direct3D9 devices found.");
+
+ return Direct3D9Settings.BuildValidSettings(bestCombo, optimal);
+ }
+ }
+}
diff --git a/FDK19/繧ｳ繝ｼ繝/01.繝輔Ξ繝ｼ繝繝ｯ繝ｼ繧ｯ/DeviceSettings/Direct3D9Settings.cs b/FDK19/繧ｳ繝ｼ繝/01.繝輔Ξ繝ｼ繝繝ｯ繝ｼ繧ｯ/DeviceSettings/Direct3D9Settings.cs
new file mode 100644
index 00000000..b44a3aac
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/01.繝輔Ξ繝ｼ繝繝ｯ繝ｼ繧ｯ/DeviceSettings/Direct3D9Settings.cs
@@ -0,0 +1,440 @@
+ｻｿ/*
+* Copyright (c) 2007-2009 SlimDX Group
+*
+* Permission is hereby granted, free of charge, to any person obtaining a copy
+* of this software and associated documentation files (the "Software"), to deal
+* in the Software without restriction, including without limitation the rights
+* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+* copies of the Software, and to permit persons to whom the Software is
+* furnished to do so, subject to the following conditions:
+*
+* The above copyright notice and this permission notice shall be included in
+* all copies or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+* THE SOFTWARE.
+*/
+using System;
+using System.Collections.Generic;
+using SlimDX.Direct3D9;
+
+namespace SampleFramework
+{
+ class Direct3D9Settings : ICloneable
+ {
+ public int AdapterOrdinal
+ {
+ get;
+ set;
+ }
+
+ public DeviceType DeviceType
+ {
+ get;
+ set;
+ }
+
+ public Format AdapterFormat
+ {
+ get;
+ set;
+ }
+
+ public CreateFlags CreationFlags
+ {
+ get;
+ set;
+ }
+
+ public PresentParameters PresentParameters
+ {
+ get;
+ private set;
+ }
+
+ public Direct3D9Settings()
+ {
+ PresentParameters = new PresentParameters();
+ DeviceType = DeviceType.Hardware;
+ PresentParameters.Windowed = true;
+ AdapterFormat = Format.Unknown;
+ CreationFlags = CreateFlags.HardwareVertexProcessing;
+ PresentParameters.BackBufferFormat = Format.Unknown;
+ PresentParameters.BackBufferCount = 1;
+ PresentParameters.Multisample = MultisampleType.None;
+ PresentParameters.SwapEffect = SwapEffect.Discard;
+ PresentParameters.EnableAutoDepthStencil = true;
+ PresentParameters.AutoDepthStencilFormat = Format.Unknown;
+ PresentParameters.PresentFlags = PresentFlags.DiscardDepthStencil;
+ PresentParameters.PresentationInterval = PresentInterval.Default;
+ }
+
+ public Direct3D9Settings Clone()
+ {
+ Direct3D9Settings clone = new Direct3D9Settings();
+ clone.AdapterFormat = AdapterFormat;
+ clone.AdapterOrdinal = AdapterOrdinal;
+ clone.CreationFlags = CreationFlags;
+ clone.DeviceType = DeviceType;
+ clone.PresentParameters = PresentParameters.Clone();
+
+ return clone;
+ }
+
+ object ICloneable.Clone()
+ {
+ return Clone();
+ }
+
+ public static Direct3D9Settings BuildOptimalSettings(DeviceSettings settings)
+ {
+ DisplayMode desktopMode = GraphicsDeviceManager.Direct3D9Object.GetAdapterDisplayMode(0);
+ Direct3D9Settings optimal = new Direct3D9Settings();
+
+ optimal.AdapterOrdinal = settings.AdapterOrdinal;
+ optimal.DeviceType = settings.DeviceType;
+ optimal.PresentParameters.Windowed = settings.Windowed;
+ optimal.PresentParameters.BackBufferCount = settings.BackBufferCount;
+ optimal.PresentParameters.Multisample = settings.MultisampleType;
+ optimal.PresentParameters.MultisampleQuality = settings.MultisampleQuality;
+ optimal.PresentParameters.FullScreenRefreshRateInHertz = settings.RefreshRate;
+
+ if(settings.Multithreaded)
+ optimal.CreationFlags |= CreateFlags.Multithreaded;
+
+ if(optimal.PresentParameters.Windowed || ConversionMethods.GetColorBits(desktopMode.Format) >= 8)
+ optimal.AdapterFormat = desktopMode.Format;
+ else
+ optimal.AdapterFormat = Format.X8R8G8B8;
+
+ if(settings.BackBufferWidth == 0 || settings.BackBufferHeight == 0)
+ {
+ if(optimal.PresentParameters.Windowed)
+ {
+ optimal.PresentParameters.BackBufferWidth = 640;
+ optimal.PresentParameters.BackBufferHeight = 480;
+ }
+ else
+ {
+ optimal.PresentParameters.BackBufferWidth = desktopMode.Width;
+ optimal.PresentParameters.BackBufferHeight = desktopMode.Height;
+ }
+ }
+ else
+ {
+ optimal.PresentParameters.BackBufferWidth = settings.BackBufferWidth;
+ optimal.PresentParameters.BackBufferHeight = settings.BackBufferHeight;
+ }
+
+ if(settings.BackBufferFormat == Format.Unknown)
+ optimal.PresentParameters.BackBufferFormat = optimal.AdapterFormat;
+ else
+ optimal.PresentParameters.BackBufferFormat = settings.BackBufferFormat;
+
+ if(settings.DepthStencilFormat == Format.Unknown)
+ {
+ if(ConversionMethods.GetColorBits(optimal.PresentParameters.BackBufferFormat) >= 8)
+ optimal.PresentParameters.AutoDepthStencilFormat = Format.D32;
+ else
+ optimal.PresentParameters.AutoDepthStencilFormat = Format.D16;
+ }
+ else
+ optimal.PresentParameters.AutoDepthStencilFormat = settings.DepthStencilFormat;
+
+ if(!settings.EnableVSync)
+ optimal.PresentParameters.PresentationInterval = PresentInterval.Immediate;
+
+ return optimal;
+ }
+
+ public static float RankSettingsCombo(SettingsCombo9 combo, Direct3D9Settings optimal, DisplayMode desktopMode)
+ {
+ float ranking = 0.0f;
+
+ if(combo.AdapterOrdinal == optimal.AdapterOrdinal)
+ ranking += 1000.0f;
+
+ if(combo.DeviceType == optimal.DeviceType)
+ ranking += 100.0f;
+
+ if(combo.DeviceType == DeviceType.Hardware)
+ ranking += 0.1f;
+
+ if(combo.Windowed == optimal.PresentParameters.Windowed)
+ ranking += 10.0f;
+
+ if(combo.AdapterFormat == optimal.AdapterFormat)
+ ranking += 1.0f;
+ else
+ {
+ int bitDepthDelta = Math.Abs(ConversionMethods.GetColorBits(combo.AdapterFormat) -
+ ConversionMethods.GetColorBits(optimal.AdapterFormat));
+ float scale = Math.Max(0.9f - bitDepthDelta * 0.2f, 0.0f);
+ ranking += scale;
+ }
+
+ if(!combo.Windowed)
+ {
+ bool match;
+ if(ConversionMethods.GetColorBits(desktopMode.Format) >= 8)
+ match = (combo.AdapterFormat == desktopMode.Format);
+ else
+ match = (combo.AdapterFormat == Format.X8R8G8B8);
+
+ if(match)
+ ranking += 0.1f;
+ }
+
+ if((optimal.CreationFlags & CreateFlags.HardwareVertexProcessing) != 0 &&
+ (optimal.CreationFlags & CreateFlags.MixedVertexProcessing) != 0)
+ {
+ if((combo.DeviceInfo.Capabilities.DeviceCaps & DeviceCaps.HWTransformAndLight) != 0)
+ ranking += 1.0f;
+ }
+
+ if((combo.DeviceInfo.Capabilities.DeviceCaps & DeviceCaps.HWTransformAndLight) != 0)
+ ranking += 0.1f;
+
+ foreach(DisplayMode displayMode in combo.AdapterInfo.DisplayModes)
+ {
+ if(displayMode.Format == combo.AdapterFormat &&
+ displayMode.Width == optimal.PresentParameters.BackBufferWidth &&
+ displayMode.Height == optimal.PresentParameters.BackBufferHeight)
+ {
+ ranking += 1.0f;
+ break;
+ }
+ }
+
+ if(combo.BackBufferFormat == optimal.PresentParameters.BackBufferFormat)
+ ranking += 1.0f;
+ else
+ {
+ int bitDepthDelta = Math.Abs(ConversionMethods.GetColorBits(combo.BackBufferFormat) -
+ ConversionMethods.GetColorBits(optimal.PresentParameters.BackBufferFormat));
+ float scale = Math.Max(0.9f - bitDepthDelta * 0.2f, 0.0f);
+ ranking += scale;
+ }
+
+ if(combo.BackBufferFormat == combo.AdapterFormat)
+ ranking += 0.1f;
+
+ for(int i = 0; i < combo.MultisampleTypes.Count; i++)
+ {
+ MultisampleType type = combo.MultisampleTypes[i];
+ int quality = combo.MultisampleQualities[i];
+
+ if(type == optimal.PresentParameters.Multisample && quality == optimal.PresentParameters.MultisampleQuality)
+ {
+ ranking += 1.0f;
+ break;
+ }
+ }
+
+ if(combo.DepthStencilFormats.Contains(optimal.PresentParameters.AutoDepthStencilFormat))
+ ranking += 1.0f;
+
+ foreach(DisplayMode displayMode in combo.AdapterInfo.DisplayModes)
+ {
+ if(displayMode.Format == combo.AdapterFormat &&
+ displayMode.RefreshRate == optimal.PresentParameters.FullScreenRefreshRateInHertz)
+ {
+ ranking += 1.0f;
+ break;
+ }
+ }
+
+ if(combo.PresentIntervals.Contains(optimal.PresentParameters.PresentationInterval))
+ ranking += 1.0f;
+
+ return ranking;
+ }
+
+ public static Direct3D9Settings BuildValidSettings(SettingsCombo9 combo, Direct3D9Settings input)
+ {
+ Direct3D9Settings settings = new Direct3D9Settings();
+
+ settings.AdapterOrdinal = combo.AdapterOrdinal;
+ settings.DeviceType = combo.DeviceType;
+ settings.PresentParameters.Windowed = combo.Windowed;
+ settings.AdapterFormat = combo.AdapterFormat;
+ settings.PresentParameters.BackBufferFormat = combo.BackBufferFormat;
+ settings.PresentParameters.SwapEffect = input.PresentParameters.SwapEffect;
+ settings.PresentParameters.PresentFlags = input.PresentParameters.PresentFlags | PresentFlags.DiscardDepthStencil;
+
+ settings.CreationFlags = input.CreationFlags;
+ if((combo.DeviceInfo.Capabilities.DeviceCaps & DeviceCaps.HWTransformAndLight) == 0 &&
+ ((settings.CreationFlags & CreateFlags.HardwareVertexProcessing) != 0 ||
+ (settings.CreationFlags & CreateFlags.MixedVertexProcessing) != 0))
+ {
+ settings.CreationFlags &= ~CreateFlags.HardwareVertexProcessing;
+ settings.CreationFlags &= ~CreateFlags.MixedVertexProcessing;
+ settings.CreationFlags |= CreateFlags.SoftwareVertexProcessing;
+ }
+
+ if((settings.CreationFlags & CreateFlags.HardwareVertexProcessing) == 0 &&
+ (settings.CreationFlags & CreateFlags.MixedVertexProcessing) == 0 &&
+ (settings.CreationFlags & CreateFlags.SoftwareVertexProcessing) == 0)
+ {
+ if((combo.DeviceInfo.Capabilities.DeviceCaps & DeviceCaps.HWTransformAndLight) != 0)
+ settings.CreationFlags |= CreateFlags.HardwareVertexProcessing;
+ else
+ settings.CreationFlags |= CreateFlags.SoftwareVertexProcessing;
+ }
+
+ DisplayMode bestDisplayMode = FindValidResolution(combo, input);
+ settings.PresentParameters.BackBufferWidth = bestDisplayMode.Width;
+ settings.PresentParameters.BackBufferHeight = bestDisplayMode.Height;
+
+ settings.PresentParameters.BackBufferCount = input.PresentParameters.BackBufferCount;
+ if(settings.PresentParameters.BackBufferCount > 3)
+ settings.PresentParameters.BackBufferCount = 3;
+ if(settings.PresentParameters.BackBufferCount < 1)
+ settings.PresentParameters.BackBufferCount = 1;
+
+ if(input.PresentParameters.SwapEffect != SwapEffect.Discard)
+ {
+ settings.PresentParameters.Multisample = MultisampleType.None;
+ settings.PresentParameters.MultisampleQuality = 0;
+ }
+ else
+ {
+ MultisampleType bestType = MultisampleType.None;
+ int bestQuality = 0;
+
+ for(int i = 0; i < combo.MultisampleTypes.Count; i++)
+ {
+ MultisampleType type = combo.MultisampleTypes[i];
+ int quality = combo.MultisampleQualities[0];
+
+ if(Math.Abs(type - input.PresentParameters.Multisample) < Math.Abs(bestType -
+ input.PresentParameters.Multisample))
+ {
+ bestType = type;
+ bestQuality = Math.Min(quality - 1, input.PresentParameters.MultisampleQuality);
+ }
+ }
+
+ settings.PresentParameters.Multisample = bestType;
+ settings.PresentParameters.MultisampleQuality = bestQuality;
+ }
+
+ List rankings = new List();
+ int inputDepthBitDepth = ConversionMethods.GetDepthBits(input.PresentParameters.AutoDepthStencilFormat);
+ int inputStencilBitDepth = ConversionMethods.GetStencilBits(input.PresentParameters.AutoDepthStencilFormat);
+
+ foreach(Format format in combo.DepthStencilFormats)
+ {
+ int currentBitDepth = ConversionMethods.GetDepthBits(format);
+ int currentStencilDepth = ConversionMethods.GetStencilBits(format);
+
+ int ranking = Math.Abs(currentBitDepth - inputDepthBitDepth);
+ ranking += Math.Abs(currentStencilDepth - inputStencilBitDepth);
+ rankings.Add(ranking);
+ }
+
+ int bestRanking = int.MaxValue;
+ foreach(int ranking in rankings)
+ {
+ if(ranking < bestRanking)
+ bestRanking = ranking;
+ }
+ int bestIndex = rankings.IndexOf(bestRanking);
+
+ if(bestIndex >= 0)
+ {
+ settings.PresentParameters.AutoDepthStencilFormat = combo.DepthStencilFormats[bestIndex];
+ settings.PresentParameters.EnableAutoDepthStencil = true;
+ }
+ else
+ {
+ settings.PresentParameters.AutoDepthStencilFormat = Format.Unknown;
+ settings.PresentParameters.EnableAutoDepthStencil = false;
+ }
+
+ if(combo.Windowed)
+ settings.PresentParameters.FullScreenRefreshRateInHertz = 0;
+ else
+ {
+ int match = input.PresentParameters.FullScreenRefreshRateInHertz;
+ bestDisplayMode.RefreshRate = 0;
+ if(match != 0)
+ {
+ bestRanking = 100000;
+ foreach(DisplayMode displayMode in combo.AdapterInfo.DisplayModes)
+ {
+ if(displayMode.Format != combo.AdapterFormat ||
+ displayMode.Width != bestDisplayMode.Width ||
+ displayMode.Height != bestDisplayMode.Height)
+ continue;
+
+ int ranking = Math.Abs(displayMode.RefreshRate - match);
+
+ if(ranking < bestRanking)
+ {
+ bestDisplayMode.RefreshRate = displayMode.RefreshRate;
+ bestRanking = ranking;
+
+ if(bestRanking == 0)
+ break;
+ }
+ }
+ }
+
+ settings.PresentParameters.FullScreenRefreshRateInHertz = bestDisplayMode.RefreshRate;
+ }
+
+ if(combo.PresentIntervals.Contains(input.PresentParameters.PresentationInterval))
+ settings.PresentParameters.PresentationInterval = input.PresentParameters.PresentationInterval;
+ else
+ settings.PresentParameters.PresentationInterval = PresentInterval.Default;
+
+ return settings;
+ }
+
+ static DisplayMode FindValidResolution(SettingsCombo9 combo, Direct3D9Settings input)
+ {
+ DisplayMode bestMode = new DisplayMode();
+
+ if(combo.Windowed)
+ {
+ bestMode.Width = input.PresentParameters.BackBufferWidth;
+ bestMode.Height = input.PresentParameters.BackBufferHeight;
+ return bestMode;
+ }
+
+ int bestRanking = 100000;
+ int ranking;
+ foreach(DisplayMode mode in combo.AdapterInfo.DisplayModes)
+ {
+ if(mode.Format != combo.AdapterFormat)
+ continue;
+
+ ranking = Math.Abs(mode.Width - input.PresentParameters.BackBufferWidth) +
+ Math.Abs(mode.Height - input.PresentParameters.BackBufferHeight);
+
+ if(ranking < bestRanking)
+ {
+ bestMode = mode;
+ bestRanking = ranking;
+
+ if(bestRanking == 0)
+ break;
+ }
+ }
+
+ if(bestMode.Width == 0)
+ {
+ bestMode.Width = input.PresentParameters.BackBufferWidth;
+ bestMode.Height = input.PresentParameters.BackBufferHeight;
+ }
+
+ return bestMode;
+ }
+ }
+}
diff --git a/FDK19/繧ｳ繝ｼ繝/01.繝輔Ξ繝ｼ繝繝ｯ繝ｼ繧ｯ/Enumeration/Enumeration9.cs b/FDK19/繧ｳ繝ｼ繝/01.繝輔Ξ繝ｼ繝繝ｯ繝ｼ繧ｯ/Enumeration/Enumeration9.cs
new file mode 100644
index 00000000..0aa8f41d
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/01.繝輔Ξ繝ｼ繝繝ｯ繝ｼ繧ｯ/Enumeration/Enumeration9.cs
@@ -0,0 +1,447 @@
+ｻｿ/*
+* Copyright (c) 2007-2009 SlimDX Group
+*
+* Permission is hereby granted, free of charge, to any person obtaining a copy
+* of this software and associated documentation files (the "Software"), to deal
+* in the Software without restriction, including without limitation the rights
+* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+* copies of the Software, and to permit persons to whom the Software is
+* furnished to do so, subject to the following conditions:
+*
+* The above copyright notice and this permission notice shall be included in
+* all copies or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+* THE SOFTWARE.
+*/
+using System.Collections.Generic;
+using System.Globalization;
+using SlimDX.Direct3D9;
+
+namespace SampleFramework
+{
+ class AdapterInfo9
+ {
+ public int AdapterOrdinal
+ {
+ get;
+ set;
+ }
+
+ public AdapterDetails Details
+ {
+ get;
+ set;
+ }
+
+ public string Description
+ {
+ get;
+ set;
+ }
+
+ public List DisplayModes
+ {
+ get;
+ private set;
+ }
+
+ public List Devices
+ {
+ get;
+ private set;
+ }
+
+ public AdapterInfo9()
+ {
+ // create lists
+ DisplayModes = new List();
+ Devices = new List();
+ }
+ }
+
+ class DeviceInfo9
+ {
+ public DeviceType DeviceType
+ {
+ get;
+ set;
+ }
+
+ public Capabilities Capabilities
+ {
+ get;
+ set;
+ }
+
+ public List DeviceSettings
+ {
+ get;
+ private set;
+ }
+
+ public DeviceInfo9()
+ {
+ DeviceSettings = new List();
+ }
+ }
+
+ class SettingsCombo9
+ {
+ public int AdapterOrdinal
+ {
+ get;
+ set;
+ }
+
+ public DeviceType DeviceType
+ {
+ get;
+ set;
+ }
+
+ public Format AdapterFormat
+ {
+ get;
+ set;
+ }
+
+ public Format BackBufferFormat
+ {
+ get;
+ set;
+ }
+
+ public bool Windowed
+ {
+ get;
+ set;
+ }
+
+ public List DepthStencilFormats
+ {
+ get;
+ internal set;
+ }
+
+ public List MultisampleTypes
+ {
+ get;
+ private set;
+ }
+
+ public List MultisampleQualities
+ {
+ get;
+ private set;
+ }
+
+ public List PresentIntervals
+ {
+ get;
+ private set;
+ }
+
+ public AdapterInfo9 AdapterInfo
+ {
+ get;
+ set;
+ }
+
+ public DeviceInfo9 DeviceInfo
+ {
+ get;
+ set;
+ }
+
+ public SettingsCombo9()
+ {
+ DepthStencilFormats = new List();
+ MultisampleQualities = new List();
+ MultisampleTypes = new List();
+ PresentIntervals = new List();
+ }
+ }
+
+ class DisplayModeComparer9 : IComparer
+ {
+ static DisplayModeComparer9 comparer = new DisplayModeComparer9();
+
+ public static DisplayModeComparer9 Comparer
+ {
+ get { return comparer; }
+ }
+
+ public DisplayModeComparer9()
+ {
+ }
+
+ public int Compare(DisplayMode x, DisplayMode y)
+ {
+ if (x.Width > y.Width)
+ return 1;
+ if (x.Width < y.Width)
+ return -1;
+ if (x.Height > y.Height)
+ return 1;
+ if (x.Height < y.Height)
+ return -1;
+ if (x.Format > y.Format)
+ return 1;
+ if (x.Format < y.Format)
+ return -1;
+ if (x.RefreshRate > y.RefreshRate)
+ return 1;
+ if (x.RefreshRate < y.RefreshRate)
+ return -1;
+
+ return 0;
+ }
+ }
+
+ static class Enumeration9
+ {
+ public static DeviceSettings MinimumSettings
+ {
+ get;
+ set;
+ }
+
+ public static List Adapters
+ {
+ get;
+ private set;
+ }
+
+ public static bool HasEnumerated
+ {
+ get;
+ private set;
+ }
+
+ public static void Enumerate()
+ {
+ HasEnumerated = true;
+ Adapters = new List();
+ List adapterFormats = new List();
+ Format[] allowedAdapterFormats = { Format.X8R8G8B8, Format.X1R5G5B5, Format.R5G6B5,
+ Format.A2R10G10B10 };
+
+ foreach (AdapterInformation adapter in GraphicsDeviceManager.Direct3D9Object.Adapters) //
+ {
+ AdapterInfo9 info = new AdapterInfo9();
+ info.AdapterOrdinal = adapter.Adapter;
+ info.Details = adapter.Details;
+
+ adapterFormats.Clear();
+ foreach (Format adapterFormat in allowedAdapterFormats)
+ {
+ foreach (DisplayMode displayMode in adapter.GetDisplayModes(adapterFormat))
+ {
+ if (MinimumSettings != null)
+ {
+ if (displayMode.Width < MinimumSettings.BackBufferWidth ||
+ displayMode.Height < MinimumSettings.BackBufferHeight ||
+ displayMode.RefreshRate < MinimumSettings.RefreshRate)
+ continue;
+ }
+
+ info.DisplayModes.Add(displayMode);
+
+ if (!adapterFormats.Contains(displayMode.Format))
+ adapterFormats.Add(displayMode.Format);
+ }
+ }
+
+ if (!adapterFormats.Contains(adapter.CurrentDisplayMode.Format))
+ adapterFormats.Add(adapter.CurrentDisplayMode.Format);
+
+ info.DisplayModes.Sort(DisplayModeComparer9.Comparer);
+
+ EnumerateDevices(info, adapterFormats);
+
+ if (info.Devices.Count > 0)
+ Adapters.Add(info);
+ }
+
+ bool unique = true;
+ foreach (AdapterInfo9 adapter1 in Adapters)
+ {
+ foreach (AdapterInfo9 adapter2 in Adapters)
+ {
+ if (adapter1 == adapter2)
+ continue;
+ if (adapter1.Details.Description == adapter2.Details.Description)
+ {
+ unique = false;
+ break;
+ }
+ }
+
+ if (!unique)
+ break;
+ }
+
+ foreach (AdapterInfo9 info in Adapters)
+ {
+ info.Description = info.Details.Description;
+ if (!unique)
+ info.Description += " " + info.AdapterOrdinal.ToString(CultureInfo.CurrentCulture);
+ }
+ }
+
+ static void EnumerateDevices(AdapterInfo9 info, List adapterFormats)
+ {
+ DeviceType[] deviceTypes = { DeviceType.Hardware, DeviceType.Reference };
+
+ foreach (DeviceType deviceType in deviceTypes)
+ {
+ if (MinimumSettings != null && MinimumSettings.DeviceType != deviceType)
+ continue;
+
+ DeviceInfo9 deviceInfo = new DeviceInfo9();
+ deviceInfo.DeviceType = deviceType;
+ try
+ {
+ deviceInfo.Capabilities = GraphicsDeviceManager.Direct3D9Object.GetDeviceCaps(info.AdapterOrdinal, deviceInfo.DeviceType);
+
+ EnumerateSettingsCombos(info, deviceInfo, adapterFormats);
+
+ if (deviceInfo.DeviceSettings.Count > 0)
+ info.Devices.Add(deviceInfo);
+ }
+ catch (Direct3D9Exception)
+ {
+ // #23681 2010.11.17 yyagi: GetDeviceCaps()縺ｧ萓句､悶′逋ｺ逕溘☆繧九Δ繝九ち縺ｫ蟇ｾ縺励※縺ｯ縲‘numerate繧偵せ繧ｭ繝繝励☆繧九
+ }
+ }
+ }
+
+ static void EnumerateSettingsCombos(AdapterInfo9 adapterInfo, DeviceInfo9 deviceInfo, List adapterFormats)
+ {
+ Format[] backBufferFormats = { Format.A8R8G8B8, Format.X8R8G8B8, Format.A2R10G10B10,
+ Format.R5G6B5, Format.A1R5G5B5, Format.X1R5G5B5 };
+
+ foreach (Format adapterFormat in adapterFormats)
+ {
+ foreach (Format backBufferFormat in backBufferFormats)
+ {
+ for (int windowed = 0; windowed < 2; windowed++)
+ {
+ if (windowed == 0 && adapterInfo.DisplayModes.Count == 0)
+ continue;
+
+ if (!GraphicsDeviceManager.Direct3D9Object.CheckDeviceType(adapterInfo.AdapterOrdinal, deviceInfo.DeviceType,
+ adapterFormat, backBufferFormat, (windowed == 1)))
+ continue;
+
+ if (!GraphicsDeviceManager.Direct3D9Object.CheckDeviceFormat(adapterInfo.AdapterOrdinal,
+ deviceInfo.DeviceType, adapterFormat, Usage.QueryPostPixelShaderBlending,
+ ResourceType.Texture, backBufferFormat))
+ continue;
+
+ SettingsCombo9 combo = new SettingsCombo9();
+ combo.AdapterOrdinal = adapterInfo.AdapterOrdinal;
+ combo.DeviceType = deviceInfo.DeviceType;
+ combo.AdapterFormat = adapterFormat;
+ combo.BackBufferFormat = backBufferFormat;
+ combo.Windowed = (windowed == 1);
+ combo.AdapterInfo = adapterInfo;
+ combo.DeviceInfo = deviceInfo;
+
+ BuildDepthStencilFormatList(combo);
+ BuildMultisampleTypeList(combo);
+
+ if (combo.MultisampleTypes.Count == 0)
+ continue;
+
+ BuildPresentIntervalList(combo);
+
+ if (MinimumSettings != null)
+ {
+ if (MinimumSettings.BackBufferFormat != Format.Unknown &&
+ MinimumSettings.BackBufferFormat != backBufferFormat)
+ continue;
+
+ if (MinimumSettings.DepthStencilFormat != Format.Unknown &&
+ !combo.DepthStencilFormats.Contains(MinimumSettings.DepthStencilFormat))
+ continue;
+
+ if (!combo.MultisampleTypes.Contains(MinimumSettings.MultisampleType))
+ continue;
+ }
+
+ deviceInfo.DeviceSettings.Add(combo);
+ }
+ }
+ }
+ }
+
+ static void BuildDepthStencilFormatList(SettingsCombo9 combo)
+ {
+ List possibleDepthStencilFormats = new List {
+ Format.D16, Format.D15S1, Format.D24X8,
+ Format.D24S8, Format.D24X4S4, Format.D32 };
+
+ foreach (Format format in possibleDepthStencilFormats)
+ {
+ if (GraphicsDeviceManager.Direct3D9Object.CheckDeviceFormat(combo.AdapterOrdinal, combo.DeviceType, combo.AdapterFormat,
+ Usage.DepthStencil, ResourceType.Surface, format) &&
+ GraphicsDeviceManager.Direct3D9Object.CheckDepthStencilMatch(combo.AdapterOrdinal, combo.DeviceType,
+ combo.AdapterFormat, combo.BackBufferFormat, format))
+ combo.DepthStencilFormats.Add(format);
+ }
+ }
+
+ static void BuildMultisampleTypeList(SettingsCombo9 combo)
+ {
+ List possibleMultisampleTypes = new List() {
+ MultisampleType.None, MultisampleType.NonMaskable,
+ MultisampleType.TwoSamples, MultisampleType.ThreeSamples,
+ MultisampleType.FourSamples, MultisampleType.FiveSamples,
+ MultisampleType.SixSamples, MultisampleType.SevenSamples,
+ MultisampleType.EightSamples, MultisampleType.NineSamples,
+ MultisampleType.TenSamples, MultisampleType.ElevenSamples,
+ MultisampleType.TwelveSamples, MultisampleType.ThirteenSamples,
+ MultisampleType.FourteenSamples, MultisampleType.FifteenSamples,
+ MultisampleType.SixteenSamples
+ };
+
+ int quality;
+ foreach (MultisampleType type in possibleMultisampleTypes)
+ {
+ if (GraphicsDeviceManager.Direct3D9Object.CheckDeviceMultisampleType(combo.AdapterOrdinal, combo.DeviceType,
+ combo.AdapterFormat, combo.Windowed, type, out quality))
+ {
+ combo.MultisampleTypes.Add(type);
+ combo.MultisampleQualities.Add(quality);
+ }
+ }
+ }
+
+ static void BuildPresentIntervalList(SettingsCombo9 combo)
+ {
+ List possiblePresentIntervals = new List() {
+ PresentInterval.Immediate, PresentInterval.Default,
+ PresentInterval.One, PresentInterval.Two,
+ PresentInterval.Three, PresentInterval.Four
+ };
+
+ foreach (PresentInterval interval in possiblePresentIntervals)
+ {
+ if (combo.Windowed && (interval == PresentInterval.Two ||
+ interval == PresentInterval.Three || interval == PresentInterval.Four))
+ continue;
+
+ if (interval == PresentInterval.Default ||
+ (combo.DeviceInfo.Capabilities.PresentationIntervals & interval) != 0)
+ combo.PresentIntervals.Add(interval);
+ }
+ }
+ }
+}
diff --git a/FDK19/繧ｳ繝ｼ繝/01.繝輔Ξ繝ｼ繝繝ｯ繝ｼ繧ｯ/Properties/Resources.Designer.cs b/FDK19/繧ｳ繝ｼ繝/01.繝輔Ξ繝ｼ繝繝ｯ繝ｼ繧ｯ/Properties/Resources.Designer.cs
new file mode 100644
index 00000000..eecc3623
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/01.繝輔Ξ繝ｼ繝繝ｯ繝ｼ繧ｯ/Properties/Resources.Designer.cs
@@ -0,0 +1,70 @@
+ｻｿ//------------------------------------------------------------------------------
+//
+// This code was generated by a tool.
+// Runtime Version:2.0.50727.1434
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+//------------------------------------------------------------------------------
+
+namespace SampleFramework.Properties {
+ using System;
+
+
+ ///
+ /// A strongly-typed resource class, for looking up localized strings, etc.
+ ///
+ // This class was auto-generated by the StronglyTypedResourceBuilder
+ // class via a tool like ResGen or Visual Studio.
+ // To add or remove a member, edit your .ResX file then rerun ResGen
+ // with the /str option, or rebuild your VS project.
+ [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "2.0.0.0")]
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+ [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+ internal class Resources {
+
+ private static global::System.Resources.ResourceManager resourceMan;
+
+ private static global::System.Globalization.CultureInfo resourceCulture;
+
+ [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
+ internal Resources() {
+ }
+
+ ///
+ /// Returns the cached ResourceManager instance used by this class.
+ ///
+ [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+ internal static global::System.Resources.ResourceManager ResourceManager {
+ get {
+ if (object.ReferenceEquals(resourceMan, null)) {
+ global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("SampleFramework.Properties.Resources", typeof(Resources).Assembly);
+ resourceMan = temp;
+ }
+ return resourceMan;
+ }
+ }
+
+ ///
+ /// Overrides the current thread's CurrentUICulture property for all
+ /// resource lookups using this strongly typed resource class.
+ ///
+ [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+ internal static global::System.Globalization.CultureInfo Culture {
+ get {
+ return resourceCulture;
+ }
+ set {
+ resourceCulture = value;
+ }
+ }
+
+ internal static System.Drawing.Icon sdx_icon_black {
+ get {
+ object obj = ResourceManager.GetObject("sdx_icon_black", resourceCulture);
+ return ((System.Drawing.Icon)(obj));
+ }
+ }
+ }
+}
diff --git a/FDK19/繧ｳ繝ｼ繝/01.繝輔Ξ繝ｼ繝繝ｯ繝ｼ繧ｯ/Properties/Resources.resx b/FDK19/繧ｳ繝ｼ繝/01.繝輔Ξ繝ｼ繝繝ｯ繝ｼ繧ｯ/Properties/Resources.resx
new file mode 100644
index 00000000..827822b2
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/01.繝輔Ξ繝ｼ繝繝ｯ繝ｼ繧ｯ/Properties/Resources.resx
@@ -0,0 +1,124 @@
+ｻｿ
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ text/microsoft-resx
+
+
+ 2.0
+
+
+ System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
+
+
+ System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
+
+
+
+ ..\Resources\sdx_icon_black.ico;System.Drawing.Icon, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a
+
+
\ No newline at end of file
diff --git a/FDK19/繧ｳ繝ｼ繝/01.繝輔Ξ繝ｼ繝繝ｯ繝ｼ繧ｯ/Rendering/DeviceCache.cs b/FDK19/繧ｳ繝ｼ繝/01.繝輔Ξ繝ｼ繝繝ｯ繝ｼ繧ｯ/Rendering/DeviceCache.cs
new file mode 100644
index 00000000..3a3dd8fe
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/01.繝輔Ξ繝ｼ繝繝ｯ繝ｼ繧ｯ/Rendering/DeviceCache.cs
@@ -0,0 +1,200 @@
+ｻｿusing System;
+using System.Drawing;
+using SlimDX;
+using SlimDX.Direct3D9;
+
+namespace SampleFramework
+{
+ public sealed class DeviceCache
+ {
+ private readonly Device _device;
+
+ public DeviceCache(Device device)
+ {
+ _device = device;
+ }
+
+ public Device UnderlyingDevice => _device;
+
+ public void Dispose()
+ {
+ _device.Dispose();
+ }
+
+ public object Tag
+ {
+ get => _device.Tag;
+ set => _device.Tag = value;
+ }
+
+ public Result TestCooperativeLevel()
+ {
+ return _device.TestCooperativeLevel();
+ }
+
+ public Result Reset(PresentParameters presentParameters)
+ {
+ return _device.Reset(presentParameters);
+ }
+
+ public Result Clear(ClearFlags clearFlags, in Color4 color, float zdepth, int stencil)
+ {
+ return _device.Clear(clearFlags, color, zdepth, stencil);
+ }
+
+ public Result BeginScene()
+ {
+ return _device.BeginScene();
+ }
+
+ public Result EndScene()
+ {
+ return _device.EndScene();
+ }
+
+ public Result Present()
+ {
+ return _device.Present();
+ }
+
+ public Surface GetBackBuffer(int swapChain, int backBuffer)
+ {
+ return _device.GetBackBuffer(swapChain, backBuffer);
+ }
+
+ public Surface GetRenderTarget(int index)
+ {
+ return _device.GetRenderTarget(index);
+ }
+
+ public Result SetRenderState(RenderState state, T value) where T : Enum
+ {
+ return _device.SetRenderState(state, value);
+ }
+
+ private BlendOperation? _lastBlendOperation;
+ public void SetRenderState(RenderState state, BlendOperation value)
+ {
+ if (state == RenderState.BlendOperation)
+ {
+ if (_lastBlendOperation == value)
+ {
+ return;
+ }
+
+ _lastBlendOperation = value;
+ }
+
+ _device.SetRenderState(state, value);
+ }
+
+ private Blend? _lastSourceBlend;
+ private Blend? _lastDestinationBlend;
+ public void SetRenderState(RenderState state, Blend value)
+ {
+ if (state == RenderState.SourceBlend)
+ {
+ if (_lastSourceBlend == value)
+ {
+ return;
+ }
+
+ _lastSourceBlend = value;
+ }
+ else if (state == RenderState.DestinationBlend)
+ {
+ if (_lastDestinationBlend == value)
+ {
+ return;
+ }
+
+ _lastDestinationBlend = value;
+ }
+
+ _device.SetRenderState(state, value);
+ }
+
+ public Result SetRenderState(RenderState state, bool value)
+ {
+ return _device.SetRenderState(state, value);
+ }
+
+ public Result SetRenderState(RenderState state, int value)
+ {
+ return _device.SetRenderState(state, value);
+ }
+
+ public Result SetTextureStageState(int stage, TextureStage type, TextureOperation textureOperation)
+ {
+ return _device.SetTextureStageState(stage, type, textureOperation);
+ }
+
+ public Result SetTextureStageState(int stage, TextureStage type, int value)
+ {
+ return _device.SetTextureStageState(stage, type, value);
+ }
+
+ public Result SetSamplerState(int sampler, SamplerState type, TextureFilter textureFilter)
+ {
+ return _device.SetSamplerState(sampler, type, textureFilter);
+ }
+
+ public Result SetTransform(TransformState state, in Matrix value)
+ {
+ return _device.SetTransform(state, value);
+ }
+
+ private int? _lastSetTextureSampler;
+ private object _lastSetTextureTexture;
+ public void SetTexture(int sampler, BaseTexture texture)
+ {
+ if ( ReferenceEquals(_lastSetTextureTexture, texture) && _lastSetTextureSampler == sampler)
+ {
+ return;
+ }
+
+ _lastSetTextureSampler = sampler;
+ _lastSetTextureTexture = texture;
+ _device.SetTexture(sampler, texture);
+ }
+
+ public Result SetRenderTarget(int targetIndex, Surface target)
+ {
+ return _device.SetRenderTarget(targetIndex, target);
+ }
+
+ public Result DrawUserPrimitives(PrimitiveType primitiveType, int startIndex, int primitiveCount, in T[] data) where T : struct//, new()
+ {
+ return _device.DrawUserPrimitives(primitiveType, startIndex, primitiveCount, data);
+ }
+
+ public Result DrawUserPrimitives(PrimitiveType primitiveType, int primitiveCount, in T[] data) where T : struct//, new()
+ {
+ return _device.DrawUserPrimitives(primitiveType, primitiveCount, data);
+ }
+
+ public Result StretchRectangle(Surface source, Surface destination, TextureFilter filter)
+ {
+ return _device.StretchRectangle(source, destination, filter);
+ }
+
+ public Result UpdateSurface(Surface source, in Rectangle sourceRectangle, Surface destination, in Point destinationPoint)
+ {
+ return _device.UpdateSurface(source, sourceRectangle, destination, destinationPoint);
+ }
+
+ public Viewport Viewport
+ {
+ get => _device.Viewport;
+ set => _device.Viewport = value;
+ }
+
+ public VertexFormat VertexFormat
+ {
+ get => _device.VertexFormat;
+ set => _device.VertexFormat = value;
+ }
+
+ public Capabilities Capabilities => _device.Capabilities;
+ }
+}
\ No newline at end of file
diff --git a/FDK19/繧ｳ繝ｼ繝/01.繝輔Ξ繝ｼ繝繝ｯ繝ｼ繧ｯ/Rendering/DeviceCreationException.cs b/FDK19/繧ｳ繝ｼ繝/01.繝輔Ξ繝ｼ繝繝ｯ繝ｼ繧ｯ/Rendering/DeviceCreationException.cs
new file mode 100644
index 00000000..c6104b80
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/01.繝輔Ξ繝ｼ繝繝ｯ繝ｼ繧ｯ/Rendering/DeviceCreationException.cs
@@ -0,0 +1,71 @@
+ｻｿ/*
+* Copyright (c) 2007-2009 SlimDX Group
+*
+* Permission is hereby granted, free of charge, to any person obtaining a copy
+* of this software and associated documentation files (the "Software"), to deal
+* in the Software without restriction, including without limitation the rights
+* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+* copies of the Software, and to permit persons to whom the Software is
+* furnished to do so, subject to the following conditions:
+*
+* The above copyright notice and this permission notice shall be included in
+* all copies or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+* THE SOFTWARE.
+*/
+using System;
+using System.Runtime.Serialization;
+
+namespace SampleFramework
+{
+ ///
+ /// Thrown when a graphics device cannot be created.
+ ///
+ [Serializable]
+ public class DeviceCreationException : Exception
+ {
+ ///
+ /// Initializes a new instance of the class.
+ ///
+ public DeviceCreationException()
+ {
+ }
+
+ ///
+ /// Initializes a new instance of the class.
+ ///
+ /// The message.
+ public DeviceCreationException(string message)
+ : base(message)
+ {
+ }
+
+ ///
+ /// Initializes a new instance of the class.
+ ///
+ /// The message.
+ /// The inner exception.
+ public DeviceCreationException(string message, Exception innerException)
+ : base(message, innerException)
+ {
+ }
+
+ ///
+ /// Initializes a new instance of the class.
+ ///
+ /// The that holds the serialized object data about the exception being thrown.
+ /// The that contains contextual information about the source or destination.
+ /// The parameter is null.
+ /// The class name is null or is zero (0).
+ protected DeviceCreationException(SerializationInfo info, StreamingContext context)
+ : base(info, context)
+ {
+ }
+ }
+}
diff --git a/FDK19/繧ｳ繝ｼ繝/01.繝輔Ξ繝ｼ繝繝ｯ繝ｼ繧ｯ/Rendering/Direct3D9Manager.cs b/FDK19/繧ｳ繝ｼ繝/01.繝輔Ξ繝ｼ繝繝ｯ繝ｼ繧ｯ/Rendering/Direct3D9Manager.cs
new file mode 100644
index 00000000..f7cf7b85
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/01.繝輔Ξ繝ｼ繝繝ｯ繝ｼ繧ｯ/Rendering/Direct3D9Manager.cs
@@ -0,0 +1,219 @@
+ｻｿ/*
+* Copyright (c) 2007-2009 SlimDX Group
+*
+* Permission is hereby granted, free of charge, to any person obtaining a copy
+* of this software and associated documentation files (the "Software"), to deal
+* in the Software without restriction, including without limitation the rights
+* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+* copies of the Software, and to permit persons to whom the Software is
+* furnished to do so, subject to the following conditions:
+*
+* The above copyright notice and this permission notice shall be included in
+* all copies or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+* THE SOFTWARE.
+*/
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Runtime.InteropServices;
+using System.Security.Permissions;
+using SlimDX;
+using SlimDX.Direct3D9;
+
+namespace SampleFramework
+{
+ ///
+ /// Manages aspects of the graphics device unique to Direct3D9.
+ ///
+ public class Direct3D9Manager
+ {
+ GraphicsDeviceManager manager;
+
+ ///
+ /// Gets the graphics device.
+ ///
+ /// The graphics device.
+#if TEST_Direct3D9Ex
+ public DeviceEx Device //yyagi
+#else
+ public DeviceCache Device
+#endif
+ {
+ get;
+ internal set;
+ }
+
+ ///
+ /// Initializes a new instance of the class.
+ ///
+ /// The parent manager.
+ internal Direct3D9Manager(GraphicsDeviceManager manager)
+ {
+ this.manager = manager;
+ }
+
+ ///
+ /// Creates a vertex declaration using the specified vertex type.
+ ///
+ /// Type of the vertex.
+ /// The vertex declaration for the specified vertex type.
+ [EnvironmentPermission(SecurityAction.LinkDemand)]
+ public VertexDeclaration CreateVertexDeclaration(Type vertexType)
+ {
+ // ensure that we have a value type
+ if (!vertexType.IsValueType)
+ throw new InvalidOperationException("Vertex types must be value types.");
+
+ // grab the list of elements in the vertex
+ List objectAttributes = new List();
+ FieldInfo[] fields = vertexType.GetFields(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance);
+ foreach (FieldInfo field in fields)
+ {
+ // check for the custom attribute
+ VertexElementAttribute[] attributes = (VertexElementAttribute[])field.GetCustomAttributes(typeof(VertexElementAttribute), false);
+ if (field.Name.Contains("<") && field.Name.Contains(">"))
+ {
+ // look up the property matching this field to see if it has the attribute
+ int index1 = field.Name.IndexOf('<');
+ int index2 = field.Name.IndexOf('>');
+
+ // parse out the name
+ string propertyName = field.Name.Substring(index1 + 1, index2 - index1 - 1);
+ PropertyInfo property = vertexType.GetProperty(propertyName, field.FieldType);
+ if (property != null)
+ attributes = (VertexElementAttribute[])property.GetCustomAttributes(typeof(VertexElementAttribute), false);
+ }
+ if (attributes.Length == 1)
+ {
+ // add the attribute to the list
+ attributes[0].Offset = Marshal.OffsetOf(vertexType, field.Name).ToInt32();
+ objectAttributes.Add(attributes[0]);
+ }
+ }
+
+ // make sure we have at least one element
+ if (objectAttributes.Count < 1)
+ throw new InvalidOperationException("The vertex type must have at least one field or property marked with the VertexElement attribute.");
+
+ // loop through the attributes and start building vertex elements
+ List elements = new List();
+ Dictionary usages = new Dictionary();
+ foreach (VertexElementAttribute attribute in objectAttributes)
+ {
+ // check the current usage index
+ if (!usages.ContainsKey(attribute.Usage))
+ usages.Add(attribute.Usage, 0);
+
+ // advance the current usage count
+ int index = usages[attribute.Usage];
+ usages[attribute.Usage]++;
+
+ // create the element
+ elements.Add(new VertexElement((short)attribute.Stream, (short)attribute.Offset, attribute.Type,
+ attribute.Method, attribute.Usage, (byte)index));
+ }
+
+ elements.Add(VertexElement.VertexDeclarationEnd);
+ return new VertexDeclaration(Device.UnderlyingDevice, elements.ToArray());
+ }
+
+ ///
+ /// Creates a render target surface that is compatible with the current device settings.
+ ///
+ /// The width of the surface.
+ /// The height of the surface.
+ /// The newly created render target surface.
+ public Texture CreateRenderTarget(int width, int height)
+ {
+ return new Texture(Device.UnderlyingDevice, width, height, 1, Usage.RenderTarget, manager.CurrentSettings.BackBufferFormat, Pool.Default);
+ }
+
+ ///
+ /// Creates a resolve target for capturing the back buffer.
+ ///
+ /// The newly created resolve target.
+ public Texture CreateResolveTarget()
+ {
+ return new Texture(Device.UnderlyingDevice, manager.ScreenWidth, manager.ScreenHeight, 1, Usage.RenderTarget, manager.CurrentSettings.BackBufferFormat, Pool.Default);
+ }
+
+ ///
+ /// Resolves the current back buffer into a texture.
+ ///
+ /// The target texture.
+ /// Thrown when the resolve process fails.
+ public void ResolveBackBuffer(Texture target)
+ {
+ ResolveBackBuffer(target, 0);
+ }
+
+ ///
+ /// Resolves the current back buffer into a texture.
+ ///
+ /// The target texture.
+ /// The index of the back buffer.
+ /// Thrown when the resolve process fails.
+ public void ResolveBackBuffer(Texture target, int backBufferIndex)
+ {
+ // disable exceptions for this method
+ bool storedThrow = Configuration.ThrowOnError;
+ Configuration.ThrowOnError = false;
+ Surface destination = null;
+
+ try
+ {
+ // grab the current back buffer
+ Surface backBuffer = Device.GetBackBuffer(0, backBufferIndex);
+ if (backBuffer == null || Result.Last.IsFailure)
+ throw new InvalidOperationException("Could not obtain back buffer surface.");
+
+ // grab the destination surface
+ destination = target.GetSurfaceLevel(0);
+ if (destination == null || Result.Last.IsFailure)
+ throw new InvalidOperationException("Could not obtain resolve target surface.");
+
+ // first try to copy using linear filtering
+ if (Device.StretchRectangle(backBuffer, destination, TextureFilter.Linear).IsFailure)
+ {
+ // that failed, so try with no filtering
+ if (Device.StretchRectangle(backBuffer, destination, TextureFilter.None).IsFailure)
+ {
+ // that failed as well, so the last thing we can try is a load surface call
+ if (Surface.FromSurface(destination, backBuffer, Filter.Default, 0).IsFailure)
+ throw new InvalidOperationException("Could not copy surfaces.");
+ }
+ }
+ }
+ finally
+ {
+ if (destination != null)
+ destination.Dispose();
+ Configuration.ThrowOnError = storedThrow;
+ }
+ }
+
+ ///
+ /// Resets the render target.
+ ///
+ public void ResetRenderTarget()
+ {
+ Surface backBuffer = Device.GetBackBuffer(0, 0);
+
+ try
+ {
+ Device.SetRenderTarget(0, backBuffer);
+ }
+ finally
+ {
+ backBuffer.Dispose();
+ }
+ }
+ }
+}
diff --git a/FDK19/繧ｳ繝ｼ繝/01.繝輔Ξ繝ｼ繝繝ｯ繝ｼ繧ｯ/Rendering/Enums.cs b/FDK19/繧ｳ繝ｼ繝/01.繝輔Ξ繝ｼ繝繝ｯ繝ｼ繧ｯ/Rendering/Enums.cs
new file mode 100644
index 00000000..2e6e35df
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/01.繝輔Ξ繝ｼ繝繝ｯ繝ｼ繧ｯ/Rendering/Enums.cs
@@ -0,0 +1,25 @@
+ｻｿ/*
+* Copyright (c) 2007-2009 SlimDX Group
+*
+* Permission is hereby granted, free of charge, to any person obtaining a copy
+* of this software and associated documentation files (the "Software"), to deal
+* in the Software without restriction, including without limitation the rights
+* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+* copies of the Software, and to permit persons to whom the Software is
+* furnished to do so, subject to the following conditions:
+*
+* The above copyright notice and this permission notice shall be included in
+* all copies or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+* THE SOFTWARE.
+*/
+
+namespace SampleFramework
+{
+}
diff --git a/FDK19/繧ｳ繝ｼ繝/01.繝輔Ξ繝ｼ繝繝ｯ繝ｼ繧ｯ/Rendering/GraphicsDeviceManager.cs b/FDK19/繧ｳ繝ｼ繝/01.繝輔Ξ繝ｼ繝繝ｯ繝ｼ繧ｯ/Rendering/GraphicsDeviceManager.cs
new file mode 100644
index 00000000..55dc16bc
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/01.繝輔Ξ繝ｼ繝繝ｯ繝ｼ繧ｯ/Rendering/GraphicsDeviceManager.cs
@@ -0,0 +1,701 @@
+ｻｿ/*
+* Copyright (c) 2007-2009 SlimDX Group
+*
+* Permission is hereby granted, free of charge, to any person obtaining a copy
+* of this software and associated documentation files (the "Software"), to deal
+* in the Software without restriction, including without limitation the rights
+* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+* copies of the Software, and to permit persons to whom the Software is
+* furnished to do so, subject to the following conditions:
+*
+* The above copyright notice and this permission notice shall be included in
+* all copies or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+* THE SOFTWARE.
+*/
+using System;
+using System.ComponentModel;
+using System.Drawing;
+using System.Text;
+using System.Threading;
+using System.Windows.Forms;
+using SlimDX;
+using SlimDX.Direct3D9;
+using SlimDX.DXGI;
+using System.Diagnostics;
+
+namespace SampleFramework
+{
+ ///
+ /// Handles the configuration and management of the graphics device.
+ ///
+ public class GraphicsDeviceManager : IDisposable
+ {
+ Game game;
+ bool ignoreSizeChanges;
+ bool deviceLost;
+// bool doNotStoreBufferSize;
+// bool renderingOccluded;
+
+ int fullscreenWindowWidth;
+ int fullscreenWindowHeight;
+ int windowedWindowWidth;
+ int windowedWindowHeight;
+ WINDOWPLACEMENT windowedPlacement;
+ long windowedStyle;
+ bool savedTopmost;
+
+#if TEST_Direct3D9Ex
+ internal static Direct3DEx Direct3D9Object // yyagi
+#else
+ internal static Direct3D Direct3D9Object
+#endif
+ {
+ get;
+ private set;
+ }
+
+ public DeviceSettings CurrentSettings
+ {
+ get;
+ private set;
+ }
+ public bool IsWindowed
+ {
+ get { return CurrentSettings.Windowed; }
+ }
+ public int ScreenWidth
+ {
+ get { return CurrentSettings.BackBufferWidth; }
+ }
+ public int ScreenHeight
+ {
+ get { return CurrentSettings.BackBufferHeight; }
+ }
+ public Size ScreenSize
+ {
+ get { return new Size(CurrentSettings.BackBufferWidth, CurrentSettings.BackBufferHeight); }
+ }
+ public Direct3D9Manager Direct3D9
+ {
+ get;
+ private set;
+ }
+ public string DeviceStatistics
+ {
+ get;
+ private set;
+ }
+ public string DeviceInformation
+ {
+ get;
+ private set;
+ }
+
+ public GraphicsDeviceManager( Game game )
+ {
+ if( game == null )
+ throw new ArgumentNullException( "game" );
+
+ this.game = game;
+
+ game.Window.ScreenChanged += Window_ScreenChanged;
+ game.Window.UserResized += Window_UserResized;
+
+ game.FrameStart += game_FrameStart;
+ game.FrameEnd += game_FrameEnd;
+
+ Direct3D9 = new Direct3D9Manager( this );
+ }
+
+ public void Dispose()
+ {
+ Dispose(true);
+ GC.SuppressFinalize(this);
+ }
+
+ public void ChangeDevice( DeviceSettings settings, DeviceSettings minimumSettings )
+ {
+ if( settings == null )
+ throw new ArgumentNullException( "settings" );
+
+ Enumeration9.MinimumSettings = minimumSettings;
+
+ DeviceSettings validSettings = DeviceSettings.FindValidSettings( settings );
+
+ validSettings.Direct3D9.PresentParameters.DeviceWindowHandle = game.Window.Handle;
+
+ CreateDevice( validSettings );
+ }
+ public void ChangeDevice(bool windowed, int desiredWidth, int desiredHeight)
+ {
+ DeviceSettings desiredSettings = new DeviceSettings();
+ desiredSettings.Windowed = windowed;
+ desiredSettings.BackBufferWidth = desiredWidth;
+ desiredSettings.BackBufferHeight = desiredHeight;
+
+ ChangeDevice(desiredSettings, null);
+ }
+ public void ChangeDevice(DeviceSettings settings)
+ {
+ ChangeDevice(settings, null);
+ }
+
+ public void ToggleFullScreen()
+ {
+ if (!EnsureDevice())
+ throw new InvalidOperationException("No valid device.");
+
+ DeviceSettings newSettings = CurrentSettings.Clone();
+
+ newSettings.Windowed = !newSettings.Windowed;
+
+ int width = newSettings.Windowed ? windowedWindowWidth : fullscreenWindowWidth;
+ int height = newSettings.Windowed ? windowedWindowHeight : fullscreenWindowHeight;
+
+ newSettings.BackBufferWidth = width;
+ newSettings.BackBufferHeight = height;
+
+ ChangeDevice(newSettings);
+ }
+ public bool EnsureDevice()
+ {
+ if (Direct3D9.Device != null && !deviceLost)
+ return true;
+
+ return false;
+ }
+
+ protected virtual void Dispose( bool disposing )
+ {
+ if( this.bDisposed )
+ return;
+ this.bDisposed = true;
+
+ if( disposing )
+ ReleaseDevice();
+
+ }
+ private bool bDisposed = false;
+
+ void CreateDevice(DeviceSettings settings)
+ {
+ DeviceSettings oldSettings = CurrentSettings;
+ CurrentSettings = settings;
+
+ ignoreSizeChanges = true;
+
+ bool keepCurrentWindowSize = false;
+ if (settings.BackBufferWidth == 0 && settings.BackBufferHeight == 0)
+ keepCurrentWindowSize = true;
+
+ // handle the window state in Direct3D9 (it will be handled for us in DXGI)
+ // check if we are going to windowed or fullscreen mode
+ if( settings.Windowed )
+ {
+ if( oldSettings != null && !oldSettings.Windowed )
+ NativeMethods.SetWindowLong( game.Window.Handle, WindowConstants.GWL_STYLE, (uint) windowedStyle );
+ }
+ else
+ {
+ if( oldSettings == null || oldSettings.Windowed )
+ {
+ savedTopmost = game.Window.TopMost;
+ long style = NativeMethods.GetWindowLong( game.Window.Handle, WindowConstants.GWL_STYLE );
+ style &= ~WindowConstants.WS_MAXIMIZE & ~WindowConstants.WS_MINIMIZE;
+ windowedStyle = style;
+
+ windowedPlacement = new WINDOWPLACEMENT();
+ windowedPlacement.length = WINDOWPLACEMENT.Length;
+ NativeMethods.GetWindowPlacement( game.Window.Handle, ref windowedPlacement );
+ }
+
+ // hide the window until we are done messing with it
+ game.Window.Hide();
+ NativeMethods.SetWindowLong( game.Window.Handle, WindowConstants.GWL_STYLE, (uint) ( WindowConstants.WS_POPUP | WindowConstants.WS_SYSMENU ) );
+
+ WINDOWPLACEMENT placement = new WINDOWPLACEMENT();
+ placement.length = WINDOWPLACEMENT.Length;
+ NativeMethods.GetWindowPlacement( game.Window.Handle, ref placement );
+
+ // check if we are in the middle of a restore
+ if( ( placement.flags & WindowConstants.WPF_RESTORETOMAXIMIZED ) != 0 )
+ {
+ // update the flags to avoid sizing issues
+ placement.flags &= ~WindowConstants.WPF_RESTORETOMAXIMIZED;
+ placement.showCmd = WindowConstants.SW_RESTORE;
+ NativeMethods.SetWindowPlacement( game.Window.Handle, ref placement );
+ }
+ }
+
+ if (settings.Windowed)
+ {
+ if (oldSettings != null && !oldSettings.Windowed)
+ {
+ fullscreenWindowWidth = oldSettings.BackBufferWidth;
+ fullscreenWindowHeight = oldSettings.BackBufferHeight;
+ }
+ }
+ else
+ {
+ if (oldSettings != null && oldSettings.Windowed)
+ {
+ windowedWindowWidth = oldSettings.BackBufferWidth;
+ windowedWindowHeight = oldSettings.BackBufferHeight;
+ }
+ }
+
+ // check if the device can be reset, or if we need to completely recreate it
+ Result result = SlimDX.Direct3D9.ResultCode.Success;
+ bool canReset = CanDeviceBeReset(oldSettings, settings);
+ if (canReset)
+ result = ResetDevice();
+
+ if (result == SlimDX.Direct3D9.ResultCode.DeviceLost)
+ deviceLost = true;
+ else if (!canReset || result.IsFailure)
+ {
+ if (oldSettings != null)
+ ReleaseDevice();
+
+ InitializeDevice();
+ }
+
+ UpdateDeviceInformation();
+
+ // check if we changed from fullscreen to windowed mode
+ if (oldSettings != null && !oldSettings.Windowed && settings.Windowed)
+ {
+ NativeMethods.SetWindowPlacement(game.Window.Handle, ref windowedPlacement);
+ game.Window.TopMost = savedTopmost;
+ }
+
+ // check if we need to resize
+ if (settings.Windowed && !keepCurrentWindowSize)
+ {
+ int width;
+ int height;
+ if (NativeMethods.IsIconic(game.Window.Handle))
+ {
+ WINDOWPLACEMENT placement = new WINDOWPLACEMENT();
+ placement.length = WINDOWPLACEMENT.Length;
+ NativeMethods.GetWindowPlacement(game.Window.Handle, ref placement);
+
+ // check if we are being restored
+ if ((placement.flags & WindowConstants.WPF_RESTORETOMAXIMIZED) != 0 && placement.showCmd == WindowConstants.SW_SHOWMINIMIZED)
+ {
+ NativeMethods.ShowWindow(game.Window.Handle, WindowConstants.SW_RESTORE);
+
+ Rectangle rect = NativeMethods.GetClientRectangle(game.Window.Handle);
+
+ width = rect.Width;
+ height = rect.Height;
+ NativeMethods.ShowWindow(game.Window.Handle, WindowConstants.SW_MINIMIZE);
+ }
+ else
+ {
+ NativeRectangle frame = new NativeRectangle();
+ NativeMethods.AdjustWindowRect(ref frame, (uint)windowedStyle, false);
+ int frameWidth = frame.right - frame.left;
+ int frameHeight = frame.bottom - frame.top;
+
+ width = placement.rcNormalPosition.right - placement.rcNormalPosition.left - frameWidth;
+ height = placement.rcNormalPosition.bottom - placement.rcNormalPosition.top - frameHeight;
+ }
+ }
+ else
+ {
+ Rectangle rect = NativeMethods.GetClientRectangle(game.Window.Handle);
+ width = rect.Width;
+ height = rect.Height;
+ }
+
+ // check if we have a different desired size
+ if (width != settings.BackBufferWidth ||
+ height != settings.BackBufferHeight)
+ {
+ if (NativeMethods.IsIconic(game.Window.Handle))
+ NativeMethods.ShowWindow(game.Window.Handle, WindowConstants.SW_RESTORE);
+ if (NativeMethods.IsZoomed(game.Window.Handle))
+ NativeMethods.ShowWindow(game.Window.Handle, WindowConstants.SW_RESTORE);
+
+ NativeRectangle rect = new NativeRectangle();
+ rect.right = settings.BackBufferWidth;
+ rect.bottom = settings.BackBufferHeight;
+ NativeMethods.AdjustWindowRect(ref rect,
+ NativeMethods.GetWindowLong(game.Window.Handle, WindowConstants.GWL_STYLE), false);
+
+ NativeMethods.SetWindowPos(game.Window.Handle, IntPtr.Zero, 0, 0, rect.right - rect.left,
+ rect.bottom - rect.top, WindowConstants.SWP_NOZORDER | WindowConstants.SWP_NOMOVE);
+
+ Rectangle r = NativeMethods.GetClientRectangle(game.Window.Handle);
+ int clientWidth = r.Width;
+ int clientHeight = r.Height;
+
+ // check if the size was modified by Windows
+ if (clientWidth != settings.BackBufferWidth ||
+ clientHeight != settings.BackBufferHeight)
+ {
+ DeviceSettings newSettings = CurrentSettings.Clone();
+ newSettings.BackBufferWidth = 0;
+ newSettings.BackBufferHeight = 0;
+ if (newSettings.Direct3D9 != null)
+ {
+ newSettings.Direct3D9.PresentParameters.BackBufferWidth = GameWindowSize.Width; // #23510 2010.10.31 add yyagi: to avoid setting BackBufferSize=ClientSize
+ newSettings.Direct3D9.PresentParameters.BackBufferHeight = GameWindowSize.Height; // #23510 2010.10.31 add yyagi: to avoid setting BackBufferSize=ClientSize
+ }
+
+ CreateDevice(newSettings);
+ }
+ }
+ }
+
+ // if the window is still hidden, make sure it is shown
+ if (!game.Window.Visible)
+ NativeMethods.ShowWindow(game.Window.Handle, WindowConstants.SW_SHOW);
+
+ // set the execution state of the thread
+ if (!IsWindowed)
+ NativeMethods.SetThreadExecutionState(WindowConstants.ES_DISPLAY_REQUIRED | WindowConstants.ES_CONTINUOUS);
+ else
+ NativeMethods.SetThreadExecutionState(WindowConstants.ES_CONTINUOUS);
+
+ ignoreSizeChanges = false;
+ }
+
+ void Window_UserResized( object sender, EventArgs e )
+ {
+ if( ignoreSizeChanges || !EnsureDevice() || ( !IsWindowed ) )
+ return;
+
+ DeviceSettings newSettings = CurrentSettings.Clone();
+
+ Rectangle rect = NativeMethods.GetClientRectangle( game.Window.Handle );
+ if( rect.Width != newSettings.BackBufferWidth || rect.Height != newSettings.BackBufferHeight )
+ {
+ newSettings.BackBufferWidth = 0;
+ newSettings.BackBufferHeight = 0;
+ newSettings.Direct3D9.PresentParameters.BackBufferWidth = GameWindowSize.Width; // #23510 2010.10.31 add yyagi: to avoid setting BackBufferSize=ClientSize
+ newSettings.Direct3D9.PresentParameters.BackBufferHeight = GameWindowSize.Height; //
+ CreateDevice( newSettings );
+ }
+ }
+ void Window_ScreenChanged( object sender, EventArgs e )
+ {
+ if( !EnsureDevice() || !CurrentSettings.Windowed || ignoreSizeChanges )
+ return;
+
+ IntPtr windowMonitor = NativeMethods.MonitorFromWindow( game.Window.Handle, WindowConstants.MONITOR_DEFAULTTOPRIMARY );
+
+ DeviceSettings newSettings = CurrentSettings.Clone();
+ int adapterOrdinal = GetAdapterOrdinal( windowMonitor );
+ if( adapterOrdinal == -1 )
+ return;
+ newSettings.Direct3D9.AdapterOrdinal = adapterOrdinal;
+
+ newSettings.BackBufferWidth = 0; // #23510 2010.11.1 add yyagi to avoid to reset to 640x480 for the first time in XP.
+ newSettings.BackBufferHeight = 0; //
+ newSettings.Direct3D9.PresentParameters.BackBufferWidth = GameWindowSize.Width; //
+ newSettings.Direct3D9.PresentParameters.BackBufferHeight = GameWindowSize.Height; //
+
+ CreateDevice(newSettings);
+ }
+
+ void game_FrameEnd( object sender, EventArgs e )
+ {
+ Result result = SlimDX.Direct3D9.ResultCode.Success;
+ try
+ {
+ result = Direct3D9.Device.Present();
+ }
+ catch (Direct3D9Exception) // #23842 2011.1.6 yyagi: catch D3D9Exception to avoid unexpected termination by changing VSyncWait in fullscreen.
+ {
+ deviceLost = true;
+ }
+ if( result == SlimDX.Direct3D9.ResultCode.DeviceLost )
+ deviceLost = true;
+ }
+ void game_FrameStart(object sender, CancelEventArgs e)
+ {
+ if (Direct3D9.Device == null )
+ {
+ e.Cancel = true;
+ return;
+ }
+
+// if (!game.IsActive || deviceLost) // #23568 2010.11.3 yyagi: separate conditions to support valiable sleep value when !IsActive.
+ if (deviceLost)
+ Thread.Sleep(50);
+ else if (!game.IsActive && !this.CurrentSettings.EnableVSync) // #23568 2010.11.4 yyagi: Don't add sleep() while VSync is enabled.
+ Thread.Sleep(this.game.InactiveSleepTime.Milliseconds);
+
+ if (deviceLost)
+ {
+ Result result = Direct3D9.Device.TestCooperativeLevel();
+ if (result == SlimDX.Direct3D9.ResultCode.DeviceLost)
+ {
+ e.Cancel = true;
+ return;
+ }
+
+ // if we are windowed, check the adapter format to see if the user
+ // changed the desktop format, causing a lost device
+ if (IsWindowed)
+ {
+ DisplayMode displayMode = GraphicsDeviceManager.Direct3D9Object.GetAdapterDisplayMode(CurrentSettings.Direct3D9.AdapterOrdinal);
+ if (CurrentSettings.Direct3D9.AdapterFormat != displayMode.Format)
+ {
+ DeviceSettings newSettings = CurrentSettings.Clone();
+ ChangeDevice(newSettings);
+ e.Cancel = true;
+ return;
+ }
+ }
+
+ result = ResetDevice();
+ if (result.IsFailure)
+ {
+ e.Cancel = true;
+ return;
+ }
+ }
+
+ deviceLost = false;
+ }
+
+ bool CanDeviceBeReset( DeviceSettings oldSettings, DeviceSettings newSettings )
+ {
+ if( oldSettings == null )
+ return false;
+
+ return Direct3D9.Device != null &&
+ oldSettings.Direct3D9.AdapterOrdinal == newSettings.Direct3D9.AdapterOrdinal &&
+ oldSettings.Direct3D9.DeviceType == newSettings.Direct3D9.DeviceType &&
+ oldSettings.Direct3D9.CreationFlags == newSettings.Direct3D9.CreationFlags;
+ }
+
+ void InitializeDevice()
+ {
+ try
+ {
+ EnsureD3D9();
+
+#if TEST_Direct3D9Ex
+ // 2011.4.26 yyagi
+ // Direct3D9.DeviceEx繧貞他縺ｶ髫(IDirect3D9Ex::CreateDeviceEx繧貞他縺ｶ髫)縲
+ // 繝輔Ν繧ｹ繧ｯ繝ｪ繝ｼ繝ｳ繝｢繝ｼ繝峨〒蛻晄悄蛹悶☆繧句ｴ蜷医ｯDisplayModeEx(D3DDISPLAYMODEEX *pFullscreenDisplayMode)縺ｫ
+ // 驕ｩ蛻縺ｪ蛟､繧定ｨｭ螳壹☆繧句ｿ隕√≠繧翫
+ // 荳譁ｹ縲√え繧､繝ｳ繝峨え繝｢繝ｼ繝峨〒蛻晄悄蛹悶☆繧句ｴ蜷医ｯ縲．3DDISPLAYMODEEX繧誰ULL縺ｫ縺吶ｋ蠢隕√′縺ゅｋ縺後
+ // DisplayModeEx縺君ULL荳榊庄縺ｨ螳夂ｾｩ縺輔ｌ縺ｦ縺繧九◆繧√．eviceEx縺ｮoverload縺ｮ荳ｭ縺ｧDisplayModeEx繧貞ｼ墓焚縺ｫ蜿悶ｉ縺ｪ縺繧ゅｮ繧
+ // 菴ｿ縺縲(DeviceEx蛛ｴ縺ｧD3DDISPLAYMODEEX繧誰ULL縺ｫ縺励※縺上ｌ繧)
+ // 邨仙ｱ縲．eviceEx縺ｮ蜻ｼ縺ｳ蜃ｺ縺励ｮ髫帙↓縲√ヵ繝ｫ繧ｹ繧ｯ繝ｪ繝ｼ繝ｳ縺九←縺縺九〒蝣ｴ蜷亥縺代′蠢隕√→縺ｪ繧九
+ if ( CurrentSettings.Direct3D9.PresentParameters.Windowed == false )
+ {
+ DisplayModeEx fullScreenDisplayMode = new DisplayModeEx();
+ fullScreenDisplayMode.Width = CurrentSettings.Direct3D9.PresentParameters.BackBufferWidth;
+ fullScreenDisplayMode.Height = CurrentSettings.Direct3D9.PresentParameters.BackBufferHeight;
+ fullScreenDisplayMode.RefreshRate = CurrentSettings.Direct3D9.PresentParameters.FullScreenRefreshRateInHertz;
+ fullScreenDisplayMode.Format = CurrentSettings.Direct3D9.PresentParameters.BackBufferFormat;
+
+ Direct3D9.Device = new SlimDX.Direct3D9.DeviceEx( Direct3D9Object, CurrentSettings.Direct3D9.AdapterOrdinal,
+ CurrentSettings.Direct3D9.DeviceType, game.Window.Handle,
+ CurrentSettings.Direct3D9.CreationFlags, CurrentSettings.Direct3D9.PresentParameters, fullScreenDisplayMode );
+ }
+ else
+ {
+ Direct3D9.Device = new SlimDX.Direct3D9.DeviceEx( Direct3D9Object, CurrentSettings.Direct3D9.AdapterOrdinal,
+ CurrentSettings.Direct3D9.DeviceType, game.Window.Handle,
+ CurrentSettings.Direct3D9.CreationFlags, CurrentSettings.Direct3D9.PresentParameters );
+ }
+ Direct3D9.Device.MaximumFrameLatency = 1;
+#else
+ Direct3D9.Device = new DeviceCache( new SlimDX.Direct3D9.Device( Direct3D9Object, CurrentSettings.Direct3D9.AdapterOrdinal,
+ CurrentSettings.Direct3D9.DeviceType, game.Window.Handle,
+ CurrentSettings.Direct3D9.CreationFlags, CurrentSettings.Direct3D9.PresentParameters ) );
+#endif
+ if ( Result.Last == SlimDX.Direct3D9.ResultCode.DeviceLost )
+ {
+ deviceLost = true;
+ return;
+ }
+#if TEST_Direct3D9Ex
+ Direct3D9.Device.MaximumFrameLatency = 1; // yyagi
+#endif
+ }
+ catch( Exception e )
+ {
+ throw new DeviceCreationException( "Could not create graphics device.", e );
+ }
+
+ PropogateSettings();
+
+ UpdateDeviceStats();
+
+ game.Initialize();
+ game.LoadContent();
+ }
+
+ Result ResetDevice()
+ {
+ game.UnloadContent();
+
+ Result result = Direct3D9.Device.Reset( CurrentSettings.Direct3D9.PresentParameters );
+ if( result == SlimDX.Direct3D9.ResultCode.DeviceLost )
+ return result;
+
+ PropogateSettings();
+ UpdateDeviceStats();
+ game.LoadContent();
+
+ return Result.Last;
+ }
+
+ void ReleaseDevice()
+ {
+ ReleaseDevice9();
+ }
+ void ReleaseDevice9()
+ {
+ if (Direct3D9.Device == null)
+ return;
+
+ if (game != null)
+ {
+ game.UnloadContent();
+ game.Dispose(true);
+ }
+
+ try
+ {
+ Direct3D9.Device.Dispose();
+ }
+ catch( ObjectDisposedException e )
+ {
+ // 譎ゅ逋ｺ逕溘☆繧九ｮ縺ｧ繧ｭ繝｣繝繝√＠縺ｦ縺翫￥縲
+ Trace.TraceError( e.ToString() );
+ Trace.TraceError( "萓句､悶′逋ｺ逕溘＠縺ｾ縺励◆縺悟ｦ逅繧堤ｶ咏ｶ壹＠縺ｾ縺吶 (fc0b6e70-181e-410f-b47f-5490ca4ce0c3)" );
+ }
+ Direct3D9Object.Dispose();
+
+ Direct3D9Object = null;
+ Direct3D9.Device = null;
+ }
+ void PropogateSettings()
+ {
+ CurrentSettings.BackBufferCount = CurrentSettings.Direct3D9.PresentParameters.BackBufferCount;
+ CurrentSettings.BackBufferWidth = CurrentSettings.Direct3D9.PresentParameters.BackBufferWidth;
+ CurrentSettings.BackBufferHeight = CurrentSettings.Direct3D9.PresentParameters.BackBufferHeight;
+ CurrentSettings.BackBufferFormat = CurrentSettings.Direct3D9.PresentParameters.BackBufferFormat;
+ CurrentSettings.DepthStencilFormat = CurrentSettings.Direct3D9.PresentParameters.AutoDepthStencilFormat;
+ CurrentSettings.DeviceType = CurrentSettings.Direct3D9.DeviceType;
+ CurrentSettings.MultisampleQuality = CurrentSettings.Direct3D9.PresentParameters.MultisampleQuality;
+ CurrentSettings.MultisampleType = CurrentSettings.Direct3D9.PresentParameters.Multisample;
+ CurrentSettings.RefreshRate = CurrentSettings.Direct3D9.PresentParameters.FullScreenRefreshRateInHertz;
+ CurrentSettings.Windowed = CurrentSettings.Direct3D9.PresentParameters.Windowed;
+ }
+
+ void UpdateDeviceInformation()
+ {
+ StringBuilder builder = new StringBuilder();
+
+ if( CurrentSettings.Direct3D9.DeviceType == DeviceType.Hardware )
+ builder.Append( "HAL" );
+ else if( CurrentSettings.Direct3D9.DeviceType == DeviceType.Reference )
+ builder.Append( "REF" );
+ else if( CurrentSettings.Direct3D9.DeviceType == DeviceType.Software )
+ builder.Append( "SW" );
+
+ if( ( CurrentSettings.Direct3D9.CreationFlags & CreateFlags.HardwareVertexProcessing ) != 0 )
+ if( CurrentSettings.Direct3D9.DeviceType == DeviceType.Hardware )
+ builder.Append( " (hw vp)" );
+ else
+ builder.Append( " (simulated hw vp)" );
+ else if( ( CurrentSettings.Direct3D9.CreationFlags & CreateFlags.MixedVertexProcessing ) != 0 )
+ if( CurrentSettings.Direct3D9.DeviceType == DeviceType.Hardware )
+ builder.Append( " (mixed vp)" );
+ else
+ builder.Append( " (simulated mixed vp)" );
+ else
+ builder.Append( " (sw vp)" );
+
+ if( CurrentSettings.Direct3D9.DeviceType == DeviceType.Hardware )
+ {
+ // loop through each adapter until we find the right one
+ foreach( AdapterInfo9 adapterInfo in Enumeration9.Adapters )
+ {
+ if( adapterInfo.AdapterOrdinal == CurrentSettings.Direct3D9.AdapterOrdinal )
+ {
+ builder.AppendFormat( ": {0}", adapterInfo.Description );
+ break;
+ }
+ }
+ }
+
+ DeviceInformation = builder.ToString();
+ }
+
+ void UpdateDeviceStats()
+ {
+ StringBuilder builder = new StringBuilder();
+
+ builder.Append( "D3D9 Vsync " );
+
+ if( CurrentSettings.Direct3D9.PresentParameters.PresentationInterval == PresentInterval.Immediate )
+ builder.Append( "off" );
+ else
+ builder.Append( "on" );
+
+ builder.AppendFormat( " ({0}x{1}), ", CurrentSettings.Direct3D9.PresentParameters.BackBufferWidth, CurrentSettings.Direct3D9.PresentParameters.BackBufferHeight );
+
+ if( CurrentSettings.Direct3D9.AdapterFormat == CurrentSettings.Direct3D9.PresentParameters.BackBufferFormat )
+ builder.Append( Enum.GetName( typeof( SlimDX.Direct3D9.Format ), CurrentSettings.Direct3D9.AdapterFormat ) );
+ else
+ builder.AppendFormat( "backbuf {0}, adapter {1}",
+ Enum.GetName( typeof( SlimDX.Direct3D9.Format ), CurrentSettings.Direct3D9.AdapterFormat ),
+ Enum.GetName( typeof( SlimDX.Direct3D9.Format ), CurrentSettings.Direct3D9.PresentParameters.BackBufferFormat ) );
+
+ builder.AppendFormat( " ({0})", Enum.GetName( typeof( SlimDX.Direct3D9.Format ), CurrentSettings.Direct3D9.PresentParameters.AutoDepthStencilFormat ) );
+
+ if( CurrentSettings.Direct3D9.PresentParameters.Multisample == MultisampleType.NonMaskable )
+ builder.Append( " (Nonmaskable Multisample)" );
+ else if( CurrentSettings.Direct3D9.PresentParameters.Multisample != MultisampleType.None )
+ builder.AppendFormat( " ({0}x Multisample)", (int) CurrentSettings.Direct3D9.PresentParameters.Multisample );
+
+ DeviceStatistics = builder.ToString();
+ }
+
+ int GetAdapterOrdinal( IntPtr screen )
+ {
+ AdapterInfo9 adapter = null;
+ foreach( AdapterInfo9 a in Enumeration9.Adapters )
+ {
+ if( Direct3D9Object.GetAdapterMonitor( a.AdapterOrdinal ) == screen )
+ {
+ adapter = a;
+ break;
+ }
+ }
+
+ if( adapter != null )
+ return adapter.AdapterOrdinal;
+
+ return -1;
+ }
+
+ internal static void EnsureD3D9()
+ {
+ if ( Direct3D9Object == null )
+#if TEST_Direct3D9Ex
+ Direct3D9Object = new Direct3DEx(); // yyagi
+#else
+ Direct3D9Object = new Direct3D();
+#endif
+ }
+ }
+}
diff --git a/FDK19/繧ｳ繝ｼ繝/01.繝輔Ξ繝ｼ繝繝ｯ繝ｼ繧ｯ/Rendering/NoCompatibleDevicesException.cs b/FDK19/繧ｳ繝ｼ繝/01.繝輔Ξ繝ｼ繝繝ｯ繝ｼ繧ｯ/Rendering/NoCompatibleDevicesException.cs
new file mode 100644
index 00000000..0bb45d00
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/01.繝輔Ξ繝ｼ繝繝ｯ繝ｼ繧ｯ/Rendering/NoCompatibleDevicesException.cs
@@ -0,0 +1,71 @@
+ｻｿ/*
+* Copyright (c) 2007-2009 SlimDX Group
+*
+* Permission is hereby granted, free of charge, to any person obtaining a copy
+* of this software and associated documentation files (the "Software"), to deal
+* in the Software without restriction, including without limitation the rights
+* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+* copies of the Software, and to permit persons to whom the Software is
+* furnished to do so, subject to the following conditions:
+*
+* The above copyright notice and this permission notice shall be included in
+* all copies or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+* THE SOFTWARE.
+*/
+using System;
+using System.Runtime.Serialization;
+
+namespace SampleFramework
+{
+ ///
+ /// Thrown when no available graphics device fits the given device preferences.
+ ///
+ [Serializable]
+ public class NoCompatibleDevicesException : Exception
+ {
+ ///
+ /// Initializes a new instance of the class.
+ ///
+ public NoCompatibleDevicesException()
+ {
+ }
+
+ ///
+ /// Initializes a new instance of the class.
+ ///
+ /// The message.
+ public NoCompatibleDevicesException(string message)
+ : base(message)
+ {
+ }
+
+ ///
+ /// Initializes a new instance of the class.
+ ///
+ /// The message.
+ /// The inner exception.
+ public NoCompatibleDevicesException(string message, Exception innerException)
+ : base(message, innerException)
+ {
+ }
+
+ ///
+ /// Initializes a new instance of the class.
+ ///
+ /// The that holds the serialized object data about the exception being thrown.
+ /// The that contains contextual information about the source or destination.
+ /// The parameter is null.
+ /// The class name is null or is zero (0).
+ protected NoCompatibleDevicesException(SerializationInfo info, StreamingContext context)
+ : base(info, context)
+ {
+ }
+ }
+}
diff --git a/FDK19/繧ｳ繝ｼ繝/01.繝輔Ξ繝ｼ繝繝ｯ繝ｼ繧ｯ/Rendering/VertexElementAttribute.cs b/FDK19/繧ｳ繝ｼ繝/01.繝輔Ξ繝ｼ繝繝ｯ繝ｼ繧ｯ/Rendering/VertexElementAttribute.cs
new file mode 100644
index 00000000..cd598321
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/01.繝輔Ξ繝ｼ繝繝ｯ繝ｼ繧ｯ/Rendering/VertexElementAttribute.cs
@@ -0,0 +1,94 @@
+ｻｿ/*
+* Copyright (c) 2007-2009 SlimDX Group
+*
+* Permission is hereby granted, free of charge, to any person obtaining a copy
+* of this software and associated documentation files (the "Software"), to deal
+* in the Software without restriction, including without limitation the rights
+* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+* copies of the Software, and to permit persons to whom the Software is
+* furnished to do so, subject to the following conditions:
+*
+* The above copyright notice and this permission notice shall be included in
+* all copies or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+* THE SOFTWARE.
+*/
+using System;
+using SlimDX.Direct3D9;
+
+namespace SampleFramework
+{
+ ///
+ /// Indicates that the target code element is part of a vertex declaration.
+ ///
+ [AttributeUsage(AttributeTargets.Field | AttributeTargets.Property)]
+ public sealed class VertexElementAttribute : Attribute
+ {
+ ///
+ /// Gets or sets the stream index.
+ ///
+ /// The stream index.
+ public int Stream
+ {
+ get;
+ set;
+ }
+
+ ///
+ /// Gets or sets the tessellation method.
+ ///
+ /// The tessellation method.
+ public DeclarationMethod Method
+ {
+ get;
+ set;
+ }
+
+ ///
+ /// Gets or sets the element usage.
+ ///
+ /// The element usage.
+ public DeclarationUsage Usage
+ {
+ get;
+ private set;
+ }
+
+ ///
+ /// Gets or sets the type of the data.
+ ///
+ /// The type of the data.
+ public DeclarationType Type
+ {
+ get;
+ private set;
+ }
+
+ ///
+ /// Gets or sets the offset.
+ ///
+ /// The offset.
+ internal int Offset
+ {
+ get;
+ set;
+ }
+
+ ///
+ /// Initializes a new instance of the class.
+ ///
+ /// The type.
+ /// The vertex element usage.
+ public VertexElementAttribute(DeclarationType type, DeclarationUsage usage)
+ {
+ Type = type;
+ Usage = usage;
+ }
+ }
+}
diff --git a/FDK19/繧ｳ繝ｼ繝/01.繝輔Ξ繝ｼ繝繝ｯ繝ｼ繧ｯ/Resources/sdx_icon_black.ico b/FDK19/繧ｳ繝ｼ繝/01.繝輔Ξ繝ｼ繝繝ｯ繝ｼ繧ｯ/Resources/sdx_icon_black.ico
new file mode 100644
index 00000000..a579579b
Binary files /dev/null and b/FDK19/繧ｳ繝ｼ繝/01.繝輔Ξ繝ｼ繝繝ｯ繝ｼ繧ｯ/Resources/sdx_icon_black.ico differ
diff --git a/FDK19/繧ｳ繝ｼ繝/01.繝輔Ξ繝ｼ繝繝ｯ繝ｼ繧ｯ/Utilities/Camera.cs b/FDK19/繧ｳ繝ｼ繝/01.繝輔Ξ繝ｼ繝繝ｯ繝ｼ繧ｯ/Utilities/Camera.cs
new file mode 100644
index 00000000..a5651b66
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/01.繝輔Ξ繝ｼ繝繝ｯ繝ｼ繧ｯ/Utilities/Camera.cs
@@ -0,0 +1,197 @@
+ｻｿ/*
+* Copyright (c) 2007-2009 SlimDX Group
+*
+* Permission is hereby granted, free of charge, to any person obtaining a copy
+* of this software and associated documentation files (the "Software"), to deal
+* in the Software without restriction, including without limitation the rights
+* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+* copies of the Software, and to permit persons to whom the Software is
+* furnished to do so, subject to the following conditions:
+*
+* The above copyright notice and this permission notice shall be included in
+* all copies or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+* THE SOFTWARE.
+*/
+using SlimDX;
+
+namespace SampleFramework
+{
+ ///
+ /// Represents a view onto a 3D scene.
+ ///
+ public class Camera
+ {
+ Vector3 location;
+ Vector3 target;
+ float fieldOfView;
+ float aspectRatio;
+ float nearPlane;
+ float farPlane;
+ Matrix viewMatrix;
+ Matrix projectionMatrix;
+ bool viewDirty = true;
+ bool projectionDirty = true;
+
+ ///
+ /// Gets or sets the location of the camera eye point.
+ ///
+ /// The location of the camera eye point.
+ public Vector3 Location
+ {
+ get { return location; }
+ set
+ {
+ if (location == value)
+ return;
+
+ location = value;
+ viewDirty = true;
+ }
+ }
+
+ ///
+ /// Gets or sets the view target point.
+ ///
+ /// The view target point.
+ public Vector3 Target
+ {
+ get { return target; }
+ set
+ {
+ if (target == value)
+ return;
+
+ target = value;
+ viewDirty = true;
+ }
+ }
+
+ ///
+ /// Gets or sets the field of view.
+ ///
+ /// The field of view.
+ public float FieldOfView
+ {
+ get { return fieldOfView; }
+ set
+ {
+ if (fieldOfView == value)
+ return;
+
+ fieldOfView = value;
+ projectionDirty = true;
+ }
+ }
+
+ ///
+ /// Gets or sets the aspect ratio.
+ ///
+ /// The aspect ratio.
+ public float AspectRatio
+ {
+ get { return aspectRatio; }
+ set
+ {
+ if (aspectRatio == value)
+ return;
+
+ aspectRatio = value;
+ projectionDirty = true;
+ }
+ }
+
+ ///
+ /// Gets or sets the near plane.
+ ///
+ /// The near plane.
+ public float NearPlane
+ {
+ get { return nearPlane; }
+ set
+ {
+ if (nearPlane == value)
+ return;
+
+ nearPlane = value;
+ projectionDirty = true;
+ }
+ }
+
+ ///
+ /// Gets or sets the far plane.
+ ///
+ /// The far plane.
+ public float FarPlane
+ {
+ get { return farPlane; }
+ set
+ {
+ if (farPlane == value)
+ return;
+
+ farPlane = value;
+ projectionDirty = true;
+ }
+ }
+
+ ///
+ /// Gets the view matrix.
+ ///
+ /// The view matrix.
+ public Matrix ViewMatrix
+ {
+ get
+ {
+ if (viewDirty)
+ RebuildViewMatrix();
+ return viewMatrix;
+ }
+ }
+
+ ///
+ /// Gets the projection matrix.
+ ///
+ /// The projection matrix.
+ public Matrix ProjectionMatrix
+ {
+ get
+ {
+ if (projectionDirty)
+ RebuildProjectionMatrix();
+ return projectionMatrix;
+ }
+ }
+
+ ///
+ /// Initializes a new instance of the class.
+ ///
+ public Camera()
+ {
+ }
+
+ ///
+ /// Rebuilds the view matrix.
+ ///
+ protected virtual void RebuildViewMatrix()
+ {
+ viewMatrix = Matrix.LookAtLH(Location, Target, Vector3.UnitY);
+ viewDirty = false;
+ }
+
+ ///
+ /// Rebuilds the projection matrix.
+ ///
+ protected virtual void RebuildProjectionMatrix()
+ {
+ projectionMatrix = Matrix.PerspectiveFovLH(FieldOfView, AspectRatio, NearPlane, FarPlane);
+ projectionDirty = false;
+ }
+ }
+}
diff --git a/FDK19/繧ｳ繝ｼ繝/01.繝輔Ξ繝ｼ繝繝ｯ繝ｼ繧ｯ/Utilities/TransformedColoredTexturedVertex.cs b/FDK19/繧ｳ繝ｼ繝/01.繝輔Ξ繝ｼ繝繝ｯ繝ｼ繧ｯ/Utilities/TransformedColoredTexturedVertex.cs
new file mode 100644
index 00000000..44299168
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/01.繝輔Ξ繝ｼ繝繝ｯ繝ｼ繧ｯ/Utilities/TransformedColoredTexturedVertex.cs
@@ -0,0 +1,178 @@
+ｻｿ/*
+* Copyright (c) 2007-2009 SlimDX Group
+*
+* Permission is hereby granted, free of charge, to any person obtaining a copy
+* of this software and associated documentation files (the "Software"), to deal
+* in the Software without restriction, including without limitation the rights
+* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+* copies of the Software, and to permit persons to whom the Software is
+* furnished to do so, subject to the following conditions:
+*
+* The above copyright notice and this permission notice shall be included in
+* all copies or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+* THE SOFTWARE.
+*/
+using System;
+using System.Globalization;
+using System.Runtime.InteropServices;
+using SlimDX;
+using SlimDX.Direct3D9;
+
+namespace SampleFramework
+{
+ ///
+ /// Represents a single transformed, colored, and textured vertex.
+ ///
+ [StructLayout(LayoutKind.Sequential)]
+ public struct TransformedColoredTexturedVertex : IEquatable
+ {
+ private Vector4 m_Position;
+ ///
+ /// Gets or sets the transformed position of the vertex.
+ ///
+ /// The transformed position of the vertex.
+ [VertexElement(DeclarationType.Float4, DeclarationUsage.PositionTransformed)]
+ public Vector4 Position
+ {
+ get { return m_Position; }
+ set { m_Position = value; }
+ }
+
+ private int m_Color;
+ ///
+ /// Gets or sets the color of the vertex.
+ ///
+ /// The color of the vertex.
+ [VertexElement(DeclarationType.Color, DeclarationUsage.Color)]
+ public int Color
+ {
+ get { return m_Color; }
+ set { m_Color = value; }
+ }
+
+ private Vector2 m_TextureCoordinates;
+ ///
+ /// Gets or sets the texture coordinates.
+ ///
+ /// The texture coordinates.
+ [VertexElement(DeclarationType.Float2, DeclarationUsage.TextureCoordinate)]
+ public Vector2 TextureCoordinates
+ {
+ get { return m_TextureCoordinates; }
+ set { m_TextureCoordinates = value; }
+ }
+
+ ///
+ /// Gets the size in bytes.
+ ///
+ /// The size in bytes.
+ public static int SizeInBytes
+ {
+ get { return Marshal.SizeOf(typeof(TransformedColoredTexturedVertex)); }
+ }
+
+ ///
+ /// Gets the format.
+ ///
+ /// The format.
+ public static VertexFormat Format
+ {
+ get { return VertexFormat.PositionRhw | VertexFormat.Diffuse | VertexFormat.Texture1; }
+ }
+
+ ///
+ /// Initializes a new instance of the struct.
+ ///
+ /// The position.
+ /// The color.
+ /// The texture coordinates.
+ public TransformedColoredTexturedVertex(Vector4 position, int color, Vector2 textureCoordinates)
+ : this()
+ {
+ Position = position;
+ Color = color;
+ TextureCoordinates = textureCoordinates;
+ }
+
+ ///
+ /// Implements the operator ==.
+ ///
+ /// The left side of the operator.
+ /// The right side of the operator.
+ /// The result of the operator.
+ public static bool operator ==(TransformedColoredTexturedVertex left, TransformedColoredTexturedVertex right)
+ {
+ return left.Equals(right);
+ }
+
+ ///
+ /// Implements the operator !=.
+ ///
+ /// The left side of the operator.
+ /// The right side of the operator.
+ /// The result of the operator.
+ public static bool operator !=(TransformedColoredTexturedVertex left, TransformedColoredTexturedVertex right)
+ {
+ return !(left == right);
+ }
+
+ ///
+ /// Returns the hash code for this instance.
+ ///
+ ///
+ /// A 32-bit signed integer that is the hash code for this instance.
+ ///
+ public override int GetHashCode()
+ {
+ return Position.GetHashCode() + Color.GetHashCode() + TextureCoordinates.GetHashCode();
+ }
+
+ ///
+ /// Indicates whether this instance and a specified object are equal.
+ ///
+ /// Another object to compare to.
+ ///
+ /// true if and this instance are the same type and represent the same value; otherwise, false.
+ ///
+ public override bool Equals(object obj)
+ {
+ if (obj == null)
+ return false;
+
+ if (GetType() != obj.GetType())
+ return false;
+
+ return Equals((TransformedColoredTexturedVertex)obj);
+ }
+
+ ///
+ /// Indicates whether the current object is equal to another object of the same type.
+ ///
+ /// An object to compare with this object.
+ ///
+ /// true if the current object is equal to the parameter; otherwise, false.
+ ///
+ public bool Equals(TransformedColoredTexturedVertex other)
+ {
+ return (Position == other.Position && Color == other.Color && TextureCoordinates == other.TextureCoordinates);
+ }
+
+ ///
+ /// Returns a string representation of the current object.
+ ///
+ ///
+ /// A representing the vertex.
+ ///
+ public override string ToString()
+ {
+ return string.Format(CultureInfo.CurrentCulture, "{0} ({1}, {2})", Position.ToString(), System.Drawing.Color.FromArgb(Color).ToString(), TextureCoordinates.ToString());
+ }
+ }
+}
diff --git a/FDK19/繧ｳ繝ｼ繝/01.繝輔Ξ繝ｼ繝繝ｯ繝ｼ繧ｯ/Utilities/TransformedColoredVertex.cs b/FDK19/繧ｳ繝ｼ繝/01.繝輔Ξ繝ｼ繝繝ｯ繝ｼ繧ｯ/Utilities/TransformedColoredVertex.cs
new file mode 100644
index 00000000..92d92566
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/01.繝輔Ξ繝ｼ繝繝ｯ繝ｼ繧ｯ/Utilities/TransformedColoredVertex.cs
@@ -0,0 +1,162 @@
+ｻｿ/*
+* Copyright (c) 2007-2009 SlimDX Group
+*
+* Permission is hereby granted, free of charge, to any person obtaining a copy
+* of this software and associated documentation files (the "Software"), to deal
+* in the Software without restriction, including without limitation the rights
+* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+* copies of the Software, and to permit persons to whom the Software is
+* furnished to do so, subject to the following conditions:
+*
+* The above copyright notice and this permission notice shall be included in
+* all copies or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+* THE SOFTWARE.
+*/
+using System;
+using System.Globalization;
+using System.Runtime.InteropServices;
+using SlimDX;
+using SlimDX.Direct3D9;
+
+namespace SampleFramework
+{
+ ///
+ /// Represents a single transformed and colored vertex.
+ ///
+ [StructLayout(LayoutKind.Sequential)]
+ public struct TransformedColoredVertex : IEquatable
+ {
+ ///
+ /// Gets or sets the transformed position of the vertex.
+ ///
+ /// The transformed position of the vertex.
+ [VertexElement(DeclarationType.Float4, DeclarationUsage.PositionTransformed)]
+ public Vector4 Position
+ {
+ get;
+ set;
+ }
+
+ ///
+ /// Gets or sets the color of the vertex.
+ ///
+ /// The color of the vertex.
+ [VertexElement(DeclarationType.Color, DeclarationUsage.Color)]
+ public int Color
+ {
+ get;
+ set;
+ }
+
+ ///
+ /// Gets the size in bytes.
+ ///
+ /// The size in bytes.
+ public static int SizeInBytes
+ {
+ get { return Marshal.SizeOf(typeof(TransformedColoredVertex)); }
+ }
+
+ ///
+ /// Gets the format.
+ ///
+ /// The format.
+ public static VertexFormat Format
+ {
+ get { return VertexFormat.PositionRhw | VertexFormat.Diffuse; }
+ }
+
+ ///
+ /// Initializes a new instance of the struct.
+ ///
+ /// The position.
+ /// The color.
+ public TransformedColoredVertex(Vector4 position, int color)
+ : this()
+ {
+ Position = position;
+ Color = color;
+ }
+
+ ///
+ /// Implements the operator ==.
+ ///
+ /// The left side of the operator.
+ /// The right side of the operator.
+ /// The result of the operator.
+ public static bool operator ==(TransformedColoredVertex left, TransformedColoredVertex right)
+ {
+ return left.Equals(right);
+ }
+
+ ///
+ /// Implements the operator !=.
+ ///
+ /// The left side of the operator.
+ /// The right side of the operator.
+ /// The result of the operator.
+ public static bool operator !=(TransformedColoredVertex left, TransformedColoredVertex right)
+ {
+ return !(left == right);
+ }
+
+ ///
+ /// Returns the hash code for this instance.
+ ///
+ ///
+ /// A 32-bit signed integer that is the hash code for this instance.
+ ///
+ public override int GetHashCode()
+ {
+ return Position.GetHashCode() + Color.GetHashCode();
+ }
+
+ ///
+ /// Indicates whether this instance and a specified object are equal.
+ ///
+ /// Another object to compare to.
+ ///
+ /// true if and this instance are the same type and represent the same value; otherwise, false.
+ ///
+ public override bool Equals(object obj)
+ {
+ if (obj == null)
+ return false;
+
+ if (GetType() != obj.GetType())
+ return false;
+
+ return Equals((TransformedColoredVertex)obj);
+ }
+
+ ///
+ /// Indicates whether the current object is equal to another object of the same type.
+ ///
+ /// An object to compare with this object.
+ ///
+ /// true if the current object is equal to the parameter; otherwise, false.
+ ///
+ public bool Equals(TransformedColoredVertex other)
+ {
+ return (Position == other.Position && Color == other.Color);
+ }
+
+ ///
+ /// Returns a string representation of the current object.
+ ///
+ ///
+ /// A representing the vertex.
+ ///
+ public override string ToString()
+ {
+ return string.Format(CultureInfo.CurrentCulture, "{0} ({1})", Position.ToString(), System.Drawing.Color.FromArgb(Color).ToString());
+ }
+ }
+}
diff --git a/FDK19/繧ｳ繝ｼ繝/01.繝輔Ξ繝ｼ繝繝ｯ繝ｼ繧ｯ/Win32/NativeMethods.cs b/FDK19/繧ｳ繝ｼ繝/01.繝輔Ξ繝ｼ繝繝ｯ繝ｼ繧ｯ/Win32/NativeMethods.cs
new file mode 100644
index 00000000..6cd66ec8
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/01.繝輔Ξ繝ｼ繝繝ｯ繝ｼ繧ｯ/Win32/NativeMethods.cs
@@ -0,0 +1,115 @@
+ｻｿ/*
+* Copyright (c) 2007-2009 SlimDX Group
+*
+* Permission is hereby granted, free of charge, to any person obtaining a copy
+* of this software and associated documentation files (the "Software"), to deal
+* in the Software without restriction, including without limitation the rights
+* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+* copies of the Software, and to permit persons to whom the Software is
+* furnished to do so, subject to the following conditions:
+*
+* The above copyright notice and this permission notice shall be included in
+* all copies or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+* THE SOFTWARE.
+*/
+using System;
+using System.Drawing;
+using System.Runtime.InteropServices;
+using System.Security;
+
+namespace SampleFramework
+{
+ static class NativeMethods
+ {
+ [SuppressUnmanagedCodeSecurityAttribute]
+ [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = false)]
+ [return: MarshalAs(UnmanagedType.Bool)]
+ public static extern bool PeekMessage(out NativeMessage message, IntPtr hwnd, uint messageFilterMin, uint messageFilterMax, uint flags);
+
+ [SuppressUnmanagedCodeSecurityAttribute]
+ [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
+ [return: MarshalAs(UnmanagedType.Bool)]
+ static extern bool GetClientRect(IntPtr hWnd, out NativeRectangle lpRect);
+
+ [SuppressUnmanagedCodeSecurityAttribute]
+ [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
+ [return: MarshalAs(UnmanagedType.Bool)]
+ static extern bool GetWindowRect(IntPtr hWnd, out NativeRectangle lpRect);
+
+ [SuppressUnmanagedCodeSecurityAttribute]
+ [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
+ [return: MarshalAs(UnmanagedType.Bool)]
+ public static extern bool GetWindowPlacement(IntPtr hWnd, ref WINDOWPLACEMENT lpwndpl);
+
+ [SuppressUnmanagedCodeSecurityAttribute]
+ [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
+ [return: MarshalAs(UnmanagedType.Bool)]
+ public static extern bool SetWindowPlacement(IntPtr hWnd, ref WINDOWPLACEMENT lpwndpl);
+
+ [SuppressUnmanagedCodeSecurityAttribute]
+ [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
+ public static extern uint SetWindowLong(IntPtr hWnd, int nIndex, uint dwNewLong);
+
+ [SuppressUnmanagedCodeSecurityAttribute]
+ [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
+ public static extern uint GetWindowLong(IntPtr hWnd, int nIndex);
+
+ [SuppressUnmanagedCodeSecurityAttribute]
+ [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = false)]
+ [return: MarshalAs(UnmanagedType.Bool)]
+ public static extern bool IsIconic(IntPtr hWnd);
+
+ [SuppressUnmanagedCodeSecurityAttribute]
+ [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = false)]
+ [return: MarshalAs(UnmanagedType.Bool)]
+ public static extern bool IsZoomed(IntPtr hWnd);
+
+ [SuppressUnmanagedCodeSecurityAttribute]
+ [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = false)]
+ [return: MarshalAs(UnmanagedType.Bool)]
+ public static extern bool ShowWindow(IntPtr hWnd, int nCmdShow);
+
+ [SuppressUnmanagedCodeSecurityAttribute]
+ [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
+ [return: MarshalAs(UnmanagedType.Bool)]
+ public static extern bool AdjustWindowRect(ref NativeRectangle lpRect, uint dwStyle, [MarshalAs(UnmanagedType.Bool)]bool bMenu);
+
+ [SuppressUnmanagedCodeSecurityAttribute]
+ [DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = false)]
+ public static extern uint SetThreadExecutionState(uint esFlags);
+
+ [SuppressUnmanagedCodeSecurityAttribute]
+ [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
+ [return: MarshalAs(UnmanagedType.Bool)]
+ public static extern bool SetWindowPos(IntPtr hWnd, IntPtr hWndInsertAfter, int X, int Y, int cx, int cy, uint uFlags);
+
+ [SuppressUnmanagedCodeSecurityAttribute]
+ [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = false)]
+ public static extern IntPtr MonitorFromWindow(IntPtr hwnd, uint dwFlags);
+
+ public static Rectangle GetClientRectangle(IntPtr handle)
+ {
+ NativeRectangle rect;
+ if (!GetClientRect(handle, out rect))
+ return Rectangle.Empty;
+
+ return Rectangle.FromLTRB(rect.left, rect.top, rect.right, rect.bottom);
+ }
+
+ public static Rectangle GetWindowRectangle(IntPtr handle)
+ {
+ NativeRectangle rect;
+ if (!GetWindowRect(handle, out rect))
+ return Rectangle.Empty;
+
+ return Rectangle.FromLTRB(rect.left, rect.top, rect.right, rect.bottom);
+ }
+ }
+}
diff --git a/FDK19/繧ｳ繝ｼ繝/01.繝輔Ξ繝ｼ繝繝ｯ繝ｼ繧ｯ/Win32/NativeStructures.cs b/FDK19/繧ｳ繝ｼ繝/01.繝輔Ξ繝ｼ繝繝ｯ繝ｼ繧ｯ/Win32/NativeStructures.cs
new file mode 100644
index 00000000..3506cee4
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/01.繝輔Ξ繝ｼ繝繝ｯ繝ｼ繧ｯ/Win32/NativeStructures.cs
@@ -0,0 +1,72 @@
+ｻｿ/*
+* Copyright (c) 2007-2009 SlimDX Group
+*
+* Permission is hereby granted, free of charge, to any person obtaining a copy
+* of this software and associated documentation files (the "Software"), to deal
+* in the Software without restriction, including without limitation the rights
+* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+* copies of the Software, and to permit persons to whom the Software is
+* furnished to do so, subject to the following conditions:
+*
+* The above copyright notice and this permission notice shall be included in
+* all copies or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+* THE SOFTWARE.
+*/
+using System;
+using System.Drawing;
+using System.Runtime.InteropServices;
+
+namespace SampleFramework
+{
+ [StructLayout(LayoutKind.Sequential)]
+ struct NativeRectangle
+ {
+ public int left;
+ public int top;
+ public int right;
+ public int bottom;
+ }
+
+ [StructLayout(LayoutKind.Sequential)]
+ struct NativeMessage
+ {
+ public IntPtr hWnd;
+ public uint msg;
+ public IntPtr wParam;
+ public IntPtr lParam;
+ public uint time;
+ public Point p;
+ }
+
+ [StructLayout(LayoutKind.Sequential)]
+ struct WINDOWPLACEMENT
+ {
+ public int length;
+ public int flags;
+ public int showCmd;
+ public Point ptMinPosition;
+ public Point ptMaxPosition;
+ public NativeRectangle rcNormalPosition;
+
+ public static int Length
+ {
+ get { return Marshal.SizeOf(typeof(WINDOWPLACEMENT)); }
+ }
+ }
+ #region #28821 2014.1.23 yyagi add: 螟夜Κ縺九ｉ縺ｮ譁蟄怜励Γ繝繧ｻ繝ｼ繧ｸ騾∝女菫｡ 螳壽焚螳夂ｾｩ
+ [StructLayout( LayoutKind.Sequential )]
+ public struct COPYDATASTRUCT
+ {
+ public IntPtr dwData;
+ public UInt32 cbData;
+ public IntPtr lpData;
+ }
+ #endregion
+}
diff --git a/FDK19/繧ｳ繝ｼ繝/01.繝輔Ξ繝ｼ繝繝ｯ繝ｼ繧ｯ/Win32/WindowConstants.cs b/FDK19/繧ｳ繝ｼ繝/01.繝輔Ξ繝ｼ繝繝ｯ繝ｼ繧ｯ/Win32/WindowConstants.cs
new file mode 100644
index 00000000..f212024c
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/01.繝輔Ξ繝ｼ繝繝ｯ繝ｼ繧ｯ/Win32/WindowConstants.cs
@@ -0,0 +1,77 @@
+ｻｿ/*
+* Copyright (c) 2007-2009 SlimDX Group
+*
+* Permission is hereby granted, free of charge, to any person obtaining a copy
+* of this software and associated documentation files (the "Software"), to deal
+* in the Software without restriction, including without limitation the rights
+* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+* copies of the Software, and to permit persons to whom the Software is
+* furnished to do so, subject to the following conditions:
+*
+* The above copyright notice and this permission notice shall be included in
+* all copies or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+* THE SOFTWARE.
+*/
+using System;
+
+namespace SampleFramework
+{
+ static class WindowConstants
+ {
+ public const int WM_SIZE = 0x5;
+ public const int WM_SYSCOMMAND = 0x112;
+ public const int WM_ACTIVATEAPP = 0x001C;
+ public const int WM_POWERBROADCAST = 0x0218;
+ public const int WM_COPYDATA = 0x004A;
+
+ public const int SC_SCREENSAVE = 0xF140;
+ public const int SC_MONITORPOWER = 0xF170;
+
+ public const int VK_LWIN = 0x5B;
+ public const int VK_RWIN = 0x5C;
+
+ public static readonly IntPtr SIZE_MINIMIZED = new IntPtr(1);
+ public static readonly IntPtr SIZE_MAXIMIZED = new IntPtr(2);
+ public static readonly IntPtr SIZE_RESTORED = new IntPtr(0);
+
+ public static readonly IntPtr PBT_APMQUERYSUSPEND = new IntPtr(0x0000);
+ public static readonly IntPtr PBT_APMRESUMESUSPEND = new IntPtr(0x0007);
+
+ public const int WPF_RESTORETOMAXIMIZED = 2;
+
+ public const int SW_RESTORE = 9;
+ public const int SW_SHOWMINIMIZED = 2;
+ public const int SW_MAXIMIZE = 3;
+ public const int SW_SHOW = 5;
+ public const int SW_MINIMIZE = 6;
+
+ public const int GWL_STYLE = -16;
+ public const int GWL_EXSTYLE = -20;
+
+ public const long WS_MAXIMIZE = 0x01000000;
+ public const long WS_MINIMIZE = 0x20000000;
+ public const long WS_POPUP = 0x80000000;
+ public const long WS_SYSMENU = 0x00080000;
+
+ public const long WS_EX_TOPMOST = 0x00000008;
+
+ public const uint SWP_NOSIZE = 0x0001;
+ public const uint SWP_NOMOVE = 0x0002;
+ public const uint SWP_NOZORDER = 0x0004;
+ public const uint SWP_NOREDRAW = 0x0008;
+
+ public const uint ES_CONTINUOUS = 0x80000000;
+ public const uint ES_DISPLAY_REQUIRED = 0x00000002;
+
+ public const int MONITOR_DEFAULTTOPRIMARY = 1;
+
+ public const int WM_USER = 0x400;
+ }
+}
diff --git a/FDK19/繧ｳ繝ｼ繝/02.蜈･蜉/CInputJoystick.cs b/FDK19/繧ｳ繝ｼ繝/02.蜈･蜉/CInputJoystick.cs
new file mode 100644
index 00000000..90889d5e
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/02.蜈･蜉/CInputJoystick.cs
@@ -0,0 +1,820 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Diagnostics;
+using SharpDX;
+using SharpDX.DirectInput;
+
+namespace FDK
+{
+ public class CInputJoystick : IInputDevice, IDisposable
+ {
+ // 繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ
+
+ public CInputJoystick( IntPtr hWnd, DeviceInstance di, DirectInput directInput )
+ {
+ this.e蜈･蜉帙ョ繝舌う繧ｹ遞ｮ蛻･ = E蜈･蜉帙ョ繝舌う繧ｹ遞ｮ蛻･.Joystick;
+ this.GUID = di.InstanceGuid.ToString();
+ this.ID = 0;
+ try
+ {
+ this.devJoystick = new Joystick( directInput, di.InstanceGuid );
+ this.devJoystick.SetCooperativeLevel( hWnd, CooperativeLevel.Foreground | CooperativeLevel.Exclusive );
+ this.devJoystick.Properties.BufferSize = 32;
+ Trace.TraceInformation( this.devJoystick.Information.InstanceName + "繧堤函謌舌＠縺ｾ縺励◆縲" );
+ this.strDeviceName = this.devJoystick.Information.InstanceName;
+ }
+ catch
+ {
+ if( this.devJoystick != null )
+ {
+ this.devJoystick.Dispose();
+ this.devJoystick = null;
+ }
+ Trace.TraceError( this.devJoystick.Information.InstanceName, new object[] { " 縺ｮ逕滓舌↓螟ｱ謨励＠縺ｾ縺励◆縲" } );
+ throw;
+ }
+ foreach( DeviceObjectInstance instance in this.devJoystick.GetObjects() )
+ {
+ if ((instance.ObjectId.Flags & DeviceObjectTypeFlags.Axis) != DeviceObjectTypeFlags.All)
+ {
+ this.devJoystick.GetObjectPropertiesById(instance.ObjectId).Range = new InputRange(-1000, 1000);
+ this.devJoystick.GetObjectPropertiesById(instance.ObjectId).DeadZone = 5000; // 50%繧偵ョ繝繝峨だ繝ｼ繝ｳ縺ｫ險ｭ螳
+ // 霆ｸ繧丹N/OFF縺ｮ2蛟､縺ｧ菴ｿ縺縺ｪ繧峨％繧後〒蜊∝
+ }
+ }
+ try
+ {
+ this.devJoystick.Acquire();
+ }
+ catch
+ {
+ }
+
+ for( int i = 0; i < this.bButtonState.Length; i++ )
+ this.bButtonState[ i ] = false;
+ for ( int i = 0; i < this.nPovState.Length; i++ )
+ this.nPovState[ i ] = -1;
+
+ //this.timer = new CTimer( CTimer.E遞ｮ蛻･.MultiMedia );
+
+ this.list蜈･蜉帙う繝吶Φ繝 = new List(32);
+ }
+
+
+ // 繝｡繧ｽ繝繝
+
+ public void SetID( int nID )
+ {
+ this.ID = nID;
+ }
+
+ #region [ IInputDevice 螳溯｣ ]
+ //-----------------
+ public E蜈･蜉帙ョ繝舌う繧ｹ遞ｮ蛻･ e蜈･蜉帙ョ繝舌う繧ｹ遞ｮ蛻･
+ {
+ get;
+ private set;
+ }
+ public string GUID
+ {
+ get;
+ private set;
+ }
+ public int ID
+ {
+ get;
+ private set;
+ }
+ public List list蜈･蜉帙う繝吶Φ繝
+ {
+ get;
+ private set;
+ }
+ public string strDeviceName
+ {
+ get;
+ set;
+ }
+
+ #region [ 繝ｭ繝ｼ繧ｫ繝ｫ髢｢謨ｰ ]
+ private void POV縺ｮ蜃ｦ逅(int p, JoystickUpdate data)
+ {
+ int nPovDegree = data.Value;
+ STInputEvent e = new STInputEvent();
+ int nWay = (nPovDegree + 2250) / 4500;
+ if (nWay == 8) nWay = 0;
+ //Debug.WriteLine( "POVS:" + povs[ 0 ].ToString( CultureInfo.CurrentCulture ) + ", " +stevent.nKey );
+ //Debug.WriteLine( "nPovDegree=" + nPovDegree );
+ if (nPovDegree == -1)
+ {
+ e.nKey = 8 + 128 + this.nPovState[p];
+ this.nPovState[p] = -1;
+ //Debug.WriteLine( "POVS髮｢縺輔ｌ縺" + data.TimeStamp + " " + e.nKey );
+ e.b謚ｼ縺輔ｌ縺 = false;
+ e.nVelocity = 0;
+ this.bButtonState[e.nKey] = false;
+ this.bButtonPullUp[e.nKey] = true;
+ }
+ else
+ {
+ this.nPovState[p] = nWay;
+ e.nKey = 8 + 128 + nWay;
+ e.b謚ｼ縺輔ｌ縺 = true;
+ e.nVelocity = CInput邂｡逅.n騾壼ｸｸ髻ｳ驥;
+ this.bButtonState[e.nKey] = true;
+ this.bButtonPushDown[e.nKey] = true;
+ //Debug.WriteLine( "POVS謚ｼ縺輔ｌ縺" + data.TimeStamp + " " + e.nKey );
+ }
+ //e.nTimeStamp = data.TimeStamp;
+ e.nTimeStamp = CSound邂｡逅.rc貍泌･冗畑繧ｿ繧､繝.n繧ｵ繧ｦ繝ｳ繝峨ち繧､繝槭ｼ縺ｮ繧ｷ繧ｹ繝繝譎ょ綾ms縺ｸ縺ｮ螟画鋤(data.Timestamp);
+ this.list蜈･蜉帙う繝吶Φ繝.Add(e);
+ }
+ #endregion
+
+ public void t繝昴ｼ繝ｪ繝ｳ繧ｰ(bool bWindow縺後い繧ｯ繝繧｣繝紋ｸｭ, bool b繝舌ャ繝輔ぃ蜈･蜉帙ｒ菴ｿ逕ｨ縺吶ｋ)
+ {
+ #region [ bButton繝輔Λ繧ｰ蛻晄悄蛹 ]
+ for ( int i = 0; i < 256; i++ )
+ {
+ this.bButtonPushDown[i] = false;
+ this.bButtonPullUp[i] = false;
+ }
+ #endregion
+
+ if (bWindow縺後い繧ｯ繝繧｣繝紋ｸｭ)
+ {
+ this.devJoystick.Acquire();
+ this.devJoystick.Poll();
+
+ // this.list蜈･蜉帙う繝吶Φ繝 = new List( 32 );
+ this.list蜈･蜉帙う繝吶Φ繝.Clear(); // #xxxxx 2012.6.11 yyagi; To optimize, I removed new();
+
+
+ if( b繝舌ャ繝輔ぃ蜈･蜉帙ｒ菴ｿ逕ｨ縺吶ｋ )
+ {
+ #region [ a.繝舌ャ繝輔ぃ蜈･蜉 ]
+ //-----------------------------
+
+ var bufferedData = this.devJoystick.GetBufferedData();
+ //if( Result.Last.IsSuccess && bufferedData != null )
+ {
+ foreach (JoystickUpdate data in bufferedData)
+ {
+ switch (data.Offset)
+ {
+ case JoystickOffset.X:
+ #region [ X霆ｸｼ ]
+ //-----------------------------
+ bButtonUpDown(data, data.Value, 0, 1);
+ //-----------------------------
+ #endregion
+ #region [ X霆ｸｼ ]
+ //-----------------------------
+ bButtonUpDown(data, data.Value, 1, 0);
+ //-----------------------------
+ #endregion
+ break;
+ case JoystickOffset.Y:
+ #region [ Y霆ｸｼ ]
+ //-----------------------------
+ bButtonUpDown(data, data.Value, 2, 3);
+ //-----------------------------
+ #endregion
+ #region [ Y霆ｸｼ ]
+ //-----------------------------
+ bButtonUpDown(data, data.Value, 3, 2);
+ //-----------------------------
+ #endregion
+ break;
+ case JoystickOffset.Z:
+ #region [ Z霆ｸｼ ]
+ //-----------------------------
+ bButtonUpDown(data, data.Value, 4, 5);
+ //-----------------------------
+ #endregion
+ #region [ Z霆ｸｼ ]
+ //-----------------------------
+ bButtonUpDown(data, data.Value, 5, 4);
+ //-----------------------------
+ #endregion
+ break;
+ case JoystickOffset.RotationZ:
+ #region [ Z霆ｸｼ ]
+ //-----------------------------
+ bButtonUpDown(data, data.Value, 6, 7);
+ //-----------------------------
+ #endregion
+ #region [ Z霆ｸｼ ]
+ //-----------------------------
+ bButtonUpDown(data, data.Value, 7, 6);
+ //-----------------------------
+ #endregion
+ break;
+ // #24341 2011.3.12 yyagi: POV support
+ // #26880 2011.12.6 yyagi: improve to support "pullup" of POV buttons
+ case JoystickOffset.PointOfViewControllers0:
+ #region [ POV HAT 4/8way ]
+ POV縺ｮ蜃ｦ逅(0, data);
+ #endregion
+ break;
+ case JoystickOffset.PointOfViewControllers1:
+ #region [ POV HAT 4/8way ]
+ POV縺ｮ蜃ｦ逅(1, data);
+ #endregion
+ break;
+ case JoystickOffset.PointOfViewControllers2:
+ #region [ POV HAT 4/8way ]
+ POV縺ｮ蜃ｦ逅(2, data);
+ #endregion
+ break;
+ case JoystickOffset.PointOfViewControllers3:
+ #region [ POV HAT 4/8way ]
+ POV縺ｮ蜃ｦ逅(3, data);
+ #endregion
+ break;
+ default:
+ #region [ 繝懊ち繝ｳ ]
+ //-----------------------------
+
+ //for ( int i = 0; i < 32; i++ )
+ if (data.Offset >= JoystickOffset.Buttons0 && data.Offset <= JoystickOffset.Buttons31)
+ {
+ int i = data.Offset - JoystickOffset.Buttons0;
+
+ if ((data.Value & 0x80) != 0)
+ {
+ STInputEvent e = new STInputEvent()
+ {
+ nKey = 8 + i,
+ b謚ｼ縺輔ｌ縺 = true,
+ b髮｢縺輔ｌ縺 = false,
+ nTimeStamp = CSound邂｡逅.rc貍泌･冗畑繧ｿ繧､繝.n繧ｵ繧ｦ繝ｳ繝峨ち繧､繝槭ｼ縺ｮ繧ｷ繧ｹ繝繝譎ょ綾ms縺ｸ縺ｮ螟画鋤(data.Timestamp),
+ nVelocity = CInput邂｡逅.n騾壼ｸｸ髻ｳ驥
+ };
+ this.list蜈･蜉帙う繝吶Φ繝.Add(e);
+
+ this.bButtonState[8 + i] = true;
+ this.bButtonPushDown[8 + i] = true;
+ }
+ else //if ( ( data.Value & 0x80 ) == 0 )
+ {
+ var ev = new STInputEvent()
+ {
+ nKey = 8 + i,
+ b謚ｼ縺輔ｌ縺 = false,
+ b髮｢縺輔ｌ縺 = true,
+ nTimeStamp = CSound邂｡逅.rc貍泌･冗畑繧ｿ繧､繝.n繧ｵ繧ｦ繝ｳ繝峨ち繧､繝槭ｼ縺ｮ繧ｷ繧ｹ繝繝譎ょ綾ms縺ｸ縺ｮ螟画鋤(data.Timestamp),
+ nVelocity = CInput邂｡逅.n騾壼ｸｸ髻ｳ驥,
+ };
+ this.list蜈･蜉帙う繝吶Φ繝.Add(ev);
+
+ this.bButtonState[8 + i] = false;
+ this.bButtonPullUp[8 + i] = true;
+ }
+ }
+ //-----------------------------
+ #endregion
+ break;
+ }
+ }
+ }
+ //-----------------------------
+ #endregion
+ }
+ else
+ {
+ #region [ b.迥ｶ諷句･蜉 ]
+ //-----------------------------
+ JoystickState currentState = this.devJoystick.GetCurrentState();
+ //if( Result.Last.IsSuccess && currentState != null )
+ {
+ #region [ X霆ｸｼ ]
+ //-----------------------------
+ if( currentState.X < -500 )
+ {
+ if( this.bButtonState[ 0 ] == false )
+ {
+ STInputEvent ev = new STInputEvent()
+ {
+ nKey = 0,
+ b謚ｼ縺輔ｌ縺 = true,
+ nTimeStamp = CSound邂｡逅.rc貍泌･冗畑繧ｿ繧､繝.n繧ｷ繧ｹ繝繝譎ょ綾, // 貍泌･冗畑繧ｿ繧､繝槭→蜷後§繧ｿ繧､繝槭ｒ菴ｿ縺縺薙→縺ｧ縲。GM縺ｨ隴憺擇縲∝･蜉帙★繧後ｒ髦ｲ縺舌
+ nVelocity = CInput邂｡逅.n騾壼ｸｸ髻ｳ驥
+ };
+ this.list蜈･蜉帙う繝吶Φ繝.Add(ev);
+
+ this.bButtonState[0] = true;
+ this.bButtonPushDown[0] = true;
+ }
+ }
+ else
+ {
+ if( this.bButtonState[0] == true )
+ {
+ STInputEvent ev = new STInputEvent()
+ {
+ nKey = 0,
+ b謚ｼ縺輔ｌ縺 = false,
+ nTimeStamp = CSound邂｡逅.rc貍泌･冗畑繧ｿ繧､繝.n繧ｷ繧ｹ繝繝譎ょ綾, // 貍泌･冗畑繧ｿ繧､繝槭→蜷後§繧ｿ繧､繝槭ｒ菴ｿ縺縺薙→縺ｧ縲。GM縺ｨ隴憺擇縲∝･蜉帙★繧後ｒ髦ｲ縺舌
+ nVelocity = CInput邂｡逅.n騾壼ｸｸ髻ｳ驥
+ };
+ this.list蜈･蜉帙う繝吶Φ繝.Add(ev);
+
+ this.bButtonState[0] = false;
+ this.bButtonPullUp[0] = true;
+ }
+ }
+ //-----------------------------
+ #endregion
+ #region [ X霆ｸｼ ]
+ //-----------------------------
+ if(currentState.X > 500)
+ {
+ if(this.bButtonState[1] == false)
+ {
+ STInputEvent ev = new STInputEvent()
+ {
+ nKey = 1,
+ b謚ｼ縺輔ｌ縺 = true,
+ nTimeStamp = CSound邂｡逅.rc貍泌･冗畑繧ｿ繧､繝.n繧ｷ繧ｹ繝繝譎ょ綾, // 貍泌･冗畑繧ｿ繧､繝槭→蜷後§繧ｿ繧､繝槭ｒ菴ｿ縺縺薙→縺ｧ縲。GM縺ｨ隴憺擇縲∝･蜉帙★繧後ｒ髦ｲ縺舌
+ nVelocity = CInput邂｡逅.n騾壼ｸｸ髻ｳ驥
+ };
+ this.list蜈･蜉帙う繝吶Φ繝.Add(ev);
+
+ this.bButtonState[1] = true;
+ this.bButtonPushDown[1] = true;
+ }
+ }
+ else
+ {
+ if(this.bButtonState[1] == true)
+ {
+ STInputEvent event7 = new STInputEvent()
+ {
+ nKey = 1,
+ b謚ｼ縺輔ｌ縺 = false,
+ nTimeStamp = CSound邂｡逅.rc貍泌･冗畑繧ｿ繧､繝.n繧ｷ繧ｹ繝繝譎ょ綾, // 貍泌･冗畑繧ｿ繧､繝槭→蜷後§繧ｿ繧､繝槭ｒ菴ｿ縺縺薙→縺ｧ縲。GM縺ｨ隴憺擇縲∝･蜉帙★繧後ｒ髦ｲ縺舌
+ nVelocity = CInput邂｡逅.n騾壼ｸｸ髻ｳ驥
+ };
+ this.list蜈･蜉帙う繝吶Φ繝.Add(event7);
+
+ this.bButtonState[1] = false;
+ this.bButtonPullUp[1] = true;
+ }
+ }
+ //-----------------------------
+ #endregion
+ #region [ Y霆ｸｼ ]
+ //-----------------------------
+ if(currentState.Y < -500)
+ {
+ if(this.bButtonState[ 2 ] == false)
+ {
+ STInputEvent ev = new STInputEvent()
+ {
+ nKey = 2,
+ b謚ｼ縺輔ｌ縺 = true,
+ nTimeStamp = CSound邂｡逅.rc貍泌･冗畑繧ｿ繧､繝.n繧ｷ繧ｹ繝繝譎ょ綾, // 貍泌･冗畑繧ｿ繧､繝槭→蜷後§繧ｿ繧､繝槭ｒ菴ｿ縺縺薙→縺ｧ縲。GM縺ｨ隴憺擇縲∝･蜉帙★繧後ｒ髦ｲ縺舌
+ nVelocity = CInput邂｡逅.n騾壼ｸｸ髻ｳ驥
+ };
+ this.list蜈･蜉帙う繝吶Φ繝.Add(ev);
+
+ this.bButtonState[2] = true;
+ this.bButtonPushDown[2] = true;
+ }
+ }
+ else
+ {
+ if(this.bButtonState[2] == true)
+ {
+ STInputEvent ev = new STInputEvent()
+ {
+ nKey = 2,
+ b謚ｼ縺輔ｌ縺 = false,
+ nTimeStamp = CSound邂｡逅.rc貍泌･冗畑繧ｿ繧､繝.n繧ｷ繧ｹ繝繝譎ょ綾, // 貍泌･冗畑繧ｿ繧､繝槭→蜷後§繧ｿ繧､繝槭ｒ菴ｿ縺縺薙→縺ｧ縲。GM縺ｨ隴憺擇縲∝･蜉帙★繧後ｒ髦ｲ縺舌
+ nVelocity = CInput邂｡逅.n騾壼ｸｸ髻ｳ驥
+ };
+ this.list蜈･蜉帙う繝吶Φ繝.Add(ev);
+
+ this.bButtonState[2] = false;
+ this.bButtonPullUp[2] = true;
+ }
+ }
+ //-----------------------------
+ #endregion
+ #region [ Y霆ｸｼ ]
+ //-----------------------------
+ if(currentState.Y > 500)
+ {
+ if(this.bButtonState[3] == false)
+ {
+ STInputEvent ev = new STInputEvent()
+ {
+ nKey = 3,
+ b謚ｼ縺輔ｌ縺 = true,
+ nTimeStamp = CSound邂｡逅.rc貍泌･冗畑繧ｿ繧､繝.n繧ｷ繧ｹ繝繝譎ょ綾, // 貍泌･冗畑繧ｿ繧､繝槭→蜷後§繧ｿ繧､繝槭ｒ菴ｿ縺縺薙→縺ｧ縲。GM縺ｨ隴憺擇縲∝･蜉帙★繧後ｒ髦ｲ縺舌
+ nVelocity = CInput邂｡逅.n騾壼ｸｸ髻ｳ驥
+ };
+ this.list蜈･蜉帙う繝吶Φ繝.Add(ev);
+
+ this.bButtonState[3] = true;
+ this.bButtonPushDown[3] = true;
+ }
+ }
+ else
+ {
+ if(this.bButtonState[3] == true)
+ {
+ STInputEvent ev = new STInputEvent()
+ {
+ nKey = 3,
+ b謚ｼ縺輔ｌ縺 = false,
+ nTimeStamp = CSound邂｡逅.rc貍泌･冗畑繧ｿ繧､繝.n繧ｷ繧ｹ繝繝譎ょ綾, // 貍泌･冗畑繧ｿ繧､繝槭→蜷後§繧ｿ繧､繝槭ｒ菴ｿ縺縺薙→縺ｧ縲。GM縺ｨ隴憺擇縲∝･蜉帙★繧後ｒ髦ｲ縺舌
+ nVelocity = CInput邂｡逅.n騾壼ｸｸ髻ｳ驥
+ };
+ this.list蜈･蜉帙う繝吶Φ繝.Add(ev);
+
+ this.bButtonState[3] = false;
+ this.bButtonPullUp[3] = true;
+ }
+ }
+ //-----------------------------
+ #endregion
+ #region [ Z霆ｸｼ ]
+ //-----------------------------
+ if(currentState.Z < -500)
+ {
+ if(this.bButtonState[4] == false)
+ {
+ STInputEvent ev = new STInputEvent()
+ {
+ nKey = 4,
+ b謚ｼ縺輔ｌ縺 = true,
+ nTimeStamp = CSound邂｡逅.rc貍泌･冗畑繧ｿ繧､繝.n繧ｷ繧ｹ繝繝譎ょ綾, // 貍泌･冗畑繧ｿ繧､繝槭→蜷後§繧ｿ繧､繝槭ｒ菴ｿ縺縺薙→縺ｧ縲。GM縺ｨ隴憺擇縲∝･蜉帙★繧後ｒ髦ｲ縺舌
+ nVelocity = CInput邂｡逅.n騾壼ｸｸ髻ｳ驥
+ };
+ this.list蜈･蜉帙う繝吶Φ繝.Add(ev);
+
+ this.bButtonState[4] = true;
+ this.bButtonPushDown[4] = true;
+ }
+ }
+ else
+ {
+ if(this.bButtonState[4] == true)
+ {
+ STInputEvent ev = new STInputEvent()
+ {
+ nKey = 4,
+ b謚ｼ縺輔ｌ縺 = false,
+ nTimeStamp = CSound邂｡逅.rc貍泌･冗畑繧ｿ繧､繝.n繧ｷ繧ｹ繝繝譎ょ綾, // 貍泌･冗畑繧ｿ繧､繝槭→蜷後§繧ｿ繧､繝槭ｒ菴ｿ縺縺薙→縺ｧ縲。GM縺ｨ隴憺擇縲∝･蜉帙★繧後ｒ髦ｲ縺舌
+ nVelocity = CInput邂｡逅.n騾壼ｸｸ髻ｳ驥
+ };
+ this.list蜈･蜉帙う繝吶Φ繝.Add(ev);
+
+ this.bButtonState[4] = false;
+ this.bButtonPullUp[4] = true;
+ }
+ }
+ //-----------------------------
+ #endregion
+ #region [ Z霆ｸｼ ]
+ //-----------------------------
+ if(currentState.Z > 500)
+ {
+ if( this.bButtonState[5] == false )
+ {
+ STInputEvent ev = new STInputEvent()
+ {
+ nKey = 5,
+ b謚ｼ縺輔ｌ縺 = true,
+ nTimeStamp = CSound邂｡逅.rc貍泌･冗畑繧ｿ繧､繝.n繧ｷ繧ｹ繝繝譎ょ綾, // 貍泌･冗畑繧ｿ繧､繝槭→蜷後§繧ｿ繧､繝槭ｒ菴ｿ縺縺薙→縺ｧ縲。GM縺ｨ隴憺擇縲∝･蜉帙★繧後ｒ髦ｲ縺舌
+ nVelocity = CInput邂｡逅.n騾壼ｸｸ髻ｳ驥
+ };
+ this.list蜈･蜉帙う繝吶Φ繝.Add( ev );
+
+ this.bButtonState[5] = true;
+ this.bButtonPushDown[5] = true;
+ }
+ }
+ else
+ {
+ if(this.bButtonState[5] == true)
+ {
+ STInputEvent event15 = new STInputEvent()
+ {
+ nKey = 5,
+ b謚ｼ縺輔ｌ縺 = false,
+ nTimeStamp = CSound邂｡逅.rc貍泌･冗畑繧ｿ繧､繝.n繧ｷ繧ｹ繝繝譎ょ綾, // 貍泌･冗畑繧ｿ繧､繝槭→蜷後§繧ｿ繧､繝槭ｒ菴ｿ縺縺薙→縺ｧ縲。GM縺ｨ隴憺擇縲∝･蜉帙★繧後ｒ髦ｲ縺舌
+ nVelocity = CInput邂｡逅.n騾壼ｸｸ髻ｳ驥
+ };
+ this.list蜈･蜉帙う繝吶Φ繝.Add(event15);
+
+ this.bButtonState[5] = false;
+ this.bButtonPullUp[5] = true;
+ }
+ }
+ //-----------------------------
+ #endregion
+ #region [ Z霆ｸ蝗櫁ｻ｢ｼ ]
+ //-----------------------------
+ if (currentState.RotationZ < -500)
+ {
+ if (this.bButtonState[6] == false)
+ {
+ STInputEvent ev = new STInputEvent()
+ {
+ nKey = 6,
+ b謚ｼ縺輔ｌ縺 = true,
+ nTimeStamp = CSound邂｡逅.rc貍泌･冗畑繧ｿ繧､繝.n繧ｷ繧ｹ繝繝譎ょ綾, // 貍泌･冗畑繧ｿ繧､繝槭→蜷後§繧ｿ繧､繝槭ｒ菴ｿ縺縺薙→縺ｧ縲。GM縺ｨ隴憺擇縲∝･蜉帙★繧後ｒ髦ｲ縺舌
+ nVelocity = CInput邂｡逅.n騾壼ｸｸ髻ｳ驥
+ };
+ this.list蜈･蜉帙う繝吶Φ繝.Add(ev);
+
+ this.bButtonState[6] = true;
+ this.bButtonPushDown[6] = true;
+ }
+ }
+ else
+ {
+ if (this.bButtonState[6] == true)
+ {
+ STInputEvent ev = new STInputEvent()
+ {
+ nKey = 6,
+ b謚ｼ縺輔ｌ縺 = false,
+ nTimeStamp = CSound邂｡逅.rc貍泌･冗畑繧ｿ繧､繝.n繧ｷ繧ｹ繝繝譎ょ綾, // 貍泌･冗畑繧ｿ繧､繝槭→蜷後§繧ｿ繧､繝槭ｒ菴ｿ縺縺薙→縺ｧ縲。GM縺ｨ隴憺擇縲∝･蜉帙★繧後ｒ髦ｲ縺舌
+ nVelocity = CInput邂｡逅.n騾壼ｸｸ髻ｳ驥
+ };
+ this.list蜈･蜉帙う繝吶Φ繝.Add(ev);
+
+ this.bButtonState[6] = false;
+ this.bButtonPullUp[6] = true;
+ }
+ }
+ //-----------------------------
+ #endregion
+ #region [ Z霆ｸ蝗櫁ｻ｢ｼ ]
+ //-----------------------------
+ if (currentState.RotationZ > 500)
+ {
+ if (this.bButtonState[7] == false)
+ {
+ STInputEvent ev = new STInputEvent()
+ {
+ nKey = 7,
+ b謚ｼ縺輔ｌ縺 = true,
+ nTimeStamp = CSound邂｡逅.rc貍泌･冗畑繧ｿ繧､繝.n繧ｷ繧ｹ繝繝譎ょ綾, // 貍泌･冗畑繧ｿ繧､繝槭→蜷後§繧ｿ繧､繝槭ｒ菴ｿ縺縺薙→縺ｧ縲。GM縺ｨ隴憺擇縲∝･蜉帙★繧後ｒ髦ｲ縺舌
+ nVelocity = CInput邂｡逅.n騾壼ｸｸ髻ｳ驥
+ };
+ this.list蜈･蜉帙う繝吶Φ繝.Add(ev);
+
+ this.bButtonState[7] = true;
+ this.bButtonPushDown[7] = true;
+ }
+ }
+ else
+ {
+ if (this.bButtonState[7] == true)
+ {
+ STInputEvent event15 = new STInputEvent()
+ {
+ nKey = 7,
+ b謚ｼ縺輔ｌ縺 = false,
+ nTimeStamp = CSound邂｡逅.rc貍泌･冗畑繧ｿ繧､繝.n繧ｷ繧ｹ繝繝譎ょ綾, // 貍泌･冗畑繧ｿ繧､繝槭→蜷後§繧ｿ繧､繝槭ｒ菴ｿ縺縺薙→縺ｧ縲。GM縺ｨ隴憺擇縲∝･蜉帙★繧後ｒ髦ｲ縺舌
+ nVelocity = CInput邂｡逅.n騾壼ｸｸ髻ｳ驥
+ };
+ this.list蜈･蜉帙う繝吶Φ繝.Add(event15);
+
+ this.bButtonState[7] = false;
+ this.bButtonPullUp[7] = true;
+ }
+ }
+ //-----------------------------
+ #endregion
+ #region [ 繝懊ち繝ｳ ]
+ //-----------------------------
+ bool bIsButtonPressedReleased = false;
+ bool[] buttons = currentState.Buttons;
+ for (int j = 0; (j < buttons.Length) && (j < 128); j++)
+ {
+ if (this.bButtonState[8 + j] == false && buttons[j])
+ {
+ STInputEvent item = new STInputEvent()
+ {
+ nKey = 8 + j,
+ b謚ｼ縺輔ｌ縺 = true,
+ nTimeStamp = CSound邂｡逅.rc貍泌･冗畑繧ｿ繧､繝.n繧ｷ繧ｹ繝繝譎ょ綾, // 貍泌･冗畑繧ｿ繧､繝槭→蜷後§繧ｿ繧､繝槭ｒ菴ｿ縺縺薙→縺ｧ縲。GM縺ｨ隴憺擇縲∝･蜉帙★繧後ｒ髦ｲ縺舌
+ nVelocity = CInput邂｡逅.n騾壼ｸｸ髻ｳ驥
+ };
+ this.list蜈･蜉帙う繝吶Φ繝.Add(item);
+
+ this.bButtonState[8 + j] = true;
+ this.bButtonPushDown[8 + j] = true;
+ bIsButtonPressedReleased = true;
+ }
+ else if( this.bButtonState[8 + j] == true && !buttons[j] )
+ {
+ STInputEvent item = new STInputEvent()
+ {
+ nKey = 8 + j,
+ b謚ｼ縺輔ｌ縺 = false,
+ nTimeStamp = CSound邂｡逅.rc貍泌･冗畑繧ｿ繧､繝.n繧ｷ繧ｹ繝繝譎ょ綾, // 貍泌･冗畑繧ｿ繧､繝槭→蜷後§繧ｿ繧､繝槭ｒ菴ｿ縺縺薙→縺ｧ縲。GM縺ｨ隴憺擇縲∝･蜉帙★繧後ｒ髦ｲ縺舌
+ nVelocity = CInput邂｡逅.n騾壼ｸｸ髻ｳ驥
+ };
+ this.list蜈･蜉帙う繝吶Φ繝.Add(item);
+
+ this.bButtonState[8 + j] = false;
+ this.bButtonPullUp[8 + j] = true;
+ bIsButtonPressedReleased = true;
+ }
+ }
+ //-----------------------------
+ #endregion
+ // #24341 2011.3.12 yyagi: POV support
+ #region [ POV HAT 4/8way (only single POV switch is supported)]
+ int[] povs = currentState.PointOfViewControllers;
+ if (povs != null)
+ {
+ if ( povs[0] >= 0 )
+ {
+ int nPovDegree = povs[0];
+ int nWay = (nPovDegree + 2250) / 4500;
+ if (nWay == 8) nWay = 0;
+
+ if (this.bButtonState[8 + 128 + nWay] == false)
+ {
+ STInputEvent stevent = new STInputEvent()
+ {
+ nKey = 8 + 128 + nWay,
+ //Debug.WriteLine( "POVS:" + povs[ 0 ].ToString( CultureInfo.CurrentCulture ) + ", " +stevent.nKey );
+ b謚ｼ縺輔ｌ縺 = true,
+ nTimeStamp = CSound邂｡逅.rc貍泌･冗畑繧ｿ繧､繝.n繧ｷ繧ｹ繝繝譎ょ綾, // 貍泌･冗畑繧ｿ繧､繝槭→蜷後§繧ｿ繧､繝槭ｒ菴ｿ縺縺薙→縺ｧ縲。GM縺ｨ隴憺擇縲∝･蜉帙★繧後ｒ髦ｲ縺舌
+ nVelocity = CInput邂｡逅.n騾壼ｸｸ髻ｳ驥
+ };
+ this.list蜈･蜉帙う繝吶Φ繝.Add(stevent);
+
+ this.bButtonState[stevent.nKey] = true;
+ this.bButtonPushDown[stevent.nKey] = true;
+ }
+ }
+ else if (bIsButtonPressedReleased == false) // #xxxxx 2011.12.3 yyagi 莉悶ｮ繝懊ち繝ｳ縺御ｽ輔ｂ謚ｼ縺輔ｌ/髮｢縺輔ｌ縺ｦ縺ｪ縺ｼ抉OV縺碁屬縺輔ｌ縺
+ {
+ int nWay = 0;
+ for (int i = 8 + 0x80; i < 8 + 0x80 + 8; i++)
+ { // 髮｢縺輔ｌ縺溘懊ち繝ｳ繧定ｪｿ縺ｹ繧九◆繧√↓縲∝縲謚ｼ縺輔ｌ縺ｦ縺縺溘懊ち繝ｳ繧呈爾縺吶
+ if (this.bButtonState[i] == true) // DirectInput繧堤峩謗･縺縺倥ｋ縺ｪ繧峨％繧薙↑縺薙→縺励↑縺上※濶ｯ縺縺ｮ縺ｫ縲√≠縺髱｢蛟偵
+ { // 縺薙ｮ蜃ｦ逅縺悟ｿ隕√↑縺溘ａ縺ｫ縲￣OV繧1蛟九＠縺九し繝昴ｼ繝医〒縺阪↑縺縲ら┌蠢ｵ縲
+ nWay = i;
+ break;
+ }
+ }
+ if (nWay != 0)
+ {
+ STInputEvent stevent = new STInputEvent()
+ {
+ nKey = nWay,
+ b謚ｼ縺輔ｌ縺 = false,
+ nTimeStamp = CSound邂｡逅.rc貍泌･冗畑繧ｿ繧､繝.n繧ｷ繧ｹ繝繝譎ょ綾, // 貍泌･冗畑繧ｿ繧､繝槭→蜷後§繧ｿ繧､繝槭ｒ菴ｿ縺縺薙→縺ｧ縲。GM縺ｨ隴憺擇縲∝･蜉帙★繧後ｒ髦ｲ縺舌
+ nVelocity = 0
+ };
+ this.list蜈･蜉帙う繝吶Φ繝.Add(stevent);
+
+ this.bButtonState[nWay] = false;
+ this.bButtonPullUp[nWay] = true;
+ }
+ }
+ }
+ #endregion
+ }
+ //-----------------------------
+ #endregion
+ }
+ }
+ }
+
+ public bool b繧ｭ繝ｼ縺梧款縺輔ｌ縺(int nButton)
+ {
+ return this.bButtonPushDown[nButton];
+ }
+ public bool b繧ｭ繝ｼ縺梧款縺輔ｌ縺ｦ縺繧(int nButton)
+ {
+ return this.bButtonState[nButton];
+ }
+ public bool b繧ｭ繝ｼ縺碁屬縺輔ｌ縺(int nButton)
+ {
+ return this.bButtonPullUp[nButton];
+ }
+ public bool b繧ｭ繝ｼ縺碁屬縺輔ｌ縺ｦ縺繧(int nButton)
+ {
+ return !this.bButtonState[nButton];
+ }
+ //-----------------
+ #endregion
+
+ #region [ IDisposable 螳溯｣ ]
+ //-----------------
+ public void Dispose()
+ {
+ if(!this.bDispose螳御ｺ貂医∩)
+ {
+ if(this.devJoystick != null)
+ {
+ this.devJoystick.Dispose();
+ this.devJoystick = null;
+ }
+ //if( this.timer != null )
+ //{
+ // this.timer.Dispose();
+ // this.timer = null;
+ //}
+ if (this.list蜈･蜉帙う繝吶Φ繝 != null)
+ {
+ this.list蜈･蜉帙う繝吶Φ繝 = null;
+ }
+ this.bDispose螳御ｺ貂医∩ = true;
+ }
+ }
+ //-----------------
+ #endregion
+
+
+ // 縺昴ｮ莉
+
+ #region [ private ]
+ //-----------------
+ private bool[] bButtonPullUp = new bool[0x100];
+ private bool[] bButtonPushDown = new bool[0x100];
+ private bool[] bButtonState = new bool[0x100]; // 0-5: XYZ, 6 - 0x128+5: buttons, 0x128+6 - 0x128+6+8: POV/HAT
+ private int[] nPovState = new int[4];
+ private bool bDispose螳御ｺ貂医∩;
+ private Joystick devJoystick;
+ //private CTimer timer;
+
+ private void bButtonUpDown(JoystickUpdate data, int axisdata, int target, int contrary) // #26871 2011.12.3 霆ｸ縺ｮ蜿崎ｻ｢縺ｫ蟇ｾ蠢懊☆繧九◆繧√↓繝ｪ繝輔ぃ繧ｯ繧ｿ
+ {
+ int targetsign = (target < contrary) ? -1 : 1;
+ if (Math.Abs(axisdata) > 500 && (targetsign == Math.Sign(axisdata))) // 霆ｸ縺ｮ譛螟ｧ蛟､縺ｮ蜊雁繧定ｶ縺医※縺縺ｦ縲√°縺､
+ {
+ if (bDoUpDownCore(target, data, false)) // 逶ｴ蜑阪∪縺ｧ縺ｯ雜縺医※縺縺ｪ縺代ｌ縺ｰ縲∽ｻ雁屓ON
+ {
+ //Debug.WriteLine( "X-ON " + data.TimeStamp + " " + axisdata );
+ }
+ else
+ {
+ //Debug.WriteLine( "X-ONx " + data.TimeStamp + " " + axisdata );
+ }
+ bDoUpDownCore(contrary, data, true); // X霆ｸ+ == ON 縺九ｉ X霆ｸ-縺ｮON繝ｬ繝ｳ繧ｸ縺ｫ譚･縺溘ｉ縲々霆ｸ+縺ｯOFF
+ }
+ else if ((axisdata <= 0 && targetsign <= 0) || (axisdata >= 0 && targetsign >= 0)) // 霆ｸ縺ｮ譛螟ｧ蛟､縺ｮ蜊雁繧定ｶ縺医※縺翫ｉ縺壹√°縺､
+ {
+ //Debug.WriteLine( "X-OFF? " + data.TimeStamp + " " + axisdata );
+ if (bDoUpDownCore(target, data, true)) // 逶ｴ蜑阪∪縺ｧ縺ｯ雜縺医※縺縺溘ｮ縺ｪ繧峨ｰ縲∽ｻ雁屓OFF
+ {
+ //Debug.WriteLine( "X-OFF " + data.TimeStamp + " " + axisdata );
+ }
+ else if (bDoUpDownCore(contrary, data, true)) // X霆ｸ+ == ON 縺九ｉ X霆ｸ-縺ｮOFF繝ｬ繝ｳ繧ｸ縺ｫ縺阪◆繧峨々霆ｸ+縺ｯOFF
+ {
+ //Debug.WriteLine( "X-OFFx " + data.TimeStamp + " " + axisdata );
+ }
+ }
+ }
+
+ ///
+ /// 蠢隕√↓蠢懊§縺ｦ霆ｸ繝懊ち繝ｳ縺ｮ荳翫£荳九£繧､繝吶Φ繝医ｒ逋ｺ逕溘☆繧
+ ///
+ /// 霆ｸ繝懊ち繝ｳ逡ｪ蜿ｷ 0=-X 1=+X ... 5=+Z
+ ///
+ /// 逶ｴ蜑阪ｮ繝懊ち繝ｳ迥ｶ諷 true=謚ｼ縺輔ｌ縺ｦ縺縺
+ /// 荳翫£荳九£繧､繝吶Φ繝育匱逕滓凾true
+ private bool bDoUpDownCore(int target, JoystickUpdate data, bool lastMode)
+ {
+ if ( this.bButtonState[target] == lastMode )
+ {
+ STInputEvent e = new STInputEvent()
+ {
+ nKey = target,
+ b謚ｼ縺輔ｌ縺 = !lastMode,
+ nTimeStamp = CSound邂｡逅.rc貍泌･冗畑繧ｿ繧､繝.n繧ｵ繧ｦ繝ｳ繝峨ち繧､繝槭ｼ縺ｮ繧ｷ繧ｹ繝繝譎ょ綾ms縺ｸ縺ｮ螟画鋤(data.Timestamp),
+ nVelocity = (lastMode) ? 0 : CInput邂｡逅.n騾壼ｸｸ髻ｳ驥
+ };
+ this.list蜈･蜉帙う繝吶Φ繝.Add(e);
+
+ this.bButtonState[target] = !lastMode;
+ if (lastMode)
+ {
+ this.bButtonPullUp[target] = true;
+ }
+ else
+ {
+ this.bButtonPushDown[target] = true;
+ }
+ return true;
+ }
+ return false;
+ }
+ //-----------------
+ #endregion
+ }
+}
diff --git a/FDK19/繧ｳ繝ｼ繝/02.蜈･蜉/CInputKeyboard.cs b/FDK19/繧ｳ繝ｼ繝/02.蜈･蜉/CInputKeyboard.cs
new file mode 100644
index 00000000..44d49609
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/02.蜈･蜉/CInputKeyboard.cs
@@ -0,0 +1,296 @@
+ｻｿusing System;
+using System.Collections.Generic;
+using System.Text;
+using System.Diagnostics;
+using SharpDX;
+using SharpDX.DirectInput;
+
+using SlimDXKey = SlimDXKeys.Key;
+using SharpDXKey = SharpDX.DirectInput.Key;
+
+namespace FDK
+{
+ public class CInputKeyboard : IInputDevice, IDisposable
+ {
+ // 繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ
+
+ public CInputKeyboard(IntPtr hWnd, DirectInput directInput)
+ {
+ this.e蜈･蜉帙ョ繝舌う繧ｹ遞ｮ蛻･ = E蜈･蜉帙ョ繝舌う繧ｹ遞ｮ蛻･.Keyboard;
+ this.GUID = "";
+ this.ID = 0;
+ try
+ {
+ this.devKeyboard = new Keyboard(directInput);
+ this.devKeyboard.SetCooperativeLevel(hWnd, CooperativeLevel.NoWinKey | CooperativeLevel.Foreground | CooperativeLevel.NonExclusive);
+ this.devKeyboard.Properties.BufferSize = 32;
+ Trace.TraceInformation(this.devKeyboard.Information.ProductName.Trim(new char[] { '\0' }) + " 繧堤函謌舌＠縺ｾ縺励◆縲"); // 縺ｪ縺懊°0x00縺ｮ繧ｴ繝溘′蜃ｺ繧九ｮ縺ｧ蜑企勁
+ this.strDeviceName = this.devKeyboard.Information.ProductName.Trim(new char[] { '\0' });
+ }
+ catch
+ {
+ if(this.devKeyboard != null)
+ {
+ this.devKeyboard.Dispose();
+ this.devKeyboard = null;
+ }
+ Trace.TraceWarning("Keyboard 繝繝舌う繧ｹ縺ｮ逕滓舌↓螟ｱ謨励＠縺ｾ縺励◆縲");
+ throw;
+ }
+ try
+ {
+ this.devKeyboard.Acquire();
+ }
+ catch
+ {
+ }
+
+ for (int i = 0; i < this.bKeyState.Length; i++)
+ this.bKeyState[i] = false;
+
+ //this.timer = new CTimer( CTimer.E遞ｮ蛻･.MultiMedia );
+ this.list蜈･蜉帙う繝吶Φ繝 = new List(32);
+ // this.ct = new CTimer( CTimer.E遞ｮ蛻･.PerformanceCounter );
+ }
+
+
+ // 繝｡繧ｽ繝繝
+
+ #region [ IInputDevice 螳溯｣ ]
+ //-----------------
+ public E蜈･蜉帙ョ繝舌う繧ｹ遞ｮ蛻･ e蜈･蜉帙ョ繝舌う繧ｹ遞ｮ蛻･ { get; private set; }
+ public string GUID { get; private set; }
+ public int ID { get; private set; }
+ public List list蜈･蜉帙う繝吶Φ繝 { get; private set; }
+ public string strDeviceName { get; set; }
+
+ public void t繝昴ｼ繝ｪ繝ｳ繧ｰ(bool bWindow縺後い繧ｯ繝繧｣繝紋ｸｭ, bool b繝舌ャ繝輔ぃ蜈･蜉帙ｒ菴ｿ逕ｨ縺吶ｋ)
+ {
+ for (int i = 0; i < 256; i++)
+ {
+ this.bKeyPushDown[i] = false;
+ this.bKeyPullUp[i] = false;
+ }
+
+ if (bWindow縺後い繧ｯ繝繧｣繝紋ｸｭ && (this.devKeyboard != null))
+ {
+ this.devKeyboard.Acquire();
+ this.devKeyboard.Poll();
+
+ //this.list蜈･蜉帙う繝吶Φ繝 = new List( 32 );
+ this.list蜈･蜉帙う繝吶Φ繝.Clear(); // #xxxxx 2012.6.11 yyagi; To optimize, I removed new();
+ int posEnter = -1;
+ //string d = DateTime.Now.ToString( "yyyy/MM/dd HH:mm:ss.ffff" );
+
+ if (b繝舌ャ繝輔ぃ蜈･蜉帙ｒ菴ｿ逕ｨ縺吶ｋ)
+ {
+ #region [ a.繝舌ャ繝輔ぃ蜈･蜉 ]
+ //-----------------------------
+ var bufferedData = this.devKeyboard.GetBufferedData();
+ //if ( Result.Last.IsSuccess && bufferedData != null )
+ {
+ foreach (KeyboardUpdate data in bufferedData)
+ {
+ // #xxxxx: 2017.5.7: from: DIK (SharpDX.DirectInput.Key) 繧 SlimDX.DirectInput.Key 縺ｫ螟画鋤縲
+ var key = DeviceConstantConverter.DIKtoKey(data.Key);
+ if (SlimDXKey.Unknown == key)
+ continue; // 譛ｪ蟇ｾ蠢懊く繝ｼ縺ｯ辟｡隕悶
+
+ //foreach ( Key key in data.PressedKeys )
+ if (data.IsPressed)
+ {
+ // #23708 2016.3.19 yyagi; Even if we remove ALT+ENTER key input by SuppressKeyPress = true in Form,
+ // it doesn't affect to DirectInput (ALT+ENTER does not remove)
+ // So we ignore ENTER input in ALT+ENTER combination here.
+ // Note: ENTER will be alived if you keyup ALT after ALT+ENTER.
+ if (key != SlimDXKey.Return || (bKeyState[(int)SlimDXKey.LeftAlt] == false && bKeyState[(int)SlimDXKey.RightAlt] == false))
+ {
+ STInputEvent item = new STInputEvent()
+ {
+ nKey = (int)key,
+ b謚ｼ縺輔ｌ縺 = true,
+ b髮｢縺輔ｌ縺 = false,
+ nTimeStamp = CSound邂｡逅.rc貍泌･冗畑繧ｿ繧､繝.n繧ｵ繧ｦ繝ｳ繝峨ち繧､繝槭ｼ縺ｮ繧ｷ繧ｹ繝繝譎ょ綾ms縺ｸ縺ｮ螟画鋤(data.Timestamp),
+ nVelocity = CInput邂｡逅.n騾壼ｸｸ髻ｳ驥
+ };
+ this.list蜈･蜉帙う繝吶Φ繝.Add(item);
+
+ this.bKeyState[(int)key] = true;
+ this.bKeyPushDown[(int)key] = true;
+ }
+ //if ( item.nKey == (int) SlimDXKey.Space )
+ //{
+ // Trace.TraceInformation( "FDK(buffered): SPACE key registered. " + ct.n繧ｷ繧ｹ繝繝譎ょ綾 );
+ //}
+ }
+ //foreach ( Key key in data.ReleasedKeys )
+ if (data.IsReleased)
+ {
+ STInputEvent item = new STInputEvent()
+ {
+ nKey = (int)key,
+ b謚ｼ縺輔ｌ縺 = false,
+ b髮｢縺輔ｌ縺 = true,
+ nTimeStamp = CSound邂｡逅.rc貍泌･冗畑繧ｿ繧､繝.n繧ｵ繧ｦ繝ｳ繝峨ち繧､繝槭ｼ縺ｮ繧ｷ繧ｹ繝繝譎ょ綾ms縺ｸ縺ｮ螟画鋤(data.Timestamp),
+ nVelocity = CInput邂｡逅.n騾壼ｸｸ髻ｳ驥
+ };
+ this.list蜈･蜉帙う繝吶Φ繝.Add(item);
+ this.bKeyState[(int)key] = false;
+ this.bKeyPullUp[(int)key] = true;
+ }
+ }
+ }
+ //-----------------------------
+ #endregion
+ }
+ else
+ {
+ #region [ b.迥ｶ諷句･蜉 ]
+ //-----------------------------
+ KeyboardState currentState = this.devKeyboard.GetCurrentState();
+ //if ( Result.Last.IsSuccess && currentState != null )
+ {
+ foreach (SharpDXKey dik in currentState.PressedKeys)
+ {
+ // #xxxxx: 2017.5.7: from: DIK (SharpDX.DirectInput.Key) 繧 SlimDX.DirectInput.Key 縺ｫ螟画鋤縲
+ var key = DeviceConstantConverter.DIKtoKey(dik);
+ if (SlimDXKey.Unknown == key)
+ continue; // 譛ｪ蟇ｾ蠢懊く繝ｼ縺ｯ辟｡隕悶
+
+ if (this.bKeyState[(int)key] == false)
+ {
+ if (key != SlimDXKey.Return || (bKeyState[(int)SlimDXKey.LeftAlt] == false && bKeyState[(int)SlimDXKey.RightAlt] == false)) // #23708 2016.3.19 yyagi
+ {
+ var ev = new STInputEvent()
+ {
+ nKey = (int)key,
+ b謚ｼ縺輔ｌ縺 = true,
+ b髮｢縺輔ｌ縺 = false,
+ nTimeStamp = CSound邂｡逅.rc貍泌･冗畑繧ｿ繧､繝.n繧ｷ繧ｹ繝繝譎ょ綾, // 貍泌･冗畑繧ｿ繧､繝槭→蜷後§繧ｿ繧､繝槭ｒ菴ｿ縺縺薙→縺ｧ縲。GM縺ｨ隴憺擇縲∝･蜉帙★繧後ｒ髦ｲ縺舌
+ nVelocity = CInput邂｡逅.n騾壼ｸｸ髻ｳ驥,
+ };
+ this.list蜈･蜉帙う繝吶Φ繝.Add(ev);
+
+ this.bKeyState[(int)key] = true;
+ this.bKeyPushDown[(int)key] = true;
+ }
+
+ //if ( (int) key == (int) SlimDXKey.Space )
+ //{
+ // Trace.TraceInformation( "FDK(direct): SPACE key registered. " + ct.n繧ｷ繧ｹ繝繝譎ょ綾 );
+ //}
+ }
+ }
+ //foreach ( Key key in currentState.ReleasedKeys )
+ foreach (SharpDXKey dik in currentState.AllKeys)
+ {
+ // #xxxxx: 2017.5.7: from: DIK (SharpDX.DirectInput.Key) 繧 SlimDX.DirectInput.Key 縺ｫ螟画鋤縲
+ var key = DeviceConstantConverter.DIKtoKey(dik);
+ if (SlimDXKey.Unknown == key)
+ continue; // 譛ｪ蟇ｾ蠢懊く繝ｼ縺ｯ辟｡隕悶
+
+ if (this.bKeyState[(int)key] == true && !currentState.IsPressed(dik)) // 蜑榊屓縺ｯ謚ｼ縺輔ｌ縺ｦ縺繧九ｮ縺ｫ莉雁屓縺ｯ謚ｼ縺輔ｌ縺ｦ縺縺ｪ縺 竊 髮｢縺輔ｌ縺
+ {
+ var ev = new STInputEvent()
+ {
+ nKey = (int)key,
+ b謚ｼ縺輔ｌ縺 = false,
+ b髮｢縺輔ｌ縺 = true,
+ nTimeStamp = CSound邂｡逅.rc貍泌･冗畑繧ｿ繧､繝.n繧ｷ繧ｹ繝繝譎ょ綾, // 貍泌･冗畑繧ｿ繧､繝槭→蜷後§繧ｿ繧､繝槭ｒ菴ｿ縺縺薙→縺ｧ縲。GM縺ｨ隴憺擇縲∝･蜉帙★繧後ｒ髦ｲ縺舌
+ nVelocity = CInput邂｡逅.n騾壼ｸｸ髻ｳ驥,
+ };
+ this.list蜈･蜉帙う繝吶Φ繝.Add(ev);
+
+ this.bKeyState[(int) key] = false;
+ this.bKeyPullUp[(int) key] = true;
+ }
+ }
+ }
+ //-----------------------------
+ #endregion
+ }
+ #region [#23708 2011.4.8 yyagi Alt縺梧款縺輔ｌ縺ｦ縺繧九→縺阪ｯ縲・nter謚ｼ荳区ュ蝣ｱ繧貞炎髯､縺吶ｋ -> 蜑ｯ菴懃畑縺瑚ｦ九▽縺九ｊ蜑企勁]
+ //if ( this.bKeyState[ (int) SlimDXKey.RightAlt ] ||
+ // this.bKeyState[ (int) SlimDXKey.LeftAlt ] )
+ //{
+ // int cr = (int) SlimDXKey.Return;
+ // this.bKeyPushDown[ cr ] = false;
+ // this.bKeyPullUp[ cr ] = false;
+ // this.bKeyState[ cr ] = false;
+ //}
+ #endregion
+ }
+ }
+ ///
+ /// 隱ｿ縺ｹ繧 SlimDX.DirectInput.Key 繧 int 縺ｫ繧ｭ繝｣繧ｹ繝医＠縺溷､縲ゑｼSharpDX.DirectInput.Key 縺ｧ縺ｯ縺ｪ縺縺ｮ縺ｧ豕ｨ諢上ゑｼ
+ ///
+ public bool b繧ｭ繝ｼ縺梧款縺輔ｌ縺(int nKey)
+ {
+ return this.bKeyPushDown[nKey];
+ }
+ ///
+ /// 隱ｿ縺ｹ繧 SlimDX.DirectInput.Key 繧 int 縺ｫ繧ｭ繝｣繧ｹ繝医＠縺溷､縲ゑｼSharpDX.DirectInput.Key 縺ｧ縺ｯ縺ｪ縺縺ｮ縺ｧ豕ｨ諢上ゑｼ
+ ///
+ public bool b繧ｭ繝ｼ縺梧款縺輔ｌ縺ｦ縺繧(int nKey)
+ {
+ return this.bKeyState[ nKey ];
+ }
+ ///
+ /// 隱ｿ縺ｹ繧 SlimDX.DirectInput.Key 繧 int 縺ｫ繧ｭ繝｣繧ｹ繝医＠縺溷､縲ゑｼSharpDX.DirectInput.Key 縺ｧ縺ｯ縺ｪ縺縺ｮ縺ｧ豕ｨ諢上ゑｼ
+ ///
+ public bool b繧ｭ繝ｼ縺碁屬縺輔ｌ縺(int nKey)
+ {
+ return this.bKeyPullUp[nKey];
+ }
+ ///
+ /// 隱ｿ縺ｹ繧 SlimDX.DirectInput.Key 繧 int 縺ｫ繧ｭ繝｣繧ｹ繝医＠縺溷､縲ゑｼSharpDX.DirectInput.Key 縺ｧ縺ｯ縺ｪ縺縺ｮ縺ｧ豕ｨ諢上ゑｼ
+ ///
+ public bool b繧ｭ繝ｼ縺碁屬縺輔ｌ縺ｦ縺繧(int nKey)
+ {
+ return !this.bKeyState[nKey];
+ }
+ //-----------------
+ #endregion
+
+ #region [ IDisposable 螳溯｣ ]
+ //-----------------
+ public void Dispose()
+ {
+ if(!this.bDispose螳御ｺ貂医∩)
+ {
+ if(this.devKeyboard != null)
+ {
+ this.devKeyboard.Dispose();
+ this.devKeyboard = null;
+ }
+ //if( this.timer != null )
+ //{
+ // this.timer.Dispose();
+ // this.timer = null;
+ //}
+ if (this.list蜈･蜉帙う繝吶Φ繝 != null)
+ {
+ this.list蜈･蜉帙う繝吶Φ繝 = null;
+ }
+ this.bDispose螳御ｺ貂医∩ = true;
+ }
+ }
+ //-----------------
+ #endregion
+
+
+ // 縺昴ｮ莉
+
+ #region [ private ]
+ //-----------------
+ private bool[] bKeyPullUp = new bool[256];
+ private bool[] bKeyPushDown = new bool[256];
+ private bool[] bKeyState = new bool[256];
+ private bool bDispose螳御ｺ貂医∩;
+ private Keyboard devKeyboard;
+ //private CTimer timer;
+ //private CTimer ct;
+ //-----------------
+ #endregion
+ }
+}
diff --git a/FDK19/繧ｳ繝ｼ繝/02.蜈･蜉/CInputMIDI.cs b/FDK19/繧ｳ繝ｼ繝/02.蜈･蜉/CInputMIDI.cs
new file mode 100644
index 00000000..8b8308d9
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/02.蜈･蜉/CInputMIDI.cs
@@ -0,0 +1,124 @@
+ｻｿusing System;
+using System.Collections.Generic;
+using System.Text;
+using System.Diagnostics;
+
+namespace FDK
+{
+ public class CInputMIDI : IInputDevice, IDisposable
+ {
+ // 繝励Ο繝代ユ繧｣
+
+ public IntPtr hMidiIn;
+ public List listEventBuffer;
+
+ // 繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ
+
+ public CInputMIDI(uint nID)
+ {
+ this.hMidiIn = IntPtr.Zero;
+ this.listEventBuffer = new List(32);
+ this.list蜈･蜉帙う繝吶Φ繝 = new List(32);
+ this.e蜈･蜉帙ョ繝舌う繧ｹ遞ｮ蛻･ = E蜈･蜉帙ョ繝舌う繧ｹ遞ｮ蛻･.MidiIn;
+ this.GUID = "";
+ this.ID = (int)nID;
+ this.strDeviceName = ""; // CInput邂｡逅縺ｧ蛻晄悄蛹悶☆繧
+ }
+
+
+ // 繝｡繧ｽ繝繝
+
+ public void t繝｡繝繧ｻ繝ｼ繧ｸ縺九ｉMIDI菫｡蜿ｷ縺ｮ縺ｿ蜿嶺ｿ｡(uint wMsg, IntPtr dwInstance, IntPtr dwParam1, IntPtr dwParam2, long n蜿嶺ｿ｡繧ｷ繧ｹ繝繝譎ょ綾)
+ {
+ if (wMsg == CWin32.MIM_DATA)
+ {
+ int nMIDIevent = (int)dwParam1 & 0xF0;
+ int nPara1 = ((int)dwParam1 >> 8) & 0xFF;
+ int nPara2 = ((int)dwParam1 >> 16) & 0xFF;
+ int nPara3 = ((int)dwParam2 >> 8) & 0xFF;
+ int nPara4 = ((int)dwParam2 >> 16) & 0xFF;
+
+ // Trace.TraceInformation( "MIDIevent={0:X2} para1={1:X2} para2={2:X2}", nMIDIevent, nPara1, nPara2 ,nPara3,nPara4);
+
+ if ((nMIDIevent == 0x90) && (nPara2 != 0)) // Note ON
+ {
+ STInputEvent item = new STInputEvent();
+ item.nKey = nPara1;
+ item.b謚ｼ縺輔ｌ縺 = true;
+ item.nTimeStamp = n蜿嶺ｿ｡繧ｷ繧ｹ繝繝譎ょ綾;
+ item.nVelocity = nPara2;
+ this.listEventBuffer.Add(item);
+ }
+ //else if ( ( nMIDIevent == 0xB0 ) && ( nPara1 == 4 ) ) // Ctrl Chg #04: Foot Controller
+ //{
+ // STInputEvent item = new STInputEvent();
+ // item.nKey = nPara1;
+ // item.b謚ｼ縺輔ｌ縺 = true;
+ // item.nTimeStamp = n蜿嶺ｿ｡繧ｷ繧ｹ繝繝譎ょ綾;
+ // item.nVelocity = nPara2;
+ // this.listEventBuffer.Add( item );
+ //}
+ }
+ }
+
+ #region [ IInputDevice 螳溯｣ ]
+ //-----------------
+ public E蜈･蜉帙ョ繝舌う繧ｹ遞ｮ蛻･ e蜈･蜉帙ョ繝舌う繧ｹ遞ｮ蛻･ { get; private set; }
+ public string GUID { get; private set; }
+ public int ID { get; private set; }
+ public List list蜈･蜉帙う繝吶Φ繝 { get; private set; }
+ public string strDeviceName { get; set; }
+
+ public void t繝昴ｼ繝ｪ繝ｳ繧ｰ(bool bWindow縺後い繧ｯ繝繧｣繝紋ｸｭ, bool b繝舌ャ繝輔ぃ蜈･蜉帙ｒ菴ｿ逕ｨ縺吶ｋ)
+ {
+ // this.list蜈･蜉帙う繝吶Φ繝 = new List( 32 );
+ this.list蜈･蜉帙う繝吶Φ繝.Clear(); // #xxxxx 2012.6.11 yyagi; To optimize, I removed new();
+
+ for (int i = 0; i < this.listEventBuffer.Count; i++)
+ this.list蜈･蜉帙う繝吶Φ繝.Add(this.listEventBuffer[i]);
+
+ this.listEventBuffer.Clear();
+ }
+ public bool b繧ｭ繝ｼ縺梧款縺輔ｌ縺(int nKey)
+ {
+ foreach (STInputEvent event2 in this.list蜈･蜉帙う繝吶Φ繝)
+ {
+ if ((event2.nKey == nKey) && event2.b謚ｼ縺輔ｌ縺)
+ {
+ return true;
+ }
+ }
+ return false;
+ }
+ public bool b繧ｭ繝ｼ縺梧款縺輔ｌ縺ｦ縺繧(int nKey)
+ {
+ return false;
+ }
+ public bool b繧ｭ繝ｼ縺碁屬縺輔ｌ縺(int nKey)
+ {
+ return false;
+ }
+ public bool b繧ｭ繝ｼ縺碁屬縺輔ｌ縺ｦ縺繧(int nKey)
+ {
+ return false;
+ }
+ //-----------------
+ #endregion
+
+ #region [ IDisposable 螳溯｣ ]
+ //-----------------
+ public void Dispose()
+ {
+ if (this.listEventBuffer != null)
+ {
+ this.listEventBuffer = null;
+ }
+ if (this.list蜈･蜉帙う繝吶Φ繝 != null)
+ {
+ this.list蜈･蜉帙う繝吶Φ繝 = null;
+ }
+ }
+ //-----------------
+ #endregion
+ }
+}
diff --git a/FDK19/繧ｳ繝ｼ繝/02.蜈･蜉/CInputMouse.cs b/FDK19/繧ｳ繝ｼ繝/02.蜈･蜉/CInputMouse.cs
new file mode 100644
index 00000000..01d2dd9c
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/02.蜈･蜉/CInputMouse.cs
@@ -0,0 +1,251 @@
+ｻｿusing System;
+using System.Collections.Generic;
+using System.Text;
+using System.Diagnostics;
+using SharpDX;
+using SharpDX.DirectInput;
+
+namespace FDK
+{
+ public class CInputMouse : IInputDevice, IDisposable
+ {
+ // 螳壽焚
+
+ public const int n繝槭え繧ｹ縺ｮ譛螟ｧ繝懊ち繝ｳ謨ｰ = 8;
+
+
+ // 繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ
+
+ public CInputMouse(IntPtr hWnd, DirectInput directInput)
+ {
+ this.e蜈･蜉帙ョ繝舌う繧ｹ遞ｮ蛻･ = E蜈･蜉帙ョ繝舌う繧ｹ遞ｮ蛻･.Mouse;
+ this.GUID = "";
+ this.ID = 0;
+ try
+ {
+ this.devMouse = new Mouse(directInput);
+ this.devMouse.SetCooperativeLevel(hWnd, CooperativeLevel.Foreground | CooperativeLevel.NonExclusive);
+ this.devMouse.Properties.BufferSize = 0x20;
+ Trace.TraceInformation(this.devMouse.Information.ProductName.Trim(new char[] { '\0' }) + " 繧堤函謌舌＠縺ｾ縺励◆縲"); // 縺ｪ縺懊°0x00縺ｮ繧ｴ繝溘′蜃ｺ繧九ｮ縺ｧ蜑企勁
+ this.strDeviceName = this.devMouse.Information.ProductName.Trim(new char[] { '\0' });
+ }
+ catch
+ {
+ if (this.devMouse != null)
+ {
+ this.devMouse.Dispose();
+ this.devMouse = null;
+ }
+ Trace.TraceWarning("Mouse 繝繝舌う繧ｹ縺ｮ逕滓舌↓螟ｱ謨励＠縺ｾ縺励◆縲");
+ throw;
+ }
+ try
+ {
+ this.devMouse.Acquire();
+ }
+ catch
+ {
+ }
+
+ for (int i = 0; i < this.bMouseState.Length; i++)
+ this.bMouseState[i] = false;
+
+ //this.timer = new CTimer( CTimer.E遞ｮ蛻･.MultiMedia );
+ this.list蜈･蜉帙う繝吶Φ繝 = new List(32);
+ }
+
+
+ // 繝｡繧ｽ繝繝
+
+ #region [ IInputDevice 螳溯｣ ]
+ //-----------------
+ public E蜈･蜉帙ョ繝舌う繧ｹ遞ｮ蛻･ e蜈･蜉帙ョ繝舌う繧ｹ遞ｮ蛻･ { get; private set; }
+ public string GUID { get; private set; }
+ public int ID { get; private set; }
+ public List list蜈･蜉帙う繝吶Φ繝 { get; private set; }
+ public string strDeviceName { get; set; }
+
+ public void t繝昴ｼ繝ｪ繝ｳ繧ｰ(bool bWindow縺後い繧ｯ繝繧｣繝紋ｸｭ, bool b繝舌ャ繝輔ぃ蜈･蜉帙ｒ菴ｿ逕ｨ縺吶ｋ)
+ {
+ for (int i = 0; i < 8; i++)
+ {
+ this.bMousePushDown[i] = false;
+ this.bMousePullUp[i] = false;
+ }
+
+ if (bWindow縺後い繧ｯ繝繧｣繝紋ｸｭ && (this.devMouse != null))
+ {
+ this.devMouse.Acquire();
+ this.devMouse.Poll();
+
+ // this.list蜈･蜉帙う繝吶Φ繝 = new List( 32 );
+ this.list蜈･蜉帙う繝吶Φ繝.Clear(); // #xxxxx 2012.6.11 yyagi; To optimize, I removed new();
+
+ if (b繝舌ャ繝輔ぃ蜈･蜉帙ｒ菴ｿ逕ｨ縺吶ｋ)
+ {
+ #region [ a.繝舌ャ繝輔ぃ蜈･蜉 ]
+ //-----------------------------
+ var bufferedData = this.devMouse.GetBufferedData();
+ //if( Result.Last.IsSuccess && bufferedData != null )
+ {
+ foreach (MouseUpdate data in bufferedData)
+ {
+ var mouseButton = new[] {
+ MouseOffset.Buttons0,
+ MouseOffset.Buttons1,
+ MouseOffset.Buttons2,
+ MouseOffset.Buttons3,
+ MouseOffset.Buttons4,
+ MouseOffset.Buttons5,
+ MouseOffset.Buttons6,
+ MouseOffset.Buttons7,
+ };
+
+ for (int k = 0; k < 8; k++)
+ {
+ //if( data.IsPressed( k ) )
+ if (data.Offset == mouseButton[k] && ((data.Value & 0x80) != 0))
+ {
+ STInputEvent item = new STInputEvent()
+ {
+ nKey = k,
+ b謚ｼ縺輔ｌ縺 = true,
+ b髮｢縺輔ｌ縺 = false,
+ nTimeStamp = CSound邂｡逅.rc貍泌･冗畑繧ｿ繧､繝.n繧ｵ繧ｦ繝ｳ繝峨ち繧､繝槭ｼ縺ｮ繧ｷ繧ｹ繝繝譎ょ綾ms縺ｸ縺ｮ螟画鋤(data.Timestamp),
+ nVelocity = CInput邂｡逅.n騾壼ｸｸ髻ｳ驥
+ };
+ this.list蜈･蜉帙う繝吶Φ繝.Add(item);
+
+ this.bMouseState[k] = true;
+ this.bMousePushDown[k] = true;
+ }
+ else if (data.Offset == mouseButton[k] && this.bMouseState[k] == true && ((data.Value & 0x80) == 0))
+ //else if( data.IsReleased( k ) )
+ {
+ STInputEvent item = new STInputEvent()
+ {
+ nKey = k,
+ b謚ｼ縺輔ｌ縺 = false,
+ b髮｢縺輔ｌ縺 = true,
+ nTimeStamp = CSound邂｡逅.rc貍泌･冗畑繧ｿ繧､繝.n繧ｵ繧ｦ繝ｳ繝峨ち繧､繝槭ｼ縺ｮ繧ｷ繧ｹ繝繝譎ょ綾ms縺ｸ縺ｮ螟画鋤(data.Timestamp),
+ nVelocity = CInput邂｡逅.n騾壼ｸｸ髻ｳ驥
+ };
+ this.list蜈･蜉帙う繝吶Φ繝.Add(item);
+
+ this.bMouseState[k] = false;
+ this.bMousePullUp[k] = true;
+ }
+ }
+ }
+ }
+ //-----------------------------
+ #endregion
+ }
+ else
+ {
+ #region [ b.迥ｶ諷句･蜉 ]
+ //-----------------------------
+ MouseState currentState = this.devMouse.GetCurrentState();
+ //if( Result.Last.IsSuccess && currentState != null )
+ {
+ bool[] buttons = currentState.Buttons;
+
+ for (int j = 0; (j < buttons.Length) && (j < 8); j++)
+ {
+ if (this.bMouseState[j] == false && buttons[j] == true)
+ {
+ var ev = new STInputEvent()
+ {
+ nKey = j,
+ b謚ｼ縺輔ｌ縺 = true,
+ b髮｢縺輔ｌ縺 = false,
+ nTimeStamp = CSound邂｡逅.rc貍泌･冗畑繧ｿ繧､繝.n繧ｷ繧ｹ繝繝譎ょ綾, // 貍泌･冗畑繧ｿ繧､繝槭→蜷後§繧ｿ繧､繝槭ｒ菴ｿ縺縺薙→縺ｧ縲。GM縺ｨ隴憺擇縲∝･蜉帙★繧後ｒ髦ｲ縺舌
+ nVelocity = CInput邂｡逅.n騾壼ｸｸ髻ｳ驥,
+ };
+ this.list蜈･蜉帙う繝吶Φ繝.Add(ev);
+
+ this.bMouseState[j] = true;
+ this.bMousePushDown[j] = true;
+ }
+ else if(this.bMouseState[j] == true && buttons[j] == false)
+ {
+ var ev = new STInputEvent()
+ {
+ nKey = j,
+ b謚ｼ縺輔ｌ縺 = false,
+ b髮｢縺輔ｌ縺 = true,
+ nTimeStamp = CSound邂｡逅.rc貍泌･冗畑繧ｿ繧､繝.n繧ｷ繧ｹ繝繝譎ょ綾, // 貍泌･冗畑繧ｿ繧､繝槭→蜷後§繧ｿ繧､繝槭ｒ菴ｿ縺縺薙→縺ｧ縲。GM縺ｨ隴憺擇縲∝･蜉帙★繧後ｒ髦ｲ縺舌
+ nVelocity = CInput邂｡逅.n騾壼ｸｸ髻ｳ驥,
+ };
+ this.list蜈･蜉帙う繝吶Φ繝.Add(ev);
+
+ this.bMouseState[j] = false;
+ this.bMousePullUp[j] = true;
+ }
+ }
+ }
+ //-----------------------------
+ #endregion
+ }
+ }
+ }
+ public bool b繧ｭ繝ｼ縺梧款縺輔ｌ縺(int nButton)
+ {
+ return (((0 <= nButton) && (nButton < 8)) && this.bMousePushDown[nButton]);
+ }
+ public bool b繧ｭ繝ｼ縺梧款縺輔ｌ縺ｦ縺繧(int nButton)
+ {
+ return (((0 <= nButton) && (nButton < 8)) && this.bMouseState[nButton]);
+ }
+ public bool b繧ｭ繝ｼ縺碁屬縺輔ｌ縺(int nButton)
+ {
+ return (((0 <= nButton) && (nButton < 8)) && this.bMousePullUp[nButton]);
+ }
+ public bool b繧ｭ繝ｼ縺碁屬縺輔ｌ縺ｦ縺繧(int nButton)
+ {
+ return (((0 <= nButton) && (nButton < 8)) && !this.bMouseState[nButton]);
+ }
+ //-----------------
+ #endregion
+
+ #region [ IDisposable 螳溯｣ ]
+ //-----------------
+ public void Dispose()
+ {
+ if(!this.bDispose螳御ｺ貂医∩)
+ {
+ if(this.devMouse != null)
+ {
+ this.devMouse.Dispose();
+ this.devMouse = null;
+ }
+ //if( this.timer != null )
+ //{
+ // this.timer.Dispose();
+ // this.timer = null;
+ //}
+ if (this.list蜈･蜉帙う繝吶Φ繝 != null)
+ {
+ this.list蜈･蜉帙う繝吶Φ繝 = null;
+ }
+ this.bDispose螳御ｺ貂医∩ = true;
+ }
+ }
+ //-----------------
+ #endregion
+
+
+ // 縺昴ｮ莉
+
+ #region [ private ]
+ //-----------------
+ private bool bDispose螳御ｺ貂医∩;
+ private bool[] bMousePullUp = new bool[8];
+ private bool[] bMousePushDown = new bool[8];
+ private bool[] bMouseState = new bool[8];
+ private Mouse devMouse;
+ //private CTimer timer;
+ //-----------------
+ #endregion
+ }
+}
diff --git a/FDK19/繧ｳ繝ｼ繝/02.蜈･蜉/CInput邂｡逅.cs b/FDK19/繧ｳ繝ｼ繝/02.蜈･蜉/CInput邂｡逅.cs
new file mode 100644
index 00000000..63475af1
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/02.蜈･蜉/CInput邂｡逅.cs
@@ -0,0 +1,297 @@
+ｻｿusing System;
+using System.Collections.Generic;
+using System.Text;
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+using SharpDX.DirectInput;
+
+namespace FDK
+{
+ public class CInput邂｡逅 : IDisposable
+ {
+ // 螳壽焚
+
+ public static int n騾壼ｸｸ髻ｳ驥 = 110;
+
+
+ // 繝励Ο繝代ユ繧｣
+
+ public List list蜈･蜉帙ョ繝舌う繧ｹ
+ {
+ get;
+ private set;
+ }
+ public IInputDevice Keyboard
+ {
+ get
+ {
+ if (this._Keyboard != null)
+ {
+ return this._Keyboard;
+ }
+ foreach (IInputDevice device in this.list蜈･蜉帙ョ繝舌う繧ｹ)
+ {
+ if (device.e蜈･蜉帙ョ繝舌う繧ｹ遞ｮ蛻･ == E蜈･蜉帙ョ繝舌う繧ｹ遞ｮ蛻･.Keyboard)
+ {
+ this._Keyboard = device;
+ return device;
+ }
+ }
+ return null;
+ }
+ }
+ public IInputDevice Mouse
+ {
+ get
+ {
+ if (this._Mouse != null)
+ {
+ return this._Mouse;
+ }
+ foreach (IInputDevice device in this.list蜈･蜉帙ョ繝舌う繧ｹ)
+ {
+ if (device.e蜈･蜉帙ョ繝舌う繧ｹ遞ｮ蛻･ == E蜈･蜉帙ョ繝舌う繧ｹ遞ｮ蛻･.Mouse)
+ {
+ this._Mouse = device;
+ return device;
+ }
+ }
+ return null;
+ }
+ }
+
+
+ // 繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ
+ public CInput邂｡逅(IntPtr hWnd, bool bUseMidiIn = true)
+ {
+ CInput邂｡逅蛻晄悄蛹(hWnd, bUseMidiIn);
+ }
+
+ public void CInput邂｡逅蛻晄悄蛹(IntPtr hWnd, bool bUseMidiIn)
+ {
+ this.directInput = new DirectInput();
+ // this.timer = new CTimer( CTimer.E遞ｮ蛻･.MultiMedia );
+
+ this.list蜈･蜉帙ョ繝舌う繧ｹ = new List(10);
+ #region [ Enumerate keyboard/mouse: exception is masked if keyboard/mouse is not connected ]
+ CInputKeyboard cinputkeyboard = null;
+ CInputMouse cinputmouse = null;
+ try
+ {
+ cinputkeyboard = new CInputKeyboard(hWnd, directInput);
+ cinputmouse = new CInputMouse(hWnd, directInput);
+ }
+
+ catch
+ {
+ }
+ if (cinputkeyboard != null)
+ {
+ this.list蜈･蜉帙ョ繝舌う繧ｹ.Add(cinputkeyboard);
+ }
+ if (cinputmouse != null)
+ {
+ this.list蜈･蜉帙ョ繝舌う繧ｹ.Add(cinputmouse);
+ }
+ #endregion
+ #region [ Enumerate joypad ]
+ foreach (DeviceInstance instance in this.directInput.GetDevices(DeviceClass.GameControl, DeviceEnumerationFlags.AttachedOnly))
+ {
+ this.list蜈･蜉帙ョ繝舌う繧ｹ.Add(new CInputJoystick(hWnd, instance, directInput));
+ }
+ #endregion
+ if (bUseMidiIn)
+ {
+ this.proc = new CWin32.MidiInProc(this.MidiInCallback);
+ uint nMidiDevices = CWin32.midiInGetNumDevs();
+ Trace.TraceInformation("MIDI蜈･蜉帙ョ繝舌う繧ｹ謨ｰ: {0}", nMidiDevices);
+ for (uint i = 0; i < nMidiDevices; i++)
+ {
+ CInputMIDI item = new CInputMIDI(i);
+ CWin32.MIDIINCAPS lpMidiInCaps = new CWin32.MIDIINCAPS();
+ uint num3 = CWin32.midiInGetDevCaps(i, ref lpMidiInCaps, (uint)Marshal.SizeOf(lpMidiInCaps));
+ if (num3 != 0)
+ {
+ Trace.TraceError("MIDI In: Device{0}: midiInDevCaps(): {1:X2}: ", i, num3);
+ }
+ else
+ {
+ uint ret = CWin32.midiInOpen(ref item.hMidiIn, i, this.proc, IntPtr.Zero, 0x30000);
+ Trace.TraceInformation("midiInOpen()==" + ret);
+ Trace.TraceInformation("item.hMidiIn==" + item.hMidiIn.ToString());
+ if ((ret == 0) && (item.hMidiIn != IntPtr.Zero))
+ {
+ CWin32.midiInStart(item.hMidiIn);
+ Trace.TraceInformation("MIDI In: [{0}] \"{1}\" 縺ｮ蜈･蜉帛女莉倥ｒ髢句ｧ九＠縺ｾ縺励◆縲", i, lpMidiInCaps.szPname);
+ item.strDeviceName = lpMidiInCaps.szPname;
+ this.list蜈･蜉帙ョ繝舌う繧ｹ.Add(item);
+ continue;
+ }
+ }
+ Trace.TraceError("MIDI In: [{0}] \"{1}\" 縺ｮ蜈･蜉帛女莉倥ｮ髢句ｧ九↓螟ｱ謨励＠縺ｾ縺励◆縲", i, lpMidiInCaps.szPname);
+ }
+ }
+ else
+ {
+ Trace.TraceInformation("DTXV繝｢繝ｼ繝峨ｮ縺溘ａ縲｀IDI蜈･蜉帙ｯ菴ｿ逕ｨ縺励∪縺帙ｓ縲");
+ }
+ }
+
+
+ // 繝｡繧ｽ繝繝
+
+ public IInputDevice Joystick(int ID)
+ {
+ foreach (IInputDevice device in this.list蜈･蜉帙ョ繝舌う繧ｹ)
+ {
+ if ((device.e蜈･蜉帙ョ繝舌う繧ｹ遞ｮ蛻･ == E蜈･蜉帙ョ繝舌う繧ｹ遞ｮ蛻･.Joystick) && (device.ID == ID))
+ {
+ return device;
+ }
+ }
+ return null;
+ }
+ public IInputDevice Joystick(string GUID)
+ {
+ foreach (IInputDevice device in this.list蜈･蜉帙ョ繝舌う繧ｹ)
+ {
+ if ((device.e蜈･蜉帙ョ繝舌う繧ｹ遞ｮ蛻･ == E蜈･蜉帙ョ繝舌う繧ｹ遞ｮ蛻･.Joystick) && device.GUID.Equals(GUID))
+ {
+ return device;
+ }
+ }
+ return null;
+ }
+ public IInputDevice MidiIn(int ID)
+ {
+ foreach (IInputDevice device in this.list蜈･蜉帙ョ繝舌う繧ｹ)
+ {
+ if ((device.e蜈･蜉帙ョ繝舌う繧ｹ遞ｮ蛻･ == E蜈･蜉帙ョ繝舌う繧ｹ遞ｮ蛻･.MidiIn) && (device.ID == ID))
+ {
+ return device;
+ }
+ }
+ return null;
+ }
+ public void t繝昴ｼ繝ｪ繝ｳ繧ｰ(bool bWindow縺後い繧ｯ繝繧｣繝紋ｸｭ, bool b繝舌ャ繝輔ぃ蜈･蜉帙ｒ菴ｿ逕ｨ縺吶ｋ)
+ {
+ lock (this.objMidiIn謗剃ｻ也畑)
+ {
+ // foreach( IInputDevice device in this.list蜈･蜉帙ョ繝舌う繧ｹ )
+ for (int i = this.list蜈･蜉帙ョ繝舌う繧ｹ.Count - 1; i >= 0; i--) // #24016 2011.1.6 yyagi: change not to use "foreach" to avoid InvalidOperation exception by Remove().
+ {
+ IInputDevice device = this.list蜈･蜉帙ョ繝舌う繧ｹ[i];
+ try
+ {
+ device.t繝昴ｼ繝ｪ繝ｳ繧ｰ(bWindow縺後い繧ｯ繝繧｣繝紋ｸｭ, b繝舌ャ繝輔ぃ蜈･蜉帙ｒ菴ｿ逕ｨ縺吶ｋ);
+ }
+ catch (SharpDX.SharpDXException e) // #24016 2011.1.6 yyagi: catch exception for unplugging USB joystick, and remove the device object from the polling items.
+ {
+ if (e.ResultCode == ResultCode.OtherApplicationHasPriority)
+ {
+ // #xxxxx: 2017.5.9: from: 縺薙ｮ繧ｨ繝ｩ繝ｼ縺ｮ譎ゅｯ縲∽ｽ輔ｂ縺励↑縺縲
+ }
+ else
+ {
+ // #xxxxx: 2017.5.9: from: 縺昴ｮ莉悶ｮ繧ｨ繝ｩ繝ｼ縺ｮ蝣ｴ蜷医ｯ縲√ョ繝舌う繧ｹ縺悟､悶＆繧後◆縺ｨ諠ｳ螳壹＠縺ｦRemove縺吶ｋ縲
+ this.list蜈･蜉帙ョ繝舌う繧ｹ.Remove(device);
+ device.Dispose();
+ Trace.TraceError("t繝昴ｼ繝ｪ繝ｳ繧ｰ譎ゅ↓蟇ｾ雎｡device縺梧栢縺九ｌ縺ｦ縺翫ｊ萓句､也匱逕溘ょ酔device繧偵昴ｼ繝ｪ繝ｳ繧ｰ蟇ｾ雎｡縺九ｉRemove縺励∪縺励◆縲");
+ }
+ }
+ }
+ }
+ }
+
+ #region [ IDisposableｼ勤ｱ ]
+ //-----------------
+ public void Dispose()
+ {
+ this.Dispose(true);
+ }
+ public void Dispose(bool disposeManagedObjects)
+ {
+ if (!this.bDisposed貂医∩)
+ {
+ if (disposeManagedObjects)
+ {
+ foreach (IInputDevice device in this.list蜈･蜉帙ョ繝舌う繧ｹ)
+ {
+ CInputMIDI tmidi = device as CInputMIDI;
+ if (tmidi != null)
+ {
+ CWin32.midiInStop(tmidi.hMidiIn);
+ CWin32.midiInReset(tmidi.hMidiIn);
+ CWin32.midiInClose(tmidi.hMidiIn);
+ Trace.TraceInformation("MIDI In: [{0}] 繧貞●豁｢縺励∪縺励◆縲", new object[] { tmidi.ID });
+ }
+ }
+ foreach (IInputDevice device2 in this.list蜈･蜉帙ョ繝舌う繧ｹ)
+ {
+ device2.Dispose();
+ }
+ lock (this.objMidiIn謗剃ｻ也畑)
+ {
+ this.list蜈･蜉帙ョ繝舌う繧ｹ.Clear();
+ }
+
+ this.directInput.Dispose();
+
+ //if( this.timer != null )
+ //{
+ // this.timer.Dispose();
+ // this.timer = null;
+ //}
+ }
+ this.bDisposed貂医∩ = true;
+ }
+ }
+ ~CInput邂｡逅()
+ {
+ this.Dispose(false);
+ GC.KeepAlive(this);
+ }
+ //-----------------
+ #endregion
+
+
+ // 縺昴ｮ莉
+
+ #region [ private ]
+ //-----------------
+ private DirectInput directInput;
+ private IInputDevice _Keyboard;
+ private IInputDevice _Mouse;
+ private bool bDisposed貂医∩;
+ private List listHMIDIIN = new List(8);
+ private object objMidiIn謗剃ｻ也畑 = new object();
+ private CWin32.MidiInProc proc;
+ //private CTimer timer;
+
+ private void MidiInCallback(IntPtr hMidiIn, uint wMsg, IntPtr dwInstance, IntPtr dwParam1, IntPtr dwParam2)
+ {
+ int p = (int)dwParam1 & 0xF0;
+ if (wMsg != CWin32.MIM_DATA || (p != 0x80 && p != 0x90 && p != 0xB0))
+ return;
+
+ long time = CSound邂｡逅.rc貍泌･冗畑繧ｿ繧､繝.n繧ｷ繧ｹ繝繝譎ょ綾; // lock蜑阪↓蜿門ｾ励よｼ泌･冗畑繧ｿ繧､繝槭→蜷後§繧ｿ繧､繝槭ｒ菴ｿ縺縺薙→縺ｧ縲。GM縺ｨ隴憺擇縲∝･蜉帙★繧後ｒ髦ｲ縺舌
+ lock (this.objMidiIn謗剃ｻ也畑)
+ {
+ if ((this.list蜈･蜉帙ョ繝舌う繧ｹ != null) && (this.list蜈･蜉帙ョ繝舌う繧ｹ.Count != 0))
+ {
+ foreach (IInputDevice device in this.list蜈･蜉帙ョ繝舌う繧ｹ)
+ {
+ CInputMIDI tmidi = device as CInputMIDI;
+ if ((tmidi != null) && (tmidi.hMidiIn == hMidiIn))
+ {
+ tmidi.t繝｡繝繧ｻ繝ｼ繧ｸ縺九ｉMIDI菫｡蜿ｷ縺ｮ縺ｿ蜿嶺ｿ｡(wMsg, dwInstance, dwParam1, dwParam2, time);
+ break;
+ }
+ }
+ }
+ }
+ }
+ //-----------------
+ #endregion
+ }
+}
diff --git a/FDK19/繧ｳ繝ｼ繝/02.蜈･蜉/DeviceConstantConverter.cs b/FDK19/繧ｳ繝ｼ繝/02.蜈･蜉/DeviceConstantConverter.cs
new file mode 100644
index 00000000..0228a86b
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/02.蜈･蜉/DeviceConstantConverter.cs
@@ -0,0 +1,1666 @@
+ｻｿusing System;
+using System.Collections.Generic;
+using System.Text;
+using System.Windows.Forms;
+using SlimDXKeys;
+
+using WindowsKey = System.Windows.Forms.Keys;
+using SlimDXKey = SlimDXKeys.Key;
+using SharpDXKey = SharpDX.DirectInput.Key;
+
+namespace FDK
+{
+ public class DeviceConstantConverter
+ {
+ // 繝｡繧ｽ繝繝
+
+ public static Key DIKtoKey( int dik )
+ {
+ switch( dik )
+ {
+ case 1:
+ return Key.Escape;
+
+ case 2:
+ return Key.D1;
+
+ case 3:
+ return Key.D2;
+
+ case 4:
+ return Key.D3;
+
+ case 5:
+ return Key.D4;
+
+ case 6:
+ return Key.D5;
+
+ case 7:
+ return Key.D6;
+
+ case 8:
+ return Key.D7;
+
+ case 9:
+ return Key.D8;
+
+ case 10:
+ return Key.D9;
+
+ case 11:
+ return Key.D0;
+
+ case 12:
+ return Key.Minus;
+
+ case 13:
+ return Key.Equals;
+
+ case 14:
+ return Key.Backspace;
+
+ case 15:
+ return Key.Tab;
+
+ case 0x10:
+ return Key.Q;
+
+ case 0x11:
+ return Key.W;
+
+ case 0x12:
+ return Key.E;
+
+ case 0x13:
+ return Key.R;
+
+ case 20:
+ return Key.T;
+
+ case 0x15:
+ return Key.Y;
+
+ case 0x16:
+ return Key.U;
+
+ case 0x17:
+ return Key.I;
+
+ case 0x18:
+ return Key.O;
+
+ case 0x19:
+ return Key.P;
+
+ case 0x1a:
+ return Key.LeftBracket;
+
+ case 0x1b:
+ return Key.RightBracket;
+
+ case 0x1c:
+ return Key.Return;
+
+ case 0x1d:
+ return Key.LeftControl;
+
+ case 30:
+ return Key.A;
+
+ case 0x1f:
+ return Key.S;
+
+ case 0x20:
+ return Key.D;
+
+ case 0x21:
+ return Key.F;
+
+ case 0x22:
+ return Key.G;
+
+ case 0x23:
+ return Key.H;
+
+ case 0x24:
+ return Key.J;
+
+ case 0x25:
+ return Key.K;
+
+ case 0x26:
+ return Key.L;
+
+ case 0x27:
+ return Key.Semicolon;
+
+ case 40:
+ return Key.Apostrophe;
+
+ case 0x29:
+ return Key.Grave;
+
+ case 0x2a:
+ return Key.LeftShift;
+
+ case 0x2b:
+ return Key.Backslash;
+
+ case 0x2c:
+ return Key.Z;
+
+ case 0x2d:
+ return Key.X;
+
+ case 0x2e:
+ return Key.C;
+
+ case 0x2f:
+ return Key.V;
+
+ case 0x30:
+ return Key.B;
+
+ case 0x31:
+ return Key.N;
+
+ case 50:
+ return Key.M;
+
+ case 0x33:
+ return Key.Comma;
+
+ case 0x34:
+ return Key.Period;
+
+ case 0x35:
+ return Key.Slash;
+
+ case 0x36:
+ return Key.RightShift;
+
+ case 0x37:
+ return Key.NumberPadStar;
+
+ case 0x38:
+ return Key.LeftAlt;
+
+ case 0x39:
+ return Key.Space;
+
+ case 0x3a:
+ return Key.CapsLock;
+
+ case 0x3b:
+ return Key.F1;
+
+ case 60:
+ return Key.F2;
+
+ case 0x3d:
+ return Key.F3;
+
+ case 0x3e:
+ return Key.F4;
+
+ case 0x3f:
+ return Key.F5;
+
+ case 0x40:
+ return Key.F6;
+
+ case 0x41:
+ return Key.F7;
+
+ case 0x42:
+ return Key.F8;
+
+ case 0x43:
+ return Key.F9;
+
+ case 0x44:
+ return Key.F10;
+
+ case 0x45:
+ return Key.NumberLock;
+
+ case 70:
+ return Key.ScrollLock;
+
+ case 0x47:
+ return Key.NumberPad7;
+
+ case 0x48:
+ return Key.NumberPad8;
+
+ case 0x49:
+ return Key.NumberPad9;
+
+ case 0x4a:
+ return Key.NumberPadMinus;
+
+ case 0x4b:
+ return Key.NumberPad4;
+
+ case 0x4c:
+ return Key.NumberPad5;
+
+ case 0x4d:
+ return Key.NumberPad6;
+
+ case 0x4e:
+ return Key.NumberPadPlus;
+
+ case 0x4f:
+ return Key.NumberPad1;
+
+ case 80:
+ return Key.NumberPad2;
+
+ case 0x51:
+ return Key.NumberPad3;
+
+ case 0x52:
+ return Key.NumberPad0;
+
+ case 0x53:
+ return Key.NumberPadPeriod;
+
+ case 0x56:
+ return Key.Oem102;
+
+ case 0x57:
+ return Key.F11;
+
+ case 0x58:
+ return Key.F12;
+
+ case 100:
+ return Key.F13;
+
+ case 0x65:
+ return Key.F14;
+
+ case 0x66:
+ return Key.F15;
+
+ case 0x70:
+ return Key.Kana;
+
+ case 0x73:
+ return Key.AbntC1;
+
+ case 0x79:
+ return Key.Convert;
+
+ case 0x7b:
+ return Key.NoConvert;
+
+ case 0x7d:
+ return Key.Yen;
+
+ case 0x7e:
+ return Key.AbntC2;
+
+ case 0x8d:
+ return Key.NumberPadEquals;
+
+ case 0x90:
+ return Key.PreviousTrack;
+
+ case 0x91:
+ return Key.AT;
+
+ case 0x92:
+ return Key.Colon;
+
+ case 0x93:
+ return Key.Underline;
+
+ case 0x94:
+ return Key.Kanji;
+
+ case 0x95:
+ return Key.Stop;
+
+ case 150:
+ return Key.AX;
+
+ case 0x97:
+ return Key.Unlabeled;
+
+ case 0x99:
+ return Key.NextTrack;
+
+ case 0x9c:
+ return Key.NumberPadEnter;
+
+ case 0x9d:
+ return Key.RightControl;
+
+ case 160:
+ return Key.Mute;
+
+ case 0xa1:
+ return Key.Calculator;
+
+ case 0xa2:
+ return Key.PlayPause;
+
+ case 0xa4:
+ return Key.MediaStop;
+
+ case 0xae:
+ return Key.VolumeDown;
+
+ case 0xb0:
+ return Key.VolumeUp;
+
+ case 0xb2:
+ return Key.WebHome;
+
+ case 0xb3:
+ return Key.NumberPadComma;
+
+ case 0xb5:
+ return Key.NumberPadSlash;
+
+ case 0xb7:
+ return Key.PrintScreen;
+
+ case 0xb8:
+ return Key.RightAlt;
+
+ case 0xc5:
+ return Key.Pause;
+
+ case 0xc7:
+ return Key.Home;
+
+ case 200:
+ return Key.UpArrow;
+
+ case 0xc9:
+ return Key.PageUp;
+
+ case 0xcb:
+ return Key.LeftArrow;
+
+ case 0xcd:
+ return Key.RightArrow;
+
+ case 0xcf:
+ return Key.End;
+
+ case 0xd0:
+ return Key.DownArrow;
+
+ case 0xd1:
+ return Key.PageDown;
+
+ case 210:
+ return Key.Insert;
+
+ case 0xd3:
+ return Key.Delete;
+
+ case 0xdb:
+ return Key.LeftWindowsKey;
+
+ case 220:
+ return Key.RightWindowsKey;
+
+ case 0xdd:
+ return Key.Applications;
+
+ case 0xde:
+ return Key.Power;
+
+ case 0xdf:
+ return Key.Sleep;
+
+ case 0xe3:
+ return Key.Wake;
+
+ case 0xe5:
+ return Key.WebSearch;
+
+ case 230:
+ return Key.WebFavorites;
+
+ case 0xe7:
+ return Key.WebRefresh;
+
+ case 0xe8:
+ return Key.WebStop;
+
+ case 0xe9:
+ return Key.WebForward;
+
+ case 0xea:
+ return Key.WebBack;
+
+ case 0xeb:
+ return Key.MyComputer;
+
+ case 0xec:
+ return Key.Mail;
+
+ case 0xed:
+ return Key.MediaSelect;
+ }
+ return Key.Unknown;
+ }
+ public static int KeyToDIK( Key key )
+ {
+ switch( key )
+ {
+ case Key.D0:
+ return 11;
+
+ case Key.D1:
+ return 2;
+
+ case Key.D2:
+ return 3;
+
+ case Key.D3:
+ return 4;
+
+ case Key.D4:
+ return 5;
+
+ case Key.D5:
+ return 6;
+
+ case Key.D6:
+ return 7;
+
+ case Key.D7:
+ return 8;
+
+ case Key.D8:
+ return 9;
+
+ case Key.D9:
+ return 10;
+
+ case Key.A:
+ return 30;
+
+ case Key.B:
+ return 0x30;
+
+ case Key.C:
+ return 0x2e;
+
+ case Key.D:
+ return 0x20;
+
+ case Key.E:
+ return 0x12;
+
+ case Key.F:
+ return 0x21;
+
+ case Key.G:
+ return 0x22;
+
+ case Key.H:
+ return 0x23;
+
+ case Key.I:
+ return 0x17;
+
+ case Key.J:
+ return 0x24;
+
+ case Key.K:
+ return 0x25;
+
+ case Key.L:
+ return 0x26;
+
+ case Key.M:
+ return 50;
+
+ case Key.N:
+ return 0x31;
+
+ case Key.O:
+ return 0x18;
+
+ case Key.P:
+ return 0x19;
+
+ case Key.Q:
+ return 0x10;
+
+ case Key.R:
+ return 0x13;
+
+ case Key.S:
+ return 0x1f;
+
+ case Key.T:
+ return 20;
+
+ case Key.U:
+ return 0x16;
+
+ case Key.V:
+ return 0x2f;
+
+ case Key.W:
+ return 0x11;
+
+ case Key.X:
+ return 0x2d;
+
+ case Key.Y:
+ return 0x15;
+
+ case Key.Z:
+ return 0x2c;
+
+ case Key.AbntC1:
+ return 0x73;
+
+ case Key.AbntC2:
+ return 0x7e;
+
+ case Key.Apostrophe:
+ return 40;
+
+ case Key.Applications:
+ return 0xdd;
+
+ case Key.AT:
+ return 0x91;
+
+ case Key.AX:
+ return 150;
+
+ case Key.Backspace:
+ return 14;
+
+ case Key.Backslash:
+ return 0x2b;
+
+ case Key.Calculator:
+ return 0xa1;
+
+ case Key.CapsLock:
+ return 0x3a;
+
+ case Key.Colon:
+ return 0x92;
+
+ case Key.Comma:
+ return 0x33;
+
+ case Key.Convert:
+ return 0x79;
+
+ case Key.Delete:
+ return 0xd3;
+
+ case Key.DownArrow:
+ return 0xd0;
+
+ case Key.End:
+ return 0xcf;
+
+ case Key.Equals:
+ return 13;
+
+ case Key.Escape:
+ return 1;
+
+ case Key.F1:
+ return 0x3b;
+
+ case Key.F2:
+ return 60;
+
+ case Key.F3:
+ return 0x3d;
+
+ case Key.F4:
+ return 0x3e;
+
+ case Key.F5:
+ return 0x3f;
+
+ case Key.F6:
+ return 0x40;
+
+ case Key.F7:
+ return 0x41;
+
+ case Key.F8:
+ return 0x42;
+
+ case Key.F9:
+ return 0x43;
+
+ case Key.F10:
+ return 0x44;
+
+ case Key.F11:
+ return 0x57;
+
+ case Key.F12:
+ return 0x58;
+
+ case Key.F13:
+ return 100;
+
+ case Key.F14:
+ return 0x65;
+
+ case Key.F15:
+ return 0x66;
+
+ case Key.Grave:
+ return 0x29;
+
+ case Key.Home:
+ return 0xc7;
+
+ case Key.Insert:
+ return 210;
+
+ case Key.Kana:
+ return 0x70;
+
+ case Key.Kanji:
+ return 0x94;
+
+ case Key.LeftBracket:
+ return 0x1a;
+
+ case Key.LeftControl:
+ return 0x1d;
+
+ case Key.LeftArrow:
+ return 0xcb;
+
+ case Key.LeftAlt:
+ return 0x38;
+
+ case Key.LeftShift:
+ return 0x2a;
+
+ case Key.LeftWindowsKey:
+ return 0xdb;
+
+ case Key.Mail:
+ return 0xec;
+
+ case Key.MediaSelect:
+ return 0xed;
+
+ case Key.MediaStop:
+ return 0xa4;
+
+ case Key.Minus:
+ return 12;
+
+ case Key.Mute:
+ return 160;
+
+ case Key.MyComputer:
+ return 0xeb;
+
+ case Key.NextTrack:
+ return 0x99;
+
+ case Key.NoConvert:
+ return 0x7b;
+
+ case Key.NumberLock:
+ return 0x45;
+
+ case Key.NumberPad0:
+ return 0x52;
+
+ case Key.NumberPad1:
+ return 0x4f;
+
+ case Key.NumberPad2:
+ return 80;
+
+ case Key.NumberPad3:
+ return 0x51;
+
+ case Key.NumberPad4:
+ return 0x4b;
+
+ case Key.NumberPad5:
+ return 0x4c;
+
+ case Key.NumberPad6:
+ return 0x4d;
+
+ case Key.NumberPad7:
+ return 0x47;
+
+ case Key.NumberPad8:
+ return 0x48;
+
+ case Key.NumberPad9:
+ return 0x49;
+
+ case Key.NumberPadComma:
+ return 0xb3;
+
+ case Key.NumberPadEnter:
+ return 0x9c;
+
+ case Key.NumberPadEquals:
+ return 0x8d;
+
+ case Key.NumberPadMinus:
+ return 0x4a;
+
+ case Key.NumberPadPeriod:
+ return 0x53;
+
+ case Key.NumberPadPlus:
+ return 0x4e;
+
+ case Key.NumberPadSlash:
+ return 0xb5;
+
+ case Key.NumberPadStar:
+ return 0x37;
+
+ case Key.Oem102:
+ return 0x56;
+
+ case Key.PageDown:
+ return 0xd1;
+
+ case Key.PageUp:
+ return 0xc9;
+
+ case Key.Pause:
+ return 0xc5;
+
+ case Key.Period:
+ return 0x34;
+
+ case Key.PlayPause:
+ return 0xa2;
+
+ case Key.Power:
+ return 0xde;
+
+ case Key.PreviousTrack:
+ return 0x90;
+
+ case Key.RightBracket:
+ return 0x1b;
+
+ case Key.RightControl:
+ return 0x9d;
+
+ case Key.Return:
+ return 0x1c;
+
+ case Key.RightArrow:
+ return 0xcd;
+
+ case Key.RightAlt:
+ return 0xb8;
+
+ case Key.RightShift:
+ return 0x36;
+
+ case Key.RightWindowsKey:
+ return 220;
+
+ case Key.ScrollLock:
+ return 70;
+
+ case Key.Semicolon:
+ return 0x27;
+
+ case Key.Slash:
+ return 0x35;
+
+ case Key.Sleep:
+ return 0xdf;
+
+ case Key.Space:
+ return 0x39;
+
+ case Key.Stop:
+ return 0x95;
+
+ case Key.PrintScreen:
+ return 0xb7;
+
+ case Key.Tab:
+ return 15;
+
+ case Key.Underline:
+ return 0x93;
+
+ case Key.Unlabeled:
+ return 0x97;
+
+ case Key.UpArrow:
+ return 200;
+
+ case Key.VolumeDown:
+ return 0xae;
+
+ case Key.VolumeUp:
+ return 0xb0;
+
+ case Key.Wake:
+ return 0xe3;
+
+ case Key.WebBack:
+ return 0xea;
+
+ case Key.WebFavorites:
+ return 230;
+
+ case Key.WebForward:
+ return 0xe9;
+
+ case Key.WebHome:
+ return 0xb2;
+
+ case Key.WebRefresh:
+ return 0xe7;
+
+ case Key.WebSearch:
+ return 0xe5;
+
+ case Key.WebStop:
+ return 0xe8;
+
+ case Key.Yen:
+ return 0x7d;
+ }
+ return 0;
+ }
+ public static Keys KeyToKeyCode(SlimDXKey key)
+ {
+ switch ( key )
+ {
+ case Key.D0:
+ return Keys.D0;
+
+ case Key.D1:
+ return Keys.D1;
+
+ case Key.D2:
+ return Keys.D2;
+
+ case Key.D3:
+ return Keys.D3;
+
+ case Key.D4:
+ return Keys.D4;
+
+ case Key.D5:
+ return Keys.D5;
+
+ case Key.D6:
+ return Keys.D6;
+
+ case Key.D7:
+ return Keys.D7;
+
+ case Key.D8:
+ return Keys.D8;
+
+ case Key.D9:
+ return Keys.D9;
+
+ case Key.A:
+ return Keys.A;
+
+ case Key.B:
+ return Keys.B;
+
+ case Key.C:
+ return Keys.C;
+
+ case Key.D:
+ return Keys.D;
+
+ case Key.E:
+ return Keys.E;
+
+ case Key.F:
+ return Keys.F;
+
+ case Key.G:
+ return Keys.G;
+
+ case Key.H:
+ return Keys.H;
+
+ case Key.I:
+ return Keys.I;
+
+ case Key.J:
+ return Keys.J;
+
+ case Key.K:
+ return Keys.K;
+
+ case Key.L:
+ return Keys.L;
+
+ case Key.M:
+ return Keys.M;
+
+ case Key.N:
+ return Keys.N;
+
+ case Key.O:
+ return Keys.O;
+
+ case Key.P:
+ return Keys.P;
+
+ case Key.Q:
+ return Keys.Q;
+
+ case Key.R:
+ return Keys.R;
+
+ case Key.S:
+ return Keys.S;
+
+ case Key.T:
+ return Keys.T;
+
+ case Key.U:
+ return Keys.U;
+
+ case Key.V:
+ return Keys.V;
+
+ case Key.W:
+ return Keys.W;
+
+ case Key.X:
+ return Keys.X;
+
+ case Key.Y:
+ return Keys.Y;
+
+ case Key.Z:
+ return Keys.Z;
+
+// case Key.AbntC1:
+// return Keys.A; //0x73;
+ //147
+// case Key.AbntC2:
+// return Keys.A; //0x7e;
+
+// case Key.Apostrophe:
+// return Keys.A; ///
+
+ case Key.Applications:
+ return Keys.Apps;
+
+ case Key.AT:
+ return Keys.Oem3;
+
+// case Key.AX:
+// return Keys.A; ///
+
+ case Key.Backspace:
+ return Keys.Back;
+
+ case Key.Backslash:
+ return Keys.Oem5;
+
+// case Key.Calculator:
+// return Keys.A; ///
+
+ case Key.CapsLock:
+ return Keys.CapsLock;
+
+ case Key.Colon:
+ return Keys.Oem1;
+
+ case Key.Comma:
+ return Keys.Oemcomma;
+
+ case Key.Convert:
+ return Keys.IMEConvert;
+
+ case Key.Delete:
+ return Keys.Delete;
+
+ case Key.DownArrow:
+ return Keys.Down;
+
+ case Key.End:
+ return Keys.End;
+
+ case Key.Equals:
+ return Keys.A; ///
+
+ case Key.Escape:
+ return Keys.Escape;
+
+ case Key.F1:
+ return Keys.F1;
+
+ case Key.F2:
+ return Keys.F2;
+
+ case Key.F3:
+ return Keys.F3;
+
+ case Key.F4:
+ return Keys.F4;
+
+ case Key.F5:
+ return Keys.F5;
+
+ case Key.F6:
+ return Keys.F6;
+
+ case Key.F7:
+ return Keys.F7;
+
+ case Key.F8:
+ return Keys.F8;
+
+ case Key.F9:
+ return Keys.F9;
+
+ case Key.F10:
+ return Keys.F10;
+
+ case Key.F11:
+ return Keys.F11;
+
+ case Key.F12:
+ return Keys.F12;
+
+ case Key.F13:
+ return Keys.F13;
+
+ case Key.F14:
+ return Keys.F14;
+
+ case Key.F15:
+ return Keys.F15;
+
+ case Key.Grave:
+ return Keys.A; ///
+
+ case Key.Home:
+ return Keys.Home;
+
+ case Key.Insert:
+ return Keys.Insert;
+
+ case Key.Kana:
+ return Keys.KanaMode;
+
+ case Key.Kanji:
+ return Keys.KanjiMode;
+
+ case Key.LeftBracket:
+ return Keys.Oem4;
+
+ case Key.LeftControl:
+ return Keys.LControlKey;
+
+ case Key.LeftArrow:
+ return Keys.Left;
+
+ case Key.LeftAlt:
+ return Keys.LMenu;
+
+ case Key.LeftShift:
+ return Keys.LShiftKey;
+
+ case Key.LeftWindowsKey:
+ return Keys.LWin;
+
+ case Key.Mail:
+ return Keys.LaunchMail;
+
+ case Key.MediaSelect:
+ return Keys.SelectMedia;
+
+ case Key.MediaStop:
+ return Keys.MediaStop;
+
+ case Key.Minus:
+ return Keys.OemMinus;
+
+ case Key.Mute:
+ return Keys.VolumeMute;
+
+ case Key.MyComputer: ///
+ return Keys.A;
+
+ case Key.NextTrack:
+ return Keys.MediaNextTrack;
+
+ case Key.NoConvert:
+ return Keys.IMENonconvert;
+
+ case Key.NumberLock:
+ return Keys.NumLock;
+
+ case Key.NumberPad0:
+ return Keys.NumPad0;
+
+ case Key.NumberPad1:
+ return Keys.NumPad1;
+
+ case Key.NumberPad2:
+ return Keys.NumPad2;
+
+ case Key.NumberPad3:
+ return Keys.NumPad3;
+
+ case Key.NumberPad4:
+ return Keys.NumPad4;
+
+ case Key.NumberPad5:
+ return Keys.NumPad5;
+
+ case Key.NumberPad6:
+ return Keys.NumPad6;
+
+ case Key.NumberPad7:
+ return Keys.NumPad7;
+
+ case Key.NumberPad8:
+ return Keys.NumPad8;
+
+ case Key.NumberPad9:
+ return Keys.NumPad9;
+
+ case Key.NumberPadComma:
+ return Keys.Separator;
+
+ case Key.NumberPadEnter:
+ return Keys.A; //
+
+ case Key.NumberPadEquals:
+ return Keys.A; //
+
+ case Key.NumberPadMinus:
+ return Keys.Subtract;
+
+ case Key.NumberPadPeriod:
+ return Keys.Decimal;
+
+ case Key.NumberPadPlus:
+ return Keys.Add;
+
+ case Key.NumberPadSlash:
+ return Keys.Divide;
+
+ case Key.NumberPadStar:
+ return Keys.Multiply; //
+
+ case Key.Oem102:
+ return Keys.Oem102;
+
+ case Key.PageDown:
+ return Keys.PageDown;
+
+ case Key.PageUp:
+ return Keys.PageUp;
+
+ case Key.Pause:
+ return Keys.Pause;
+
+ case Key.Period:
+ return Keys.OemPeriod;
+
+ case Key.PlayPause:
+ return Keys.MediaPlayPause;
+
+ case Key.Power:
+ return Keys.A; ///
+
+ case Key.PreviousTrack:
+ return Keys.MediaPreviousTrack;
+
+ case Key.RightBracket:
+ return Keys.Oem6;
+
+ case Key.RightControl:
+ return Keys.RControlKey;
+
+ case Key.Return:
+ return Keys.Return;
+
+ case Key.RightArrow:
+ return Keys.Right;
+
+ case Key.RightAlt:
+ return Keys.RMenu;
+
+ case Key.RightShift:
+ return Keys.A;
+
+ case Key.RightWindowsKey:
+ return Keys.RWin;
+
+ case Key.ScrollLock:
+ return Keys.Scroll;
+
+ case Key.Semicolon:
+ return Keys.Oemplus; ///??
+
+ case Key.Slash:
+ return Keys.Oem2;
+
+ case Key.Sleep:
+ return Keys.Sleep;
+
+ case Key.Space:
+ return Keys.Space;
+
+ case Key.Stop:
+ return Keys.MediaStop;
+
+ case Key.PrintScreen:
+ return Keys.PrintScreen;
+
+ case Key.Tab:
+ return Keys.Tab;
+
+ case Key.Underline:
+ return Keys.Oem102;
+
+// case Key.Unlabeled: ///
+// return Keys.A;
+
+ case Key.UpArrow:
+ return Keys.Up;
+
+ case Key.VolumeDown:
+ return Keys.VolumeDown;
+
+ case Key.VolumeUp:
+ return Keys.VolumeUp;
+
+ case Key.Wake:
+ return Keys.A; ///
+
+ case Key.WebBack:
+ return Keys.BrowserBack;
+
+ case Key.WebFavorites:
+ return Keys.BrowserFavorites;
+
+ case Key.WebForward:
+ return Keys.BrowserForward;
+
+ case Key.WebHome:
+ return Keys.BrowserHome;
+
+ case Key.WebRefresh:
+ return Keys.BrowserRefresh;
+
+ case Key.WebSearch:
+ return Keys.BrowserSearch;
+
+ case Key.WebStop:
+ return Keys.BrowserStop;
+
+ case Key.Yen:
+ return Keys.OemBackslash;
+ }
+ return 0;
+ }
+
+ ///
+ /// 蟇ｾ蠢懊☆繧句､縺後↑縺代ｌ縺ｰ SlimDX.DirectInput.Unknown 繧定ｿ斐☆縲
+ ///
+ public static SlimDXKey DIKtoKey(SharpDXKey key)
+ {
+ if (_DIKtoKey.ContainsKey(key))
+ {
+ return _DIKtoKey[key];
+ }
+ else
+ {
+ return SlimDXKey.Unknown;
+ }
+ }
+
+ ///
+ /// 蟇ｾ蠢懊☆繧句､縺後↑縺代ｌ縺ｰ System.Windows.Forms.Keys.None 繧定ｿ斐☆縲
+ ///
+ public static WindowsKey KeyToKeys(SlimDXKey key)
+ {
+ if (_KeyToKeys.ContainsKey(key))
+ {
+ return _KeyToKeys[key];
+ }
+ else
+ {
+ return WindowsKey.None;
+ }
+ }
+
+
+ ///
+ /// DIK (SharpDX.DirectInput.Key) 縺九ｉ SlimDX.DirectInput.Key 縺ｸ縺ｮ螟画鋤陦ｨ縲
+ ///
+ private static readonly Dictionary _DIKtoKey = new Dictionary() {
+ #region [ *** ]
+ { SharpDXKey.Unknown, SlimDXKey.Unknown },
+ { SharpDXKey.Escape, SlimDXKey.Escape },
+ { SharpDXKey.D1, SlimDXKey.D1 },
+ { SharpDXKey.D2, SlimDXKey.D2 },
+ { SharpDXKey.D3, SlimDXKey.D3 },
+ { SharpDXKey.D4, SlimDXKey.D4 },
+ { SharpDXKey.D5, SlimDXKey.D5 },
+ { SharpDXKey.D6, SlimDXKey.D6 },
+ { SharpDXKey.D7, SlimDXKey.D7 },
+ { SharpDXKey.D8, SlimDXKey.D8 },
+ { SharpDXKey.D9, SlimDXKey.D9 },
+ { SharpDXKey.D0, SlimDXKey.D0 },
+ { SharpDXKey.Minus, SlimDXKey.Minus },
+ { SharpDXKey.Equals, SlimDXKey.Equals },
+ { SharpDXKey.Back, SlimDXKey.Backspace },
+ { SharpDXKey.Tab, SlimDXKey.Tab },
+ { SharpDXKey.Q, SlimDXKey.Q },
+ { SharpDXKey.W, SlimDXKey.W },
+ { SharpDXKey.E, SlimDXKey.E },
+ { SharpDXKey.R, SlimDXKey.R },
+ { SharpDXKey.T, SlimDXKey.T },
+ { SharpDXKey.Y, SlimDXKey.Y },
+ { SharpDXKey.U, SlimDXKey.U },
+ { SharpDXKey.I, SlimDXKey.I },
+ { SharpDXKey.O, SlimDXKey.O },
+ { SharpDXKey.P, SlimDXKey.P },
+ { SharpDXKey.LeftBracket, SlimDXKey.LeftBracket },
+ { SharpDXKey.RightBracket, SlimDXKey.RightBracket },
+ { SharpDXKey.Return, SlimDXKey.Return },
+ { SharpDXKey.LeftControl, SlimDXKey.LeftControl },
+ { SharpDXKey.A, SlimDXKey.A },
+ { SharpDXKey.S, SlimDXKey.S },
+ { SharpDXKey.D, SlimDXKey.D },
+ { SharpDXKey.F, SlimDXKey.F },
+ { SharpDXKey.G, SlimDXKey.G },
+ { SharpDXKey.H, SlimDXKey.H },
+ { SharpDXKey.J, SlimDXKey.J },
+ { SharpDXKey.K, SlimDXKey.K },
+ { SharpDXKey.L, SlimDXKey.L },
+ { SharpDXKey.Semicolon, SlimDXKey.Semicolon },
+ { SharpDXKey.Apostrophe, SlimDXKey.Apostrophe },
+ { SharpDXKey.Grave, SlimDXKey.Grave },
+ { SharpDXKey.LeftShift, SlimDXKey.LeftShift },
+ { SharpDXKey.Backslash, SlimDXKey.Backslash },
+ { SharpDXKey.Z, SlimDXKey.Z },
+ { SharpDXKey.X, SlimDXKey.X },
+ { SharpDXKey.C, SlimDXKey.C },
+ { SharpDXKey.V, SlimDXKey.V },
+ { SharpDXKey.B, SlimDXKey.B },
+ { SharpDXKey.N, SlimDXKey.N },
+ { SharpDXKey.M, SlimDXKey.M },
+ { SharpDXKey.Comma, SlimDXKey.Comma },
+ { SharpDXKey.Period, SlimDXKey.Period },
+ { SharpDXKey.Slash, SlimDXKey.Slash },
+ { SharpDXKey.RightShift, SlimDXKey.RightShift },
+ { SharpDXKey.Multiply, SlimDXKey.NumberPadStar },
+ { SharpDXKey.LeftAlt, SlimDXKey.LeftAlt },
+ { SharpDXKey.Space, SlimDXKey.Space },
+ { SharpDXKey.Capital, SlimDXKey.CapsLock },
+ { SharpDXKey.F1, SlimDXKey.F1 },
+ { SharpDXKey.F2, SlimDXKey.F2 },
+ { SharpDXKey.F3, SlimDXKey.F3 },
+ { SharpDXKey.F4, SlimDXKey.F4 },
+ { SharpDXKey.F5, SlimDXKey.F5 },
+ { SharpDXKey.F6, SlimDXKey.F6 },
+ { SharpDXKey.F7, SlimDXKey.F7 },
+ { SharpDXKey.F8, SlimDXKey.F8 },
+ { SharpDXKey.F9, SlimDXKey.F9 },
+ { SharpDXKey.F10, SlimDXKey.F10 },
+ { SharpDXKey.NumberLock, SlimDXKey.NumberLock },
+ { SharpDXKey.ScrollLock, SlimDXKey.ScrollLock },
+ { SharpDXKey.NumberPad7, SlimDXKey.NumberPad7 },
+ { SharpDXKey.NumberPad8, SlimDXKey.NumberPad8 },
+ { SharpDXKey.NumberPad9, SlimDXKey.NumberPad9 },
+ { SharpDXKey.Subtract, SlimDXKey.NumberPadMinus },
+ { SharpDXKey.NumberPad4, SlimDXKey.NumberPad4 },
+ { SharpDXKey.NumberPad5, SlimDXKey.NumberPad5 },
+ { SharpDXKey.NumberPad6, SlimDXKey.NumberPad6 },
+ { SharpDXKey.Add, SlimDXKey.NumberPadPlus },
+ { SharpDXKey.NumberPad1, SlimDXKey.NumberPad1 },
+ { SharpDXKey.NumberPad2, SlimDXKey.NumberPad2 },
+ { SharpDXKey.NumberPad3, SlimDXKey.NumberPad3 },
+ { SharpDXKey.NumberPad0, SlimDXKey.NumberPad0 },
+ { SharpDXKey.Decimal, SlimDXKey.NumberPadPeriod },
+ { SharpDXKey.Oem102, SlimDXKey.Oem102 },
+ { SharpDXKey.F11, SlimDXKey.F11 },
+ { SharpDXKey.F12, SlimDXKey.F12 },
+ { SharpDXKey.F13, SlimDXKey.F13 },
+ { SharpDXKey.F14, SlimDXKey.F14 },
+ { SharpDXKey.F15, SlimDXKey.F15 },
+ { SharpDXKey.Kana, SlimDXKey.Kana },
+ { SharpDXKey.AbntC1, SlimDXKey.AbntC1 },
+ { SharpDXKey.Convert, SlimDXKey.Convert },
+ { SharpDXKey.NoConvert, SlimDXKey.NoConvert },
+ { SharpDXKey.Yen, SlimDXKey.Yen },
+ { SharpDXKey.AbntC2, SlimDXKey.AbntC2 },
+ { SharpDXKey.NumberPadEquals, SlimDXKey.NumberPadEquals },
+ { SharpDXKey.PreviousTrack, SlimDXKey.PreviousTrack },
+ { SharpDXKey.AT, SlimDXKey.AT },
+ { SharpDXKey.Colon, SlimDXKey.Colon },
+ { SharpDXKey.Underline, SlimDXKey.Underline },
+ { SharpDXKey.Kanji, SlimDXKey.Kanji },
+ { SharpDXKey.Stop, SlimDXKey.Stop },
+ { SharpDXKey.AX, SlimDXKey.AX },
+ { SharpDXKey.Unlabeled, SlimDXKey.Unlabeled },
+ { SharpDXKey.NextTrack, SlimDXKey.NextTrack },
+ { SharpDXKey.NumberPadEnter, SlimDXKey.NumberPadEnter },
+ { SharpDXKey.RightControl, SlimDXKey.RightControl },
+ { SharpDXKey.Mute, SlimDXKey.Mute },
+ { SharpDXKey.Calculator, SlimDXKey.Calculator },
+ { SharpDXKey.PlayPause, SlimDXKey.PlayPause },
+ { SharpDXKey.MediaStop, SlimDXKey.MediaStop },
+ { SharpDXKey.VolumeDown, SlimDXKey.VolumeDown },
+ { SharpDXKey.VolumeUp, SlimDXKey.VolumeUp },
+ { SharpDXKey.WebHome, SlimDXKey.WebHome },
+ { SharpDXKey.PrintScreen, SlimDXKey.PrintScreen },
+ { SharpDXKey.RightAlt, SlimDXKey.RightAlt },
+ { SharpDXKey.Pause, SlimDXKey.Pause },
+ { SharpDXKey.Home, SlimDXKey.Home },
+ { SharpDXKey.Up, SlimDXKey.UpArrow },
+ { SharpDXKey.PageUp, SlimDXKey.PageUp },
+ { SharpDXKey.Left, SlimDXKey.LeftArrow },
+ { SharpDXKey.Right, SlimDXKey.RightArrow },
+ { SharpDXKey.End, SlimDXKey.End },
+ { SharpDXKey.Down, SlimDXKey.DownArrow },
+ { SharpDXKey.PageDown, SlimDXKey.PageDown },
+ { SharpDXKey.Insert, SlimDXKey.Insert },
+ { SharpDXKey.Delete, SlimDXKey.Delete },
+ { SharpDXKey.LeftWindowsKey, SlimDXKey.LeftWindowsKey },
+ { SharpDXKey.RightWindowsKey, SlimDXKey.RightWindowsKey },
+ { SharpDXKey.Applications, SlimDXKey.Applications },
+ { SharpDXKey.Power, SlimDXKey.Power },
+ { SharpDXKey.Sleep, SlimDXKey.Sleep },
+ { SharpDXKey.Wake, SlimDXKey.Wake },
+ { SharpDXKey.WebSearch, SlimDXKey.WebSearch },
+ { SharpDXKey.WebFavorites, SlimDXKey.WebFavorites },
+ { SharpDXKey.WebRefresh, SlimDXKey.WebRefresh },
+ { SharpDXKey.WebStop, SlimDXKey.WebStop },
+ { SharpDXKey.WebForward, SlimDXKey.WebForward },
+ { SharpDXKey.WebBack, SlimDXKey.WebBack },
+ { SharpDXKey.MyComputer, SlimDXKey.MyComputer },
+ { SharpDXKey.Mail, SlimDXKey.Mail },
+ { SharpDXKey.MediaSelect, SlimDXKey.MediaSelect },
+ #endregion
+ };
+
+ ///
+ /// SlimDX.DirectInput.Key 縺九ｉ System.Windows.Form.Keys 縺ｸ縺ｮ螟画鋤陦ｨ縲
+ ///
+ private static readonly Dictionary _KeyToKeys = new Dictionary() {
+ #region [ *** ]
+ { SlimDXKey.D0, WindowsKey.D0 },
+ { SlimDXKey.D1, WindowsKey.D1 },
+ { SlimDXKey.D2, WindowsKey.D2 },
+ { SlimDXKey.D3, WindowsKey.D3 },
+ { SlimDXKey.D4, WindowsKey.D4 },
+ { SlimDXKey.D5, WindowsKey.D5 },
+ { SlimDXKey.D6, WindowsKey.D6 },
+ { SlimDXKey.D7, WindowsKey.D7 },
+ { SlimDXKey.D8, WindowsKey.D8 },
+ { SlimDXKey.D9, WindowsKey.D9 },
+ { SlimDXKey.A, WindowsKey.A },
+ { SlimDXKey.B, WindowsKey.B },
+ { SlimDXKey.C, WindowsKey.C },
+ { SlimDXKey.D, WindowsKey.D },
+ { SlimDXKey.E, WindowsKey.E },
+ { SlimDXKey.F, WindowsKey.F },
+ { SlimDXKey.G, WindowsKey.G },
+ { SlimDXKey.H, WindowsKey.H },
+ { SlimDXKey.I, WindowsKey.I },
+ { SlimDXKey.J, WindowsKey.J },
+ { SlimDXKey.K, WindowsKey.K },
+ { SlimDXKey.L, WindowsKey.L },
+ { SlimDXKey.M, WindowsKey.M },
+ { SlimDXKey.N, WindowsKey.N },
+ { SlimDXKey.O, WindowsKey.O },
+ { SlimDXKey.P, WindowsKey.P },
+ { SlimDXKey.Q, WindowsKey.Q },
+ { SlimDXKey.R, WindowsKey.R },
+ { SlimDXKey.S, WindowsKey.S },
+ { SlimDXKey.T, WindowsKey.T },
+ { SlimDXKey.U, WindowsKey.U },
+ { SlimDXKey.V, WindowsKey.V },
+ { SlimDXKey.W, WindowsKey.W },
+ { SlimDXKey.X, WindowsKey.X },
+ { SlimDXKey.Y, WindowsKey.Y },
+ { SlimDXKey.Z, WindowsKey.Z },
+ //{ SlimDXKey.AbntC1, WindowsKey.A },
+ //{ SlimDXKey.AbntC2, WindowsKey.A },
+ { SlimDXKey.Apostrophe, WindowsKey.OemQuotes },
+ { SlimDXKey.Applications, WindowsKey.Apps },
+ { SlimDXKey.AT, WindowsKey.Oem3 }, // OemTilde 縺ｨ蜷悟､
+ //{ SlimDXKey.AX, WindowsKey.A }, // OemAX (225) 縺ｯ譛ｪ螳夂ｾｩ
+ { SlimDXKey.Backspace, WindowsKey.Back },
+ { SlimDXKey.Backslash, WindowsKey.OemBackslash },
+ //{ SlimDXKey.Calculator, WindowsKey.A },
+ { SlimDXKey.CapsLock, WindowsKey.CapsLock },
+ { SlimDXKey.Colon, WindowsKey.Oem1 },
+ { SlimDXKey.Comma, WindowsKey.Oemcomma },
+ { SlimDXKey.Convert, WindowsKey.IMEConvert },
+ { SlimDXKey.Delete, WindowsKey.Delete },
+ { SlimDXKey.DownArrow, WindowsKey.Down },
+ { SlimDXKey.End, WindowsKey.End },
+ { SlimDXKey.Equals, WindowsKey.A }, // ?
+ { SlimDXKey.Escape, WindowsKey.Escape },
+ { SlimDXKey.F1, WindowsKey.F1 },
+ { SlimDXKey.F2, WindowsKey.F2 },
+ { SlimDXKey.F3, WindowsKey.F3 },
+ { SlimDXKey.F4, WindowsKey.F4 },
+ { SlimDXKey.F5, WindowsKey.F5 },
+ { SlimDXKey.F6, WindowsKey.F6 },
+ { SlimDXKey.F7, WindowsKey.F7 },
+ { SlimDXKey.F8, WindowsKey.F8 },
+ { SlimDXKey.F9, WindowsKey.F9 },
+ { SlimDXKey.F10, WindowsKey.F10 },
+ { SlimDXKey.F11, WindowsKey.F11 },
+ { SlimDXKey.F12, WindowsKey.F12 },
+ { SlimDXKey.F13, WindowsKey.F13 },
+ { SlimDXKey.F14, WindowsKey.F14 },
+ { SlimDXKey.F15, WindowsKey.F15 },
+ { SlimDXKey.Grave, WindowsKey.A }, // ?
+ { SlimDXKey.Home, WindowsKey.Home },
+ { SlimDXKey.Insert, WindowsKey.Insert },
+ { SlimDXKey.Kana, WindowsKey.KanaMode },
+ { SlimDXKey.Kanji, WindowsKey.KanjiMode },
+ { SlimDXKey.LeftBracket, WindowsKey.Oem4 },
+ { SlimDXKey.LeftControl, WindowsKey.LControlKey },
+ { SlimDXKey.LeftArrow, WindowsKey.Left },
+ { SlimDXKey.LeftAlt, WindowsKey.LMenu },
+ { SlimDXKey.LeftShift, WindowsKey.LShiftKey },
+ { SlimDXKey.LeftWindowsKey, WindowsKey.LWin },
+ { SlimDXKey.Mail, WindowsKey.LaunchMail },
+ { SlimDXKey.MediaSelect, WindowsKey.SelectMedia },
+ { SlimDXKey.MediaStop, WindowsKey.MediaStop },
+ { SlimDXKey.Minus, WindowsKey.OemMinus },
+ { SlimDXKey.Mute, WindowsKey.VolumeMute },
+ { SlimDXKey.MyComputer, WindowsKey.A }, // ?
+ { SlimDXKey.NextTrack, WindowsKey.MediaNextTrack },
+ { SlimDXKey.NoConvert, WindowsKey.IMENonconvert },
+ { SlimDXKey.NumberLock, WindowsKey.NumLock },
+ { SlimDXKey.NumberPad0, WindowsKey.NumPad0 },
+ { SlimDXKey.NumberPad1, WindowsKey.NumPad1 },
+ { SlimDXKey.NumberPad2, WindowsKey.NumPad2 },
+ { SlimDXKey.NumberPad3, WindowsKey.NumPad3 },
+ { SlimDXKey.NumberPad4, WindowsKey.NumPad4 },
+ { SlimDXKey.NumberPad5, WindowsKey.NumPad5 },
+ { SlimDXKey.NumberPad6, WindowsKey.NumPad6 },
+ { SlimDXKey.NumberPad7, WindowsKey.NumPad7 },
+ { SlimDXKey.NumberPad8, WindowsKey.NumPad8 },
+ { SlimDXKey.NumberPad9, WindowsKey.NumPad9 },
+ { SlimDXKey.NumberPadComma, WindowsKey.Separator },
+ { SlimDXKey.NumberPadEnter, WindowsKey.A }, // ?
+ { SlimDXKey.NumberPadEquals, WindowsKey.A }, // ?
+ { SlimDXKey.NumberPadMinus, WindowsKey.Subtract },
+ { SlimDXKey.NumberPadPeriod, WindowsKey.Decimal },
+ { SlimDXKey.NumberPadPlus, WindowsKey.Add },
+ { SlimDXKey.NumberPadSlash, WindowsKey.Divide },
+ { SlimDXKey.NumberPadStar, WindowsKey.Multiply },
+ { SlimDXKey.Oem102, WindowsKey.Oem102 },
+ { SlimDXKey.PageDown, WindowsKey.PageDown },
+ { SlimDXKey.PageUp, WindowsKey.PageUp },
+ { SlimDXKey.Pause, WindowsKey.Pause },
+ { SlimDXKey.Period, WindowsKey.OemPeriod },
+ { SlimDXKey.PlayPause, WindowsKey.MediaPlayPause },
+ { SlimDXKey.Power, WindowsKey.A }, // ?
+ { SlimDXKey.PreviousTrack, WindowsKey.MediaPreviousTrack },
+ { SlimDXKey.RightBracket, WindowsKey.Oem6 },
+ { SlimDXKey.RightControl, WindowsKey.RControlKey },
+ { SlimDXKey.Return, WindowsKey.Return },
+ { SlimDXKey.RightArrow, WindowsKey.Right },
+ { SlimDXKey.RightAlt, WindowsKey.RMenu },
+ { SlimDXKey.RightShift, WindowsKey.A }, // ?
+ { SlimDXKey.RightWindowsKey, WindowsKey.RWin },
+ { SlimDXKey.ScrollLock, WindowsKey.Scroll },
+ { SlimDXKey.Semicolon, WindowsKey.Oemplus }, // OemSemicolon 縺倥ｃ縺ｪ縺上※ｼ
+ { SlimDXKey.Slash, WindowsKey.Oem2 },
+ { SlimDXKey.Sleep, WindowsKey.Sleep },
+ { SlimDXKey.Space, WindowsKey.Space },
+ { SlimDXKey.Stop, WindowsKey.MediaStop },
+ { SlimDXKey.PrintScreen, WindowsKey.PrintScreen },
+ { SlimDXKey.Tab, WindowsKey.Tab },
+ { SlimDXKey.Underline, WindowsKey.Oem102 },
+ //{ SlimDXKey.Unlabeled, WindowsKey.A }, // ?
+ { SlimDXKey.UpArrow, WindowsKey.Up },
+ { SlimDXKey.VolumeDown, WindowsKey.VolumeDown },
+ { SlimDXKey.VolumeUp, WindowsKey.VolumeUp },
+ { SlimDXKey.Wake, WindowsKey.A }, // ?
+ { SlimDXKey.WebBack, WindowsKey.BrowserBack },
+ { SlimDXKey.WebFavorites, WindowsKey.BrowserFavorites },
+ { SlimDXKey.WebForward, WindowsKey.BrowserForward },
+ { SlimDXKey.WebHome, WindowsKey.BrowserHome },
+ { SlimDXKey.WebRefresh, WindowsKey.BrowserRefresh },
+ { SlimDXKey.WebSearch, WindowsKey.BrowserSearch },
+ { SlimDXKey.WebStop, WindowsKey.BrowserStop },
+ { SlimDXKey.Yen, WindowsKey.OemBackslash },
+ #endregion
+ };
+ }
+}
diff --git a/FDK19/繧ｳ繝ｼ繝/02.蜈･蜉/E蜈･蜉帙ョ繝舌う繧ｹ遞ｮ蛻･.cs b/FDK19/繧ｳ繝ｼ繝/02.蜈･蜉/E蜈･蜉帙ョ繝舌う繧ｹ遞ｮ蛻･.cs
new file mode 100644
index 00000000..2109b159
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/02.蜈･蜉/E蜈･蜉帙ョ繝舌う繧ｹ遞ｮ蛻･.cs
@@ -0,0 +1,17 @@
+ｻｿusing System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace FDK
+{
+ // 螳壽焚
+
+ public enum E蜈･蜉帙ョ繝舌う繧ｹ遞ｮ蛻･
+ {
+ Keyboard,
+ Mouse,
+ Joystick,
+ MidiIn,
+ Unknown
+ }
+}
diff --git a/FDK19/繧ｳ繝ｼ繝/02.蜈･蜉/IInputDevice.cs b/FDK19/繧ｳ繝ｼ繝/02.蜈･蜉/IInputDevice.cs
new file mode 100644
index 00000000..7b42faa4
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/02.蜈･蜉/IInputDevice.cs
@@ -0,0 +1,37 @@
+ｻｿusing System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace FDK
+{
+ public interface IInputDevice : IDisposable
+ {
+ // 繝励Ο繝代ユ繧｣
+
+ E蜈･蜉帙ョ繝舌う繧ｹ遞ｮ蛻･ e蜈･蜉帙ョ繝舌う繧ｹ遞ｮ蛻･
+ {
+ get;
+ }
+ string GUID
+ {
+ get;
+ }
+ int ID
+ {
+ get;
+ }
+ List list蜈･蜉帙う繝吶Φ繝
+ {
+ get;
+ }
+
+
+ // 繝｡繧ｽ繝繝峨う繝ｳ繧ｿ繝ｼ繝輔ぉ繝ｼ繧ｹ
+
+ void t繝昴ｼ繝ｪ繝ｳ繧ｰ( bool bWindow縺後い繧ｯ繝繧｣繝紋ｸｭ, bool b繝舌ャ繝輔ぃ蜈･蜉帙ｒ菴ｿ逕ｨ縺吶ｋ );
+ bool b繧ｭ繝ｼ縺梧款縺輔ｌ縺( int nKey );
+ bool b繧ｭ繝ｼ縺梧款縺輔ｌ縺ｦ縺繧( int nKey );
+ bool b繧ｭ繝ｼ縺碁屬縺輔ｌ縺( int nKey );
+ bool b繧ｭ繝ｼ縺碁屬縺輔ｌ縺ｦ縺繧( int nKey );
+ }
+}
diff --git a/FDK19/繧ｳ繝ｼ繝/02.蜈･蜉/STInputEvent.cs b/FDK19/繧ｳ繝ｼ繝/02.蜈･蜉/STInputEvent.cs
new file mode 100644
index 00000000..1903df4f
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/02.蜈･蜉/STInputEvent.cs
@@ -0,0 +1,19 @@
+ｻｿusing System;
+using System.Collections.Generic;
+using System.Text;
+using System.Runtime.InteropServices;
+
+namespace FDK
+{
+ // 讒矩菴
+
+ [StructLayout( LayoutKind.Sequential )]
+ public struct STInputEvent
+ {
+ public int nKey { get; set; }
+ public bool b謚ｼ縺輔ｌ縺 { get; set; }
+ public bool b髮｢縺輔ｌ縺 { get; set; }
+ public long nTimeStamp { get; set; }
+ public int nVelocity { get; set; }
+ }
+}
diff --git a/FDK19/繧ｳ繝ｼ繝/02.蜈･蜉/SlimDXKeys.cs b/FDK19/繧ｳ繝ｼ繝/02.蜈･蜉/SlimDXKeys.cs
new file mode 100644
index 00000000..3a876285
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/02.蜈･蜉/SlimDXKeys.cs
@@ -0,0 +1,171 @@
+ｻｿusing System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace SlimDXKeys
+{
+ public enum Key
+ {
+ D0 = 0,
+ D1 = 1,
+ D2 = 2,
+ D3 = 3,
+ D4 = 4,
+ D5 = 5,
+ D6 = 6,
+ D7 = 7,
+ D8 = 8,
+ D9 = 9,
+ A = 10,
+ B = 11,
+ C = 12,
+ D = 13,
+ E = 14,
+ F = 15,
+ G = 16,
+ H = 17,
+ I = 18,
+ J = 19,
+ K = 20,
+ L = 21,
+ M = 22,
+ N = 23,
+ O = 24,
+ P = 25,
+ Q = 26,
+ R = 27,
+ S = 28,
+ T = 29,
+ U = 30,
+ V = 31,
+ W = 32,
+ X = 33,
+ Y = 34,
+ Z = 35,
+ AbntC1 = 36,
+ AbntC2 = 37,
+ Apostrophe = 38,
+ Applications = 39,
+ AT = 40,
+ AX = 41,
+ Backspace = 42,
+ Backslash = 43,
+ Calculator = 44,
+ CapsLock = 45,
+ Colon = 46,
+ Comma = 47,
+ Convert = 48,
+ Delete = 49,
+ DownArrow = 50,
+ End = 51,
+ Equals = 52,
+ Escape = 53,
+ F1 = 54,
+ F2 = 55,
+ F3 = 56,
+ F4 = 57,
+ F5 = 58,
+ F6 = 59,
+ F7 = 60,
+ F8 = 61,
+ F9 = 62,
+ F10 = 63,
+ F11 = 64,
+ F12 = 65,
+ F13 = 66,
+ F14 = 67,
+ F15 = 68,
+ Grave = 69,
+ Home = 70,
+ Insert = 71,
+ Kana = 72,
+ Kanji = 73,
+ LeftBracket = 74,
+ LeftControl = 75,
+ LeftArrow = 76,
+ LeftAlt = 77,
+ LeftShift = 78,
+ LeftWindowsKey = 79,
+ Mail = 80,
+ MediaSelect = 81,
+ MediaStop = 82,
+ Minus = 83,
+ Mute = 84,
+ MyComputer = 85,
+ NextTrack = 86,
+ NoConvert = 87,
+ NumberLock = 88,
+ NumberPad0 = 89,
+ NumberPad1 = 90,
+ NumberPad2 = 91,
+ NumberPad3 = 92,
+ NumberPad4 = 93,
+ NumberPad5 = 94,
+ NumberPad6 = 95,
+ NumberPad7 = 96,
+ NumberPad8 = 97,
+ NumberPad9 = 98,
+ NumberPadComma = 99,
+ NumberPadEnter = 100,
+ NumberPadEquals = 101,
+ NumberPadMinus = 102,
+ NumberPadPeriod = 103,
+ NumberPadPlus = 104,
+ NumberPadSlash = 105,
+ NumberPadStar = 106,
+ Oem102 = 107,
+ PageDown = 108,
+ PageUp = 109,
+ Pause = 110,
+ Period = 111,
+ PlayPause = 112,
+ Power = 113,
+ PreviousTrack = 114,
+ RightBracket = 115,
+ RightControl = 116,
+ Return = 117,
+ RightArrow = 118,
+ RightAlt = 119,
+ RightShift = 120,
+ RightWindowsKey = 121,
+ ScrollLock = 122,
+ Semicolon = 123,
+ Slash = 124,
+ Sleep = 125,
+ Space = 126,
+ Stop = 127,
+ PrintScreen = 128,
+ Tab = 129,
+ Underline = 130,
+ Unlabeled = 131,
+ UpArrow = 132,
+ VolumeDown = 133,
+ VolumeUp = 134,
+ Wake = 135,
+ WebBack = 136,
+ WebFavorites = 137,
+ WebForward = 138,
+ WebHome = 139,
+ WebRefresh = 140,
+ WebSearch = 141,
+ WebStop = 142,
+ Yen = 143,
+ Unknown = 144
+ }
+ public enum MouseObject
+ {
+ Button1 = 0,
+ Button2 = 1,
+ Button3 = 2,
+ Button4 = 3,
+ Button5 = 4,
+ Button6 = 5,
+ Button7 = 6,
+ Button8 = 7,
+ XAxis = 8,
+ YAxis = 9,
+ ZAxis = 10
+ }
+}
\ No newline at end of file
diff --git a/FDK19/繧ｳ繝ｼ繝/03.繧ｵ繧ｦ繝ｳ繝/CSound.cs b/FDK19/繧ｳ繝ｼ繝/03.繧ｵ繧ｦ繝ｳ繝/CSound.cs
new file mode 100644
index 00000000..ba66b6fc
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/03.繧ｵ繧ｦ繝ｳ繝/CSound.cs
@@ -0,0 +1,2052 @@
+using System;
+using System.Collections.ObjectModel;
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using FDK.ExtensionMethods;
+using SharpDX.DirectSound;
+using SharpDX.Multimedia;
+using Un4seen.Bass;
+using Un4seen.BassAsio;
+using Un4seen.BassWasapi;
+using Un4seen.Bass.AddOn.Mix;
+using Un4seen.Bass.AddOn.Fx;
+
+
+namespace FDK
+{
+ #region [ DTXMania逕ｨ諡｡蠑ｵ ]
+ public class CSound邂｡逅 // : CSound
+ {
+ private static ISoundDevice SoundDevice
+ {
+ get; set;
+ }
+ private static ESoundDeviceType SoundDeviceType
+ {
+ get; set;
+ }
+ public static CSoundTimer rc貍泌･冗畑繧ｿ繧､繝 = null;
+ public static bool bUseOSTimer = false; // OS縺ｮ繧ｿ繧､繝槭ｼ繧剃ｽｿ縺縺九，SoundTimer繧剃ｽｿ縺縺九DTXC縺ｧ縺ｯfalse, DTXMania縺ｧ縺ｯtrue縲
+ // DTXC(DirectSound)縺ｧCSoundTimer繧剃ｽｿ縺縺ｨ縲∝驛ｨ縺ｧ辟｡髻ｳ縺ｮ繝ｫ繝ｼ繝励し繧ｦ繝ｳ繝峨ｒ蜀咲函縺吶ｋ縺溘ａ
+ // 繧ｵ繧ｦ繝ｳ繝峨ョ繝舌う繧ｹ繧貞頃譛峨＠縺ｦ縺励∪縺縲〃iewer縺ｨ縺励※蜻ｼ縺ｳ蜃ｺ縺輔ｌ繧汽TXMania縺ｧ縲、SIO縺御ｽｿ縺医↑縺上↑繧九
+
+ // DTXMania蜊倅ｽ薙〒縺薙ｌ繧稚rue縺ｫ縺吶ｋ縺ｨ縲仝ASAPI/ASIO譎ゅ↓貍泌･上ち繧､繝槭ｼ縺ｨ縺励※FDK繧ｿ繧､繝槭ｼ縺ｧ縺ｯ縺ｪ縺
+ // 繧ｷ繧ｹ繝繝縺ｮ繧ｿ繧､繝槭ｼ繧剃ｽｿ縺繧医≧縺ｫ縺ｪ繧九ゅ％縺縺吶ｋ縺ｨ繧ｹ繧ｯ繝ｭ繝ｼ繝ｫ縺ｯ貊代ｉ縺九↓縺ｪ繧九′縲髻ｳ繧ｺ繝ｬ縺悟ｺ繧九°繧ゅ＠繧後↑縺縲
+
+ public static IntPtr WindowHandle;
+
+ public static bool bIsTimeStretch = false;
+
+ private static int _nMasterVolume;
+ public int nMasterVolume
+ {
+ get
+ {
+ return _nMasterVolume;
+ }
+ //get
+ //{
+ // if ( SoundDeviceType == ESoundDeviceType.ExclusiveWASAPI || SoundDeviceType == ESoundDeviceType.ASIO )
+ // {
+ // return Bass.BASS_GetConfig(BASSConfig.BASS_CONFIG_GVOL_STREAM ) / 100;
+ // }
+ // else
+ // {
+ // return 100;
+ // }
+ //}
+ //set
+ //{
+ // if ( SoundDeviceType == ESoundDeviceType.ExclusiveWASAPI )
+ // {
+ // // LINEAR縺ｧ縺ｪ縺集INDOWS(2)繧剃ｽｿ縺蠢隕√′縺ゅｋ縺後‘xclusive譎ゅｯ菴ｿ逕ｨ荳榊庄縲√∪縺溘ョ繝舌う繧ｹ蛛ｴ縺悟ｯｾ蠢懊＠縺ｦ縺ｪ縺縺ｨ菴ｿ逕ｨ荳榊庄
+ // bool b = BassWasapi.BASS_WASAPI_SetVolume( BASSWASAPIVolume.BASS_WASAPI_CURVE_LINEAR, value / 100.0f );
+ // if ( !b )
+ // {
+ // BASSError be = Bass.BASS_ErrorGetCode();
+ // Trace.TraceInformation( "WASAPI Master Volume Set Error: " + be.ToString() );
+ // }
+ // }
+ //}
+ //set
+ //{
+ // if ( SoundDeviceType == ESoundDeviceType.ExclusiveWASAPI || SoundDeviceType == ESoundDeviceType.ASIO )
+ // {
+ // bool b = Bass.BASS_SetConfig(BASSConfig.BASS_CONFIG_GVOL_STREAM, value * 100 );
+ // if ( !b )
+ // {
+ // BASSError be = Bass.BASS_ErrorGetCode();
+ // Trace.TraceInformation( "Master Volume Set Error: " + be.ToString() );
+ // }
+ // }
+ //}
+ //set
+ //{
+ // if ( SoundDeviceType == ESoundDeviceType.ExclusiveWASAPI || SoundDeviceType == ESoundDeviceType.ASIO )
+ // {
+ // var nodes = new BASS_MIXER_NODE[ 1 ] { new BASS_MIXER_NODE( 0, (float) value ) };
+ // BassMix.BASS_Mixer_ChannelSetEnvelope( SoundDevice.hMixer, BASSMIXEnvelope.BASS_MIXER_ENV_VOL, nodes );
+ // }
+ //}
+ set
+ {
+ SoundDevice.nMasterVolume = value;
+ _nMasterVolume = value;
+ }
+ }
+
+ /////
+ ///// BASS譎ゅ［p3繧偵せ繝医Μ繝ｼ繝溘Φ繧ｰ蜀咲函縺帙★縺ｫ縲√ョ繧ｳ繝ｼ繝峨＠縺殲aw wav繧偵が繝ｳ繝｡繝｢繝ｪ蜀咲函縺吶ｋ蝣ｴ蜷医ｯtrue縺ｫ縺吶ｋ縲
+ ///// 迚ｹ谿翫↑mp3繧剃ｽｿ逕ｨ譎ゅｯ繧ｷ繝ｼ繧ｯ縺御ｹｱ繧後ｋ縺ｮ縺ｧ縲∝ｿ隕√↓蠢懊§縺ｦtrue縺ｫ縺吶ｋ縺薙→縲(Config.ini縺ｮNoMP3Streaming縺ｧ險ｭ螳壼庄閭ｽ縲)
+ ///// 縺溘□縺励》rue縺ｫ縺吶ｋ縺ｨ縲√◎縺ｮ蛻蜀咲函髢句ｧ九∪縺ｧ縺ｮ譎る俣縺碁聞縺上↑繧九
+ /////
+ //public static bool bIsMP3DecodeByWindowsCodec = false;
+
+ public static int nMixing = 0;
+ public int GetMixingStreams()
+ {
+ return nMixing;
+ }
+ public static int nStreams = 0;
+ public int GetStreams()
+ {
+ return nStreams;
+ }
+ #region [ WASAPI/ASIO/DirectSound險ｭ螳壼､ ]
+ ///
+ /// WASAPI 謗剃ｻ悶Δ繝ｼ繝牙ｺ蜉帙↓縺翫¢繧句咲函驕蟒ｶ[ms]ｼ医ｮ蟶梧悍蛟､ｼ峨よ怙邨ら噪縺ｫ縺ｯ縺薙ｮ謨ｰ蛟､繧貞渕縺ｫ繝峨Λ繧､繝舌′豎ｺ螳壹☆繧具ｼ峨
+ /// 0莉･荳九ｮ蛟､繧呈欠螳壹☆繧九→縲√％縺ｮ謨ｰ蛟､縺ｯWASAPI蛻晄悄蛹匁凾縺ｫ閾ｪ蜍戊ｨｭ螳壹☆繧九よｭ｣謨ｰ繧呈欠螳壹☆繧九→縲√◎縺ｮ蛟､繧定ｨｭ螳壹＠繧医≧縺ｨ隧ｦ縺ｿ繧九
+ ///
+ public static int SoundDelayExclusiveWASAPI = 0; // SST縺ｧ縺ｯ縲50ms
+ public int GetSoundExclusiveWASAPI()
+ {
+ return SoundDelayExclusiveWASAPI;
+ }
+ public void SetSoundDelayExclusiveWASAPI( int value )
+ {
+ SoundDelayExclusiveWASAPI = value;
+ }
+ ///
+ /// WASAPI 蜈ｱ譛峨Δ繝ｼ繝牙ｺ蜉帙↓縺翫¢繧句咲函驕蟒ｶ[ms]縲ゅΘ繝ｼ繧ｶ縺梧ｱｺ螳壹☆繧九
+ ///
+ public static int SoundDelaySharedWASAPI = 100;
+ ///
+ /// 謗剃ｻ妨ASAPI繝舌ャ繝輔ぃ縺ｮ譖ｴ譁ｰ髢馴囈縲ょｺ蜉幃俣髫斐〒縺ｯ縺ｪ縺縺ｮ縺ｧ豕ｨ諢上
+ /// 竊 閾ｪ蜍戊ｨｭ螳壹＆繧後ｋ縺ｮ縺ｧSoundDelay 繧医ｊ繧ょｰ上＆縺蛟､縺ｧ縺ゅｋ縺薙→縲ゑｼ亥ｰ上＆縺吶℃繧句ｴ蜷医ｯBASS縺ｫ繧医▲縺ｦ閾ｪ蜍穂ｿｮ豁｣縺輔ｌ繧九ゑｼ
+ ///
+ public static int SoundUpdatePeriodExclusiveWASAPI = 6;
+ ///
+ /// 蜈ｱ譛姥ASAPI繝舌ャ繝輔ぃ縺ｮ譖ｴ譁ｰ髢馴囈縲ょｺ蜉幃俣髫斐〒縺ｯ縺ｪ縺縺ｮ縺ｧ豕ｨ諢上
+ /// SoundDelay 繧医ｊ繧ょｰ上＆縺蛟､縺ｧ縺ゅｋ縺薙→縲ゑｼ亥ｰ上＆縺吶℃繧句ｴ蜷医ｯBASS縺ｫ繧医▲縺ｦ閾ｪ蜍穂ｿｮ豁｣縺輔ｌ繧九ゑｼ
+ ///
+ public static int SoundUpdatePeriodSharedWASAPI = 6;
+ /////
+ ///// ASIO 蜃ｺ蜉帙↓縺翫¢繧句咲函驕蟒ｶ[ms]ｼ医ｮ蟶梧悍蛟､ｼ峨よ怙邨ら噪縺ｫ縺ｯ縺薙ｮ謨ｰ蛟､繧貞渕縺ｫ繝峨Λ繧､繝舌′豎ｺ螳壹☆繧具ｼ峨
+ /////
+ //public static int SoundDelayASIO = 0; // SST縺ｧ縺ｯ50ms縲0縺ｫ縺吶ｋ縺ｨ縲√ョ繝舌う繧ｹ縺ｮ險ｭ螳壼､繧偵◎縺ｮ縺ｾ縺ｾ菴ｿ縺縲
+ ///
+ /// ASIO 蜃ｺ蜉帙↓縺翫¢繧九ヰ繝繝輔ぃ繧ｵ繧､繧ｺ縲
+ ///
+ public static int SoundDelayASIO = 0; // 0縺ｫ縺吶ｋ縺ｨ縲√ョ繝舌う繧ｹ縺ｮ險ｭ螳壼､繧偵◎縺ｮ縺ｾ縺ｾ菴ｿ縺縲
+ public int GetSoundDelayASIO()
+ {
+ return SoundDelayASIO;
+ }
+ public void SetSoundDelayASIO(int value)
+ {
+ SoundDelayASIO = value;
+ }
+ public static int ASIODevice = 0;
+ public int GetASIODevice()
+ {
+ return ASIODevice;
+ }
+ public void SetASIODevice(int value)
+ {
+ ASIODevice = value;
+ }
+ ///
+ /// DirectSound 蜃ｺ蜉帙↓縺翫¢繧句咲函驕蟒ｶ[ms]縲ゅΘ繝ｼ繧ｶ縺梧ｱｺ螳壹☆繧九
+ ///
+ public static int SoundDelayDirectSound = 100;
+
+ public long GetSoundDelay()
+ {
+ if ( SoundDevice != null )
+ {
+ return SoundDevice.n螳溘ヰ繝繝輔ぃ繧ｵ繧､繧ｺms;
+ }
+ else
+ {
+ return -1;
+ }
+ }
+
+ #endregion
+
+
+ ///
+ /// DTXMania逕ｨ繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ public CSound邂｡逅( IntPtr handle, ESoundDeviceType soundDeviceType, int nSoundDelayExclusiveWASAPI, int nSoundDelayASIO, int nASIODevice, bool _bUseOSTimer )
+ {
+ WindowHandle = handle;
+ SoundDevice = null;
+ //bUseOSTimer = false;
+ t蛻晄悄蛹( soundDeviceType, nSoundDelayExclusiveWASAPI, nSoundDelayASIO, nASIODevice, _bUseOSTimer );
+ }
+ public void Dispose()
+ {
+ t邨ゆｺ();
+ }
+
+ //public static void t蛻晄悄蛹()
+ //{
+ // t蛻晄悄蛹( ESoundDeviceType.DirectSound, 0, 0, 0 );
+ //}
+
+ public void t蛻晄悄蛹( ESoundDeviceType soundDeviceType, int _nSoundDelayExclusiveWASAPI, int _nSoundDelayASIO, int _nASIODevice, IntPtr handle )
+ {
+ //if ( !bInitialized )
+ {
+ WindowHandle = handle;
+ t蛻晄悄蛹( soundDeviceType, _nSoundDelayExclusiveWASAPI, _nSoundDelayASIO, _nASIODevice );
+ //bInitialized = true;
+ }
+ }
+ public void t蛻晄悄蛹( ESoundDeviceType soundDeviceType, int _nSoundDelayExclusiveWASAPI, int _nSoundDelayASIO, int _nASIODevice )
+ {
+ t蛻晄悄蛹( soundDeviceType, _nSoundDelayExclusiveWASAPI, _nSoundDelayASIO, _nASIODevice, false );
+ }
+
+ public void t蛻晄悄蛹( ESoundDeviceType soundDeviceType, int _nSoundDelayExclusiveWASAPI, int _nSoundDelayASIO, int _nASIODevice, bool _bUseOSTimer )
+ {
+ //SoundDevice = null; // 蠕後〒蜀榊晄悄蛹悶☆繧九％縺ｨ縺後≠繧九ｮ縺ｧ縲］ull蛻晄悄蛹悶ｯ繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ縺ｫ蝗槭☆
+ rc貍泌･冗畑繧ｿ繧､繝 = null; // Global.Bass 萓晏ｭ假ｼ医▽縺ｾ繧翫Θ繝ｼ繧ｶ萓晏ｭ假ｼ
+ nMixing = 0;
+
+ SoundDelayExclusiveWASAPI = _nSoundDelayExclusiveWASAPI;
+ SoundDelayASIO = _nSoundDelayASIO;
+ ASIODevice = _nASIODevice;
+ bUseOSTimer = _bUseOSTimer;
+
+ ESoundDeviceType[] ESoundDeviceTypes = new ESoundDeviceType[ 4 ]
+ {
+ ESoundDeviceType.ExclusiveWASAPI,
+ ESoundDeviceType.ASIO,
+ ESoundDeviceType.DirectSound,
+ ESoundDeviceType.Unknown
+ };
+
+ int n蛻晄悄繝繝舌う繧ｹ;
+ switch ( soundDeviceType )
+ {
+ case ESoundDeviceType.ExclusiveWASAPI:
+ n蛻晄悄繝繝舌う繧ｹ = 0;
+ break;
+ case ESoundDeviceType.ASIO:
+ n蛻晄悄繝繝舌う繧ｹ = 1;
+ break;
+ case ESoundDeviceType.DirectSound:
+ n蛻晄悄繝繝舌う繧ｹ = 2;
+ break;
+ default:
+ n蛻晄悄繝繝舌う繧ｹ = 3;
+ break;
+ }
+ for ( SoundDeviceType = ESoundDeviceTypes[ n蛻晄悄繝繝舌う繧ｹ ]; ; SoundDeviceType = ESoundDeviceTypes[ ++n蛻晄悄繝繝舌う繧ｹ ] )
+ {
+ try
+ {
+ t迴ｾ蝨ｨ縺ｮ繝ｦ繝ｼ繧ｶConfig縺ｫ蠕薙▲縺ｦ繧ｵ繧ｦ繝ｳ繝峨ョ繝舌う繧ｹ縺ｨ縺吶∋縺ｦ縺ｮ譌｢蟄倥し繧ｦ繝ｳ繝峨ｒ蜀肴ｧ狗ｯ峨☆繧();
+ break;
+ }
+ catch ( Exception e )
+ {
+ Trace.TraceError( e.ToString() );
+ Trace.TraceError( "萓句､悶′逋ｺ逕溘＠縺ｾ縺励◆縺悟ｦ逅繧堤ｶ咏ｶ壹＠縺ｾ縺吶 (2609806d-23e8-45c2-9389-b427e80915bc)" );
+ if ( ESoundDeviceTypes[ n蛻晄悄繝繝舌う繧ｹ ] == ESoundDeviceType.Unknown )
+ {
+ Trace.TraceError( string.Format( "繧ｵ繧ｦ繝ｳ繝峨ョ繝舌う繧ｹ縺ｮ蛻晄悄蛹悶↓螟ｱ謨励＠縺ｾ縺励◆縲" ) );
+ break;
+ }
+ }
+ }
+ if ( soundDeviceType == ESoundDeviceType.ExclusiveWASAPI || soundDeviceType == ESoundDeviceType.ASIO )
+ {
+ //Bass.BASS_SetConfig( BASSConfig.BASS_CONFIG_UPDATETHREADS, 4 );
+ //Bass.BASS_SetConfig( BASSConfig.BASS_CONFIG_UPDATEPERIOD, 0 );
+
+ Trace.TraceInformation( "BASS_CONFIG_UpdatePeriod=" + Bass.BASS_GetConfig( BASSConfig.BASS_CONFIG_UPDATEPERIOD ) );
+ Trace.TraceInformation( "BASS_CONFIG_UpdateThreads=" + Bass.BASS_GetConfig( BASSConfig.BASS_CONFIG_UPDATETHREADS ) );
+ }
+ }
+
+ public void tDisableUpdateBufferAutomatically()
+ {
+ //Bass.BASS_SetConfig( BASSConfig.BASS_CONFIG_UPDATETHREADS, 0 );
+ //Bass.BASS_SetConfig( BASSConfig.BASS_CONFIG_UPDATEPERIOD, 0 );
+
+ //Trace.TraceInformation( "BASS_CONFIG_UpdatePeriod=" + Bass.BASS_GetConfig( BASSConfig.BASS_CONFIG_UPDATEPERIOD ) );
+ //Trace.TraceInformation( "BASS_CONFIG_UpdateThreads=" + Bass.BASS_GetConfig( BASSConfig.BASS_CONFIG_UPDATETHREADS ) );
+ }
+
+
+ public static void t邨ゆｺ()
+ {
+ C蜈ｱ騾.tDispose縺吶ｋ( SoundDevice ); SoundDevice = null;
+ C蜈ｱ騾.tDispose縺吶ｋ( ref rc貍泌･冗畑繧ｿ繧､繝 ); // Global.Bass 繧定ｧ｣謾ｾ縺励◆蠕後↓隗｣謾ｾ縺吶ｋ縺薙→縲ゑｼGlobal.Bass 縺ｧ蜿らｧ縺輔ｌ縺ｦ縺繧九◆繧ｼ
+ }
+
+
+ public static void t迴ｾ蝨ｨ縺ｮ繝ｦ繝ｼ繧ｶConfig縺ｫ蠕薙▲縺ｦ繧ｵ繧ｦ繝ｳ繝峨ョ繝舌う繧ｹ縺ｨ縺吶∋縺ｦ縺ｮ譌｢蟄倥し繧ｦ繝ｳ繝峨ｒ蜀肴ｧ狗ｯ峨☆繧()
+ {
+ #region [ 縺吶〒縺ｫ繧ｵ繧ｦ繝ｳ繝峨ョ繝舌う繧ｹ縺ｨ貍泌･上ち繧､繝槭′讒狗ｯ峨＆繧後※縺繧後ｰ隗｣謾ｾ縺吶ｋ縲]
+ //-----------------
+ if ( SoundDevice != null )
+ {
+ // 縺吶〒縺ｫ逕滓先ｸ医∩縺ｮ繧ｵ繧ｦ繝ｳ繝峨′縺ゅｌ縺ｰ蛻晄悄迥ｶ諷九↓謌ｻ縺吶
+
+ CSound.t縺吶∋縺ｦ縺ｮ繧ｵ繧ｦ繝ｳ繝峨ｒ蛻晄悄迥ｶ諷九↓謌ｻ縺(); // 繝ｪ繧ｽ繝ｼ繧ｹ縺ｯ隗｣謾ｾ縺吶ｋ縺後，Sound縺ｮ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｯ谿九☆縲
+
+
+ // 繧ｵ繧ｦ繝ｳ繝峨ョ繝舌う繧ｹ縺ｨ貍泌･上ち繧､繝槭ｒ隗｣謾ｾ縺吶ｋ縲
+
+ C蜈ｱ騾.tDispose縺吶ｋ( SoundDevice ); SoundDevice = null;
+ C蜈ｱ騾.tDispose縺吶ｋ( ref rc貍泌･冗畑繧ｿ繧､繝 ); // Global.SoundDevice 繧定ｧ｣謾ｾ縺励◆蠕後↓隗｣謾ｾ縺吶ｋ縺薙→縲ゑｼGlobal.SoundDevice 縺ｧ蜿らｧ縺輔ｌ縺ｦ縺繧九◆繧ｼ
+ }
+ //-----------------
+ #endregion
+
+ #region [ 譁ｰ縺励＞繧ｵ繧ｦ繝ｳ繝峨ョ繝舌う繧ｹ繧呈ｧ狗ｯ峨☆繧九]
+ //-----------------
+ switch ( SoundDeviceType )
+ {
+ case ESoundDeviceType.ExclusiveWASAPI:
+ SoundDevice = new CSoundDeviceWASAPI( CSoundDeviceWASAPI.E繝繝舌う繧ｹ繝｢繝ｼ繝.蜈ｱ譛, SoundDelayExclusiveWASAPI, SoundUpdatePeriodExclusiveWASAPI );
+ break;
+
+ case ESoundDeviceType.SharedWASAPI:
+ SoundDevice = new CSoundDeviceWASAPI( CSoundDeviceWASAPI.E繝繝舌う繧ｹ繝｢繝ｼ繝.蜈ｱ譛, SoundDelaySharedWASAPI, SoundUpdatePeriodSharedWASAPI );
+ break;
+
+ case ESoundDeviceType.ASIO:
+ SoundDevice = new CSoundDeviceASIO( SoundDelayASIO, ASIODevice );
+ break;
+
+ case ESoundDeviceType.DirectSound:
+ SoundDevice = new CSoundDeviceDirectSound( WindowHandle, SoundDelayDirectSound, bUseOSTimer );
+ break;
+
+ default:
+ throw new Exception( string.Format( "譛ｪ蟇ｾ蠢懊ｮ SoundDeviceType 縺ｧ縺吶[{0}]", SoundDeviceType.ToString() ) );
+ }
+ //-----------------
+ #endregion
+ #region [ 譁ｰ縺励＞貍泌･上ち繧､繝槭ｒ讒狗ｯ峨☆繧九]
+ //-----------------
+ rc貍泌･冗畑繧ｿ繧､繝 = new CSoundTimer( SoundDevice );
+ //-----------------
+ #endregion
+
+ SoundDevice.nMasterVolume = _nMasterVolume; // 繧ｵ繧ｦ繝ｳ繝峨ョ繝舌う繧ｹ縺ｫ蟇ｾ縺励※縲√槭せ繧ｿ繝ｼ繝懊Μ繝･繝ｼ繝繧貞崎ｨｭ螳壹☆繧
+
+ CSound.t縺吶∋縺ｦ縺ｮ繧ｵ繧ｦ繝ｳ繝峨ｒ蜀肴ｧ狗ｯ峨☆繧( SoundDevice ); // 縺吶〒縺ｫ逕滓先ｸ医∩縺ｮ繧ｵ繧ｦ繝ｳ繝峨′縺ゅｌ縺ｰ菴懊ｊ逶ｴ縺吶
+ }
+ public CSound t繧ｵ繧ｦ繝ｳ繝峨ｒ逕滓舌☆繧( string filename, ESoundGroup soundGroup )
+ {
+ if( !File.Exists( filename ) )
+ {
+ Trace.TraceWarning($"[i18n] File does not exist: {filename}");
+ return null;
+ }
+
+ if ( SoundDeviceType == ESoundDeviceType.Unknown )
+ {
+ throw new Exception( string.Format( "譛ｪ蟇ｾ蠢懊ｮ SoundDeviceType 縺ｧ縺吶[{0}]", SoundDeviceType.ToString() ) );
+ }
+ return SoundDevice.t繧ｵ繧ｦ繝ｳ繝峨ｒ菴懈舌☆繧( filename, soundGroup );
+ }
+
+ private static DateTime lastUpdateTime = DateTime.MinValue;
+ public void t蜀咲函荳ｭ縺ｮ蜃ｦ逅繧偵☆繧( object o ) // #26122 2011.9.1 yyagi; delegate邨檎罰縺ｮ蜻ｼ縺ｳ蜃ｺ縺礼畑
+ {
+ t蜀咲函荳ｭ縺ｮ蜃ｦ逅繧偵☆繧();
+ }
+ public void t蜀咲函荳ｭ縺ｮ蜃ｦ逅繧偵☆繧()
+ {
+//笘笘笘笘笘笘笘笘笘笘笘笘笘笘笘笘笘笘笘笘笘繝繝溘ｼ笘笘笘笘笘笘笘笘笘笘笘笘笘笘笘笘笘笘
+// Debug.Write( "蜀咲函荳ｭ縺ｮ蜃ｦ逅繧偵☆繧()" );
+ //DateTime now = DateTime.Now;
+ //TimeSpan ts = now - lastUpdateTime;
+ //if ( ts.Milliseconds > 5 )
+ //{
+ // bool b = Bass.BASS_Update( 100 * 2 );
+ // lastUpdateTime = DateTime.Now;
+ // if ( !b )
+ // {
+ // Trace.TraceInformation( "BASS_UPdate() failed: " + Bass.BASS_ErrorGetCode().ToString() );
+ // }
+ //}
+ }
+
+ public void t繧ｵ繧ｦ繝ｳ繝峨ｒ遐ｴ譽縺吶ｋ( CSound csound )
+ {
+ csound?.t隗｣謾ｾ縺吶ｋ( true ); // 繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｯ蟄倡ｶ壺堤ｴ譽縺ｫ縺吶ｋ縲
+ }
+
+ public float GetCPUusage()
+ {
+ float f;
+ switch ( SoundDeviceType )
+ {
+ case ESoundDeviceType.ExclusiveWASAPI:
+ case ESoundDeviceType.SharedWASAPI:
+ f = BassWasapi.BASS_WASAPI_GetCPU();
+ break;
+ case ESoundDeviceType.ASIO:
+ f = BassAsio.BASS_ASIO_GetCPU();
+ break;
+ case ESoundDeviceType.DirectSound:
+ f = 0.0f;
+ break;
+ default:
+ f = 0.0f;
+ break;
+ }
+ return f;
+ }
+
+ public string GetCurrentSoundDeviceType()
+ {
+ switch ( SoundDeviceType )
+ {
+ case ESoundDeviceType.ExclusiveWASAPI:
+ case ESoundDeviceType.SharedWASAPI:
+ return "WASAPI";
+ case ESoundDeviceType.ASIO:
+ return "ASIO";
+ case ESoundDeviceType.DirectSound:
+ return "DirectSound";
+ default:
+ return "Unknown";
+ }
+ }
+
+ public void AddMixer( CSound cs, double db蜀咲函騾溷ｺｦ, bool _b貍泌･冗ｵゆｺ蠕後ｂ蜀咲函縺檎ｶ壹￥繝√ャ繝励〒縺ゅｋ )
+ {
+ cs.b貍泌･冗ｵゆｺ蠕後ｂ蜀咲函縺檎ｶ壹￥繝√ャ繝励〒縺ゅｋ = _b貍泌･冗ｵゆｺ蠕後ｂ蜀咲函縺檎ｶ壹￥繝√ャ繝励〒縺ゅｋ;
+ cs.db蜀咲函騾溷ｺｦ = db蜀咲函騾溷ｺｦ;
+ cs.tBASS繧ｵ繧ｦ繝ｳ繝峨ｒ繝溘く繧ｵ繝ｼ縺ｫ霑ｽ蜉縺吶ｋ();
+ }
+ public void AddMixer( CSound cs, double db蜀咲函騾溷ｺｦ )
+ {
+ cs.db蜀咲函騾溷ｺｦ = db蜀咲函騾溷ｺｦ;
+ cs.tBASS繧ｵ繧ｦ繝ｳ繝峨ｒ繝溘く繧ｵ繝ｼ縺ｫ霑ｽ蜉縺吶ｋ();
+ }
+ public void AddMixer( CSound cs )
+ {
+ cs.tBASS繧ｵ繧ｦ繝ｳ繝峨ｒ繝溘く繧ｵ繝ｼ縺ｫ霑ｽ蜉縺吶ｋ();
+ }
+ public void RemoveMixer( CSound cs )
+ {
+ cs.tBASS繧ｵ繧ｦ繝ｳ繝峨ｒ繝溘く繧ｵ繝ｼ縺九ｉ蜑企勁縺吶ｋ();
+ }
+ }
+ #endregion
+
+ // CSound 縺ｯ縲√し繧ｦ繝ｳ繝峨ョ繝舌う繧ｹ縺悟､画峩縺輔ｌ縺溘→縺阪ｂ縲√う繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ繧貞堺ｽ懈舌☆繧九％縺ｨ縺ｪ縺上∵眠縺励＞繝繝舌う繧ｹ縺ｧ菴懊ｊ逶ｴ縺帙ｋ蠢隕√′縺ゅｋ縲
+ // 縺昴ｮ縺溘ａ縲√ョ繝舌う繧ｹ縺斐→縺ｫ蛻･縺ｮ繧ｯ繝ｩ繧ｹ縺ｫ蛻蜑ｲ縺吶ｋ縺ｮ縺ｧ縺ｯ縺ｪ縺上ｼ代▽縺ｮ繧ｯ繝ｩ繧ｹ縺ｫ髮邏縺吶ｋ繧ゅｮ縺ｨ縺吶ｋ縲
+
+ public class CSound : IDisposable
+ {
+ public const int MinimumSongVol = 0;
+ public const int MaximumSongVol = 200; // support an approximate doubling in volume.
+ public const int DefaultSongVol = 100;
+
+ // 2018-08-19 twopointzero: Note the present absence of a MinimumAutomationLevel.
+ // We will revisit this if/when song select BGM fade-in/fade-out needs
+ // updating due to changing the type or range of AutomationLevel
+ public const int MaximumAutomationLevel = 100;
+ public const int DefaultAutomationLevel = 100;
+
+ public const int MinimumGroupLevel = 0;
+ public const int MaximumGroupLevel = 100;
+ public const int DefaultGroupLevel = 100;
+ public const int DefaultSoundEffectLevel = 80;
+ public const int DefaultVoiceLevel = 90;
+ public const int DefaultSongPlaybackLevel = 90;
+
+ public static readonly Lufs MinimumLufs = new Lufs(-100.0);
+ public static readonly Lufs MaximumLufs = new Lufs(10.0); // support an approximate doubling in volume.
+
+ private static readonly Lufs DefaultGain = new Lufs(0.0);
+
+ public readonly ESoundGroup SoundGroup;
+
+ #region [ DTXMania逕ｨ諡｡蠑ｵ ]
+
+ public int n邱乗ｼ泌･乗凾髢杜s
+ {
+ get;
+ private set;
+ }
+ public int n繧ｵ繧ｦ繝ｳ繝峨ヰ繝繝輔ぃ繧ｵ繧､繧ｺ // 蜿悶ｊ縺ゅ∴縺0蝗ｺ螳壺笘笘笘笘笘笘笘笘笘笘笘笘笘笘笘笘笘笘笘
+ {
+ get { return 0; }
+ }
+ public bool b繧ｹ繝医Μ繝ｼ繝蜀咲函縺吶ｋ // 蜿悶ｊ縺ゅ∴縺喃alse蝗ｺ螳壺笘笘笘笘笘笘笘笘笘笘笘笘笘笘笘笘笘笘笘
+ // true縺ｫ縺吶ｋ縺ｨ蜷御ｸ繝√ャ繝鈴浹縺ｮ螟夐榊咲函縺ｧ蝠城｡後′蜃ｺ繧(4POLY髻ｳ貅舌→縺励※蜍輔°縺ｪ縺)
+ {
+ get { return false; }
+ }
+ public double db蜻ｨ豕｢謨ｰ蛟咲紫
+ {
+ get
+ {
+ return _db蜻ｨ豕｢謨ｰ蛟咲紫;
+ }
+ set
+ {
+ if ( _db蜻ｨ豕｢謨ｰ蛟咲紫 != value )
+ {
+ _db蜻ｨ豕｢謨ｰ蛟咲紫 = value;
+ if ( bBASS繧ｵ繧ｦ繝ｳ繝峨〒縺ゅｋ )
+ {
+ Bass.BASS_ChannelSetAttribute( this.hBassStream, BASSAttribute.BASS_ATTRIB_FREQ, ( float ) ( _db蜻ｨ豕｢謨ｰ蛟咲紫 * _db蜀咲函騾溷ｺｦ * n繧ｪ繝ｪ繧ｸ繝翫Ν縺ｮ蜻ｨ豕｢謨ｰ ) );
+ }
+ else
+ {
+ try
+ {
+ this.Buffer.Frequency = (int)(_db蜻ｨ豕｢謨ｰ蛟咲紫 * _db蜀咲函騾溷ｺｦ * n繧ｪ繝ｪ繧ｸ繝翫Ν縺ｮ蜻ｨ豕｢謨ｰ);
+ }
+ catch
+ {
+ //萓句､門ｦ逅縺ｯ蜃ｺ縺輔↑縺
+ this.b騾溷ｺｦ荳翫£縺吶℃蝠城｡ = true;
+ }
+ }
+ }
+ }
+ }
+ public double db蜀咲函騾溷ｺｦ
+ {
+ get
+ {
+ return _db蜀咲函騾溷ｺｦ;
+ }
+ set
+ {
+ if ( _db蜀咲函騾溷ｺｦ != value )
+ {
+ _db蜀咲函騾溷ｺｦ = value;
+ bIs1蛟埼溷咲函 = ( _db蜀咲函騾溷ｺｦ == 1.000f );
+ if ( bBASS繧ｵ繧ｦ繝ｳ繝峨〒縺ゅｋ )
+ {
+ if ( _hTempoStream != 0 && !this.bIs1蛟埼溷咲函 ) // 蜀咲函騾溷ｺｦ縺警1.000縺ｮ縺ｨ縺阪ｯ縲ゝempoStream繧堤畑縺縺ｪ縺繧医≧縺ｫ縺励※鬮倬溷喧縺吶ｋ
+ {
+ this.hBassStream = _hTempoStream;
+ }
+ else
+ {
+ this.hBassStream = _hBassStream;
+ }
+
+ if ( CSound邂｡逅.bIsTimeStretch )
+ {
+ Bass.BASS_ChannelSetAttribute( this.hBassStream, BASSAttribute.BASS_ATTRIB_TEMPO, (float) ( db蜀咲函騾溷ｺｦ * 100 - 100 ) );
+ //double seconds = Bass.BASS_ChannelBytes2Seconds( this.hTempoStream, nBytes );
+ //this.n邱乗ｼ泌･乗凾髢杜s = (int) ( seconds * 1000 );
+ }
+ else
+ {
+ Bass.BASS_ChannelSetAttribute( this.hBassStream, BASSAttribute.BASS_ATTRIB_FREQ, ( float ) ( _db蜻ｨ豕｢謨ｰ蛟咲紫 * _db蜀咲函騾溷ｺｦ * n繧ｪ繝ｪ繧ｸ繝翫Ν縺ｮ蜻ｨ豕｢謨ｰ ) );
+ }
+ }
+ else
+ {
+ try
+ {
+ this.Buffer.Frequency = (int)(_db蜻ｨ豕｢謨ｰ蛟咲紫 * _db蜀咲函騾溷ｺｦ * n繧ｪ繝ｪ繧ｸ繝翫Ν縺ｮ蜻ｨ豕｢謨ｰ);
+ }
+ catch
+ {
+ //萓句､門ｦ逅縺ｯ蜃ｺ縺輔↑縺
+ this.b騾溷ｺｦ荳翫£縺吶℃蝠城｡ = true;
+ }
+ }
+ }
+ }
+ }
+ #endregion
+
+ public bool b騾溷ｺｦ荳翫£縺吶℃蝠城｡ = false;
+ public bool b貍泌･冗ｵゆｺ蠕後ｂ蜀咲函縺檎ｶ壹￥繝√ャ繝励〒縺ゅｋ = false; // 縺薙ｌ縺荊rue縺ｪ繧峨∵悽繧ｵ繧ｦ繝ｳ繝峨ｮ蜀咲函邨ゆｺ縺ｮ繧ｳ繝ｼ繝ｫ繝舌ャ繧ｯ譎ゅ↓閾ｪ蜍輔〒繝溘く繧ｵ繝ｼ縺九ｉ蜑企勁縺吶ｋ
+
+ //private STREAMPROC _cbStreamXA; // make it global, so that the GC can not remove it
+ private SYNCPROC _cbEndofStream; // 繧ｹ繝医Μ繝ｼ繝縺ｮ邨らｫｯ縺ｾ縺ｧ蜀咲函縺輔ｌ縺溘→縺阪↓蜻ｼ縺ｳ蜃ｺ縺輔ｌ繧九さ繝ｼ繝ｫ繝舌ャ繧ｯ
+// private WaitCallback _cbRemoveMixerChannel;
+
+ ///
+ /// Gain is applied "first" to the audio data, much as in a physical or
+ /// software mixer. Later steps in the flow of audio apply "channel" level
+ /// (e.g. AutomationLevel) and mixing group level (e.g. GroupLevel) before
+ /// the audio is output.
+ ///
+ /// This method, taking an integer representing a percent value, is used
+ /// for mixing in the SONGVOL value, when available. It is also used for
+ /// DTXViewer preview mode.
+ ///
+ public void SetGain(int songVol)
+ {
+ SetGain(LinearIntegerPercentToLufs(songVol), null);
+ }
+
+ private static Lufs LinearIntegerPercentToLufs(int percent)
+ {
+ // 2018-08-27 twopointzero: We'll use the standard conversion until an appropriate curve can be selected
+ return new Lufs(20.0 * Math.Log10(percent / 100.0));
+ }
+
+ ///
+ /// Gain is applied "first" to the audio data, much as in a physical or
+ /// software mixer. Later steps in the flow of audio apply "channel" level
+ /// (e.g. AutomationLevel) and mixing group level (e.g. GroupLevel) before
+ /// the audio is output.
+ ///
+ /// This method, taking a LUFS gain value and a LUFS true audio peak value,
+ /// is used for mixing in the loudness-metadata-base gain value, when available.
+ ///
+ public void SetGain(Lufs gain, Lufs? truePeak)
+ {
+ if (Equals(_gain, gain))
+ {
+ return;
+ }
+
+ _gain = gain;
+ _truePeak = truePeak;
+
+ if (SoundGroup == ESoundGroup.SongPlayback)
+ {
+ Trace.TraceInformation($"{nameof(CSound)}.{nameof(SetGain)}: Gain: {_gain}. True Peak: {_truePeak}");
+ }
+
+ SetVolume();
+ }
+
+ ///
+ /// AutomationLevel is applied "second" to the audio data, much as in a
+ /// physical or sofware mixer and its channel level. Before this Gain is
+ /// applied, and after this the mixing group level is applied.
+ ///
+ /// This is currently used only for automated fade in and out as is the
+ /// case right now for the song selection screen background music fade
+ /// in and fade out.
+ ///
+ public int AutomationLevel
+ {
+ get => _automationLevel;
+ set
+ {
+ if (_automationLevel == value)
+ {
+ return;
+ }
+
+ _automationLevel = value;
+
+ if (SoundGroup == ESoundGroup.SongPlayback)
+ {
+ Trace.TraceInformation($"{nameof(CSound)}.{nameof(AutomationLevel)} set: {AutomationLevel}");
+ }
+
+ SetVolume();
+ }
+ }
+
+ ///
+ /// GroupLevel is applied "third" to the audio data, much as in the sub
+ /// mixer groups of a physical or software mixer. Before this both the
+ /// Gain and AutomationLevel are applied, and after this the audio
+ /// flows into the audio subsystem for mixing and output based on the
+ /// master volume.
+ ///
+ /// This is currently automatically managed for each sound based on the
+ /// configured and dynamically adjustable sound group levels for each of
+ /// sound effects, voice, song preview, and song playback.
+ ///
+ /// See the SoundGroupLevelController and related classes for more.
+ ///
+ public int GroupLevel
+ {
+ private get => _groupLevel;
+ set
+ {
+ if (_groupLevel == value)
+ {
+ return;
+ }
+
+ _groupLevel = value;
+
+ if (SoundGroup == ESoundGroup.SongPlayback)
+ {
+ Trace.TraceInformation($"{nameof(CSound)}.{nameof(GroupLevel)} set: {GroupLevel}");
+ }
+
+ SetVolume();
+ }
+ }
+
+ private void SetVolume()
+ {
+ var automationLevel = LinearIntegerPercentToLufs(AutomationLevel);
+ var groupLevel = LinearIntegerPercentToLufs(GroupLevel);
+
+ var gain =
+ _gain +
+ automationLevel +
+ groupLevel;
+
+ var safeTruePeakGain = _truePeak?.Negate() ?? new Lufs(0);
+ var finalGain = gain.Min(safeTruePeakGain);
+
+ if (SoundGroup == ESoundGroup.SongPlayback)
+ {
+ Trace.TraceInformation(
+ $"{nameof(CSound)}.{nameof(SetVolume)}: Gain:{_gain}. Automation Level: {automationLevel}. Group Level: {groupLevel}. Summed Gain: {gain}. Safe True Peak Gain: {safeTruePeakGain}. Final Gain: {finalGain}.");
+ }
+
+ lufs髻ｳ驥 = finalGain;
+ }
+
+ private Lufs lufs髻ｳ驥
+ {
+ set
+ {
+ if (this.bBASS繧ｵ繧ｦ繝ｳ繝峨〒縺ゅｋ)
+ {
+ var db髻ｳ驥 = ((value.ToDouble() / 100.0) + 1.0).Clamp(0, 1);
+ Bass.BASS_ChannelSetAttribute(this.hBassStream, BASSAttribute.BASS_ATTRIB_VOL, (float) db髻ｳ驥);
+ }
+ else if (this.bDirectSound縺ｧ縺ゅｋ)
+ {
+ var db髻ｳ驥 = (value.ToDouble() * 100.0).Clamp(-10000, 0);
+ this.Buffer.Volume = (int) Math.Round(db髻ｳ驥);
+ }
+ }
+ }
+
+ ///
+ /// 蟾ｦ:-100ｽ樔ｸｭ螟ｮ:0ｽ100:蜿ｳ縲Ｔet 縺ｮ縺ｿ縲
+ ///
+ public int n菴咲ｽｮ
+ {
+ get
+ {
+ if( this.bBASS繧ｵ繧ｦ繝ｳ繝峨〒縺ゅｋ )
+ {
+ float f菴咲ｽｮ = 0.0f;
+ if ( !Bass.BASS_ChannelGetAttribute( this.hBassStream, BASSAttribute.BASS_ATTRIB_PAN, ref f菴咲ｽｮ ) )
+ //if( BassMix.BASS_Mixer_ChannelGetEnvelopePos( this.hBassStream, BASSMIXEnvelope.BASS_MIXER_ENV_PAN, ref f菴咲ｽｮ ) == -1 )
+ return 0;
+ return (int) ( f菴咲ｽｮ * 100 );
+ }
+ else if( this.bDirectSound縺ｧ縺ゅｋ )
+ {
+ return this._n菴咲ｽｮ;
+ }
+ return -9999;
+ }
+ set
+ {
+ if( this.bBASS繧ｵ繧ｦ繝ｳ繝峨〒縺ゅｋ )
+ {
+ float f菴咲ｽｮ = Math.Min( Math.Max( value, -100 ), 100 ) / 100.0f; // -100ｽ100 竊 -1.0ｽ1.0
+ //var nodes = new BASS_MIXER_NODE[ 1 ] { new BASS_MIXER_NODE( 0, f菴咲ｽｮ ) };
+ //BassMix.BASS_Mixer_ChannelSetEnvelope( this.hBassStream, BASSMIXEnvelope.BASS_MIXER_ENV_PAN, nodes );
+ Bass.BASS_ChannelSetAttribute( this.hBassStream, BASSAttribute.BASS_ATTRIB_PAN, f菴咲ｽｮ );
+ }
+ else if( this.bDirectSound縺ｧ縺ゅｋ )
+ {
+ this._n菴咲ｽｮ = Math.Min( Math.Max( -100, value ), 100 ); // -100ｽ100
+
+ if( this._n菴咲ｽｮ == 0 )
+ {
+ this._n菴咲ｽｮdb = 0;
+ }
+ else if( this._n菴咲ｽｮ == -100 )
+ {
+ this._n菴咲ｽｮdb = -10000;
+ }
+ else if( this._n菴咲ｽｮ == 100 )
+ {
+ this._n菴咲ｽｮdb = 10000;
+ }
+ else if( this._n菴咲ｽｮ < 0 )
+ {
+ this._n菴咲ｽｮdb = (int) ( ( 20.0 * Math.Log10( ( (double) ( this._n菴咲ｽｮ + 100 ) ) / 100.0 ) ) * 100.0 );
+ }
+ else
+ {
+ this._n菴咲ｽｮdb = (int) ( ( -20.0 * Math.Log10( ( (double) ( 100 - this._n菴咲ｽｮ ) ) / 100.0 ) ) * 100.0 );
+ }
+
+ this.Buffer.Pan = this._n菴咲ｽｮdb;
+ }
+ }
+ }
+
+ ///
+ /// DirectSound縺ｮ繧ｻ繧ｫ繝ｳ繝繝ｪ繝舌ャ繝輔ぃ縲
+ ///
+ //public SecondarySoundBuffer DirectSoundBuffer
+ public SoundBuffer DirectSoundBuffer
+ {
+ get { return this.Buffer; }
+ }
+
+ ///
+ /// DirectSound縺ｮ繧ｻ繧ｫ繝ｳ繝繝ｪ繝舌ャ繝輔ぃ菴懈先凾縺ｮ繝輔Λ繧ｰ縲
+ ///
+ public BufferFlags DirectSoundBufferFlags
+ {
+ get;
+ protected set;
+ }
+
+ ///
+ /// 蜈ｨ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ繝ｪ繧ｹ繝医
+ /// ｽ槭ｒ菴懈舌☆繧() 縺ｧ霑ｽ蜉縺輔ｌ縲》隗｣謾ｾ縺吶ｋ() or Dispose() 縺ｧ隗｣謾ｾ縺輔ｌ繧九
+ ///
+ public static readonly ObservableCollection list繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ = new ObservableCollection();
+
+ public static void ShowAllCSoundFiles()
+ {
+ int i = 0;
+ foreach ( CSound cs in list繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ )
+ {
+ Debug.WriteLine( i++.ToString( "d3" ) + ": " + Path.GetFileName( cs.str繝輔ぃ繧､繝ｫ蜷 ) );
+ }
+ }
+
+ public CSound(ESoundGroup soundGroup)
+ {
+ SoundGroup = soundGroup;
+ this.n菴咲ｽｮ = 0;
+ this._db蜻ｨ豕｢謨ｰ蛟咲紫 = 1.0;
+ this._db蜀咲函騾溷ｺｦ = 1.0;
+// this._cbRemoveMixerChannel = new WaitCallback( RemoveMixerChannelLater );
+ this._hBassStream = -1;
+ this._hTempoStream = 0;
+ }
+
+ public void tASIO繧ｵ繧ｦ繝ｳ繝峨ｒ菴懈舌☆繧( string str繝輔ぃ繧､繝ｫ蜷, int hMixer )
+ {
+ this.e繝繝舌う繧ｹ遞ｮ蛻･ = ESoundDeviceType.ASIO; // 菴懈仙ｾ後↓險ｭ螳壹☆繧九ゑｼ井ｽ懈舌↓螟ｱ謨励＠縺ｦ繧九→萓句､也匱蜃ｺ縺輔ｌ縺ｦ縺薙％縺ｯ螳溯｡後＆繧後↑縺ｼ
+ this.tBASS繧ｵ繧ｦ繝ｳ繝峨ｒ菴懈舌☆繧( str繝輔ぃ繧､繝ｫ蜷, hMixer, BASSFlag.BASS_STREAM_DECODE );
+ }
+ public void tASIO繧ｵ繧ｦ繝ｳ繝峨ｒ菴懈舌☆繧( byte[] byArrWAV繝輔ぃ繧､繝ｫ繧､繝｡繝ｼ繧ｸ, int hMixer )
+ {
+ this.e繝繝舌う繧ｹ遞ｮ蛻･ = ESoundDeviceType.ASIO; // 菴懈仙ｾ後↓險ｭ螳壹☆繧九ゑｼ井ｽ懈舌↓螟ｱ謨励＠縺ｦ繧九→萓句､也匱蜃ｺ縺輔ｌ縺ｦ縺薙％縺ｯ螳溯｡後＆繧後↑縺ｼ
+ this.tBASS繧ｵ繧ｦ繝ｳ繝峨ｒ菴懈舌☆繧( byArrWAV繝輔ぃ繧､繝ｫ繧､繝｡繝ｼ繧ｸ, hMixer, BASSFlag.BASS_STREAM_DECODE );
+ }
+ public void tWASAPI繧ｵ繧ｦ繝ｳ繝峨ｒ菴懈舌☆繧( string str繝輔ぃ繧､繝ｫ蜷, int hMixer, ESoundDeviceType e繝繝舌う繧ｹ遞ｮ蛻･ )
+ {
+ this.e繝繝舌う繧ｹ遞ｮ蛻･ = e繝繝舌う繧ｹ遞ｮ蛻･; // 菴懈仙ｾ後↓險ｭ螳壹☆繧九ゑｼ井ｽ懈舌↓螟ｱ謨励＠縺ｦ繧九→萓句､也匱蜃ｺ縺輔ｌ縺ｦ縺薙％縺ｯ螳溯｡後＆繧後↑縺ｼ
+ this.tBASS繧ｵ繧ｦ繝ｳ繝峨ｒ菴懈舌☆繧( str繝輔ぃ繧､繝ｫ蜷, hMixer, BASSFlag.BASS_STREAM_DECODE | BASSFlag.BASS_SAMPLE_FLOAT );
+ }
+ public void tWASAPI繧ｵ繧ｦ繝ｳ繝峨ｒ菴懈舌☆繧( byte[] byArrWAV繝輔ぃ繧､繝ｫ繧､繝｡繝ｼ繧ｸ, int hMixer, ESoundDeviceType e繝繝舌う繧ｹ遞ｮ蛻･ )
+ {
+ this.e繝繝舌う繧ｹ遞ｮ蛻･ = e繝繝舌う繧ｹ遞ｮ蛻･; // 菴懈仙ｾ後↓險ｭ螳壹☆繧九ゑｼ井ｽ懈舌↓螟ｱ謨励＠縺ｦ繧九→萓句､也匱蜃ｺ縺輔ｌ縺ｦ縺薙％縺ｯ螳溯｡後＆繧後↑縺ｼ
+ this.tBASS繧ｵ繧ｦ繝ｳ繝峨ｒ菴懈舌☆繧( byArrWAV繝輔ぃ繧､繝ｫ繧､繝｡繝ｼ繧ｸ, hMixer, BASSFlag.BASS_STREAM_DECODE | BASSFlag.BASS_SAMPLE_FLOAT );
+ }
+ public void tDirectSound繧ｵ繧ｦ繝ｳ繝峨ｒ菴懈舌☆繧( string str繝輔ぃ繧､繝ｫ蜷, DirectSound DirectSound )
+ {
+ this.e菴懈先婿豕 = E菴懈先婿豕.繝輔ぃ繧､繝ｫ縺九ｉ;
+ this.str繝輔ぃ繧､繝ｫ蜷 = str繝輔ぃ繧､繝ｫ蜷;
+ if ( String.Compare( Path.GetExtension( str繝輔ぃ繧､繝ｫ蜷 ), ".xa", true ) == 0 ||
+ String.Compare( Path.GetExtension( str繝輔ぃ繧､繝ｫ蜷 ), ".mp3", true ) == 0 ||
+ String.Compare( Path.GetExtension( str繝輔ぃ繧､繝ｫ蜷 ), ".ogg", true ) == 0 ) // caseless縺ｧ譁蟄怜玲ｯ碑ｼ
+ {
+ tDirectSound繧ｵ繧ｦ繝ｳ繝峨ｒ菴懈舌☆繧宜aOggMp3( str繝輔ぃ繧､繝ｫ蜷, DirectSound );
+ return;
+ }
+
+ // 縺吶∋縺ｦ縺ｮ繝輔ぃ繧､繝ｫ繧 DirectShow 縺ｧ繝繧ｳ繝ｼ繝峨☆繧九→譎る俣縺後°縺九ｋ縺ｮ縺ｧ縲√ヵ繧｡繧､繝ｫ縺 WAV 縺九▽ PCM 繝輔か繝ｼ繝槭ャ繝医〒縺ｪ縺蝣ｴ蜷医ｮ縺ｿ DirectShow 縺ｧ繝繧ｳ繝ｼ繝峨☆繧九
+
+ byte[] byArrWAV繝輔ぃ繧､繝ｫ繧､繝｡繝ｼ繧ｸ = null;
+ bool b繝輔ぃ繧､繝ｫ縺係AV縺九▽PCM繝輔か繝ｼ繝槭ャ繝医〒縺ゅｋ = true;
+
+ {
+ #region [ 繝輔ぃ繧､繝ｫ縺係AV縺九▽PCM繝輔か繝ｼ繝槭ャ繝医°蜷ｦ縺玖ｪｿ縺ｹ繧九]
+ //-----------------
+ try
+ {
+ Stream str = File.Open(str繝輔ぃ繧､繝ｫ蜷, FileMode.Open, FileAccess.Read);
+ using (var ws = new SoundStream(str))
+ {
+ if (ws.Format.Encoding != WaveFormatEncoding.Pcm)
+ b繝輔ぃ繧､繝ｫ縺係AV縺九▽PCM繝輔か繝ｼ繝槭ャ繝医〒縺ゅｋ = false;
+ }
+ }
+ catch
+ {
+ b繝輔ぃ繧､繝ｫ縺係AV縺九▽PCM繝輔か繝ｼ繝槭ャ繝医〒縺ゅｋ = false;
+ }
+ //-----------------
+ #endregion
+
+ if ( b繝輔ぃ繧､繝ｫ縺係AV縺九▽PCM繝輔か繝ｼ繝槭ャ繝医〒縺ゅｋ )
+ {
+ #region [ 繝輔ぃ繧､繝ｫ繧定ｪｭ縺ｿ霎ｼ繧薙〒 byArrWAV繝輔ぃ繧､繝ｫ繧､繝｡繝ｼ繧ｸ縺ｸ譬ｼ邏阪]
+ //-----------------
+ var fs = File.Open( str繝輔ぃ繧､繝ｫ蜷, FileMode.Open, FileAccess.Read );
+ var br = new BinaryReader( fs );
+
+ byArrWAV繝輔ぃ繧､繝ｫ繧､繝｡繝ｼ繧ｸ = new byte[ fs.Length ];
+ br.Read( byArrWAV繝輔ぃ繧､繝ｫ繧､繝｡繝ｼ繧ｸ, 0, (int) fs.Length );
+
+ br.Close();
+ fs.Close();
+ //-----------------
+ #endregion
+ }
+ else
+ {
+ #region [ DirectShow 縺ｧ繝繧ｳ繝ｼ繝牙､画鋤縺励 byArrWAV繝輔ぃ繧､繝ｫ繧､繝｡繝ｼ繧ｸ縺ｸ譬ｼ邏阪]
+ //-----------------
+ CDStoWAVFileImage.t螟画鋤( str繝輔ぃ繧､繝ｫ蜷, out byArrWAV繝輔ぃ繧､繝ｫ繧､繝｡繝ｼ繧ｸ );
+ //-----------------
+ #endregion
+ }
+ }
+
+ // 縺ゅ→縺ｯ縺ゅ■繧峨〒縲
+
+ this.tDirectSound繧ｵ繧ｦ繝ｳ繝峨ｒ菴懈舌☆繧( byArrWAV繝輔ぃ繧､繝ｫ繧､繝｡繝ｼ繧ｸ, DirectSound );
+ }
+ public void tDirectSound繧ｵ繧ｦ繝ｳ繝峨ｒ菴懈舌☆繧宜aOggMp3( string str繝輔ぃ繧､繝ｫ蜷, DirectSound DirectSound )
+ {
+ try
+ {
+ this.e菴懈先婿豕 = E菴懈先婿豕.繝輔ぃ繧､繝ｫ縺九ｉ;
+ this.str繝輔ぃ繧､繝ｫ蜷 = str繝輔ぃ繧､繝ｫ蜷;
+ WaveFormat wfx = new WaveFormat();
+ int nPCM繝繝ｼ繧ｿ縺ｮ蜈磯ｭ繧､繝ｳ繝繝繧ｯ繧ｹ = 0;
+ // int nPCM繧ｵ繧､繧ｺbyte = (int) ( xa.xaheader.nSamples * xa.xaheader.nChannels * 2 ); // nBytes = Bass.BASS_ChannelGetLength( this.hBassStream );
+
+
+
+ int nPCM繧ｵ繧､繧ｺbyte;
+ CWin32.WAVEFORMATEX cw32wfx;
+ t繧ｪ繝ｳ繝｡繝｢繝ｪ譁ｹ蠑上〒繝繧ｳ繝ｼ繝峨☆繧(str繝輔ぃ繧､繝ｫ蜷, out this.byArrWAV繝輔ぃ繧､繝ｫ繧､繝｡繝ｼ繧ｸ,
+ out nPCM繝繝ｼ繧ｿ縺ｮ蜈磯ｭ繧､繝ｳ繝繝繧ｯ繧ｹ, out nPCM繧ｵ繧､繧ｺbyte, out cw32wfx, false);
+
+ wfx = WaveFormat.CreateCustomFormat((WaveFormatEncoding)cw32wfx.wFormatTag, (int)cw32wfx.nSamplesPerSec, cw32wfx.nChannels, (int)cw32wfx.nAvgBytesPerSec, cw32wfx.nBlockAlign, cw32wfx.wBitsPerSample);
+
+ // 繧ｻ繧ｫ繝ｳ繝繝ｪ繝舌ャ繝輔ぃ繧剃ｽ懈舌＠縲￣CM繝繝ｼ繧ｿ繧呈嶌縺崎ｾｼ繧縲
+ tDirectSound繧ｵ繧ｦ繝ｳ繝峨ｒ菴懈舌☆繧祇繧ｻ繧ｫ繝ｳ繝繝ｪ繝舌ャ繝輔ぃ縺ｮ菴懈舌→WAV繝繝ｼ繧ｿ譖ｸ縺崎ｾｼ縺ｿ
+ (ref this.byArrWAV繝輔ぃ繧､繝ｫ繧､繝｡繝ｼ繧ｸ, DirectSound, CSoundDeviceDirectSound.DefaultFlags, wfx,
+ nPCM繧ｵ繧､繧ｺbyte, nPCM繝繝ｼ繧ｿ縺ｮ蜈磯ｭ繧､繝ｳ繝繝繧ｯ繧ｹ);
+ return;
+ }
+ catch (Exception e)
+ {
+ string s = Path.GetFileName(str繝輔ぃ繧､繝ｫ蜷);
+ Trace.TraceWarning($"Failed to create DirectSound buffer by using BASS.DLL.({s}: {e.Message})");
+ Trace.TraceWarning("Retrying by using DirectShow decoder.");
+ }
+ // 縺吶∋縺ｦ縺ｮ繝輔ぃ繧､繝ｫ繧 DirectShow 縺ｧ繝繧ｳ繝ｼ繝峨☆繧九→譎る俣縺後°縺九ｋ縺ｮ縺ｧ縲√ヵ繧｡繧､繝ｫ縺 WAV 縺九▽ PCM 繝輔か繝ｼ繝槭ャ繝医〒縺ｪ縺蝣ｴ蜷医ｮ縺ｿ DirectShow 縺ｧ繝繧ｳ繝ｼ繝峨☆繧九
+
+ byte[] byArrWAV繝輔ぃ繧､繝ｫ繧､繝｡繝ｼ繧ｸ = null;
+ bool b繝輔ぃ繧､繝ｫ縺係AV縺九▽PCM繝輔か繝ｼ繝槭ャ繝医〒縺ゅｋ = true;
+
+ {
+ #region [ 繝輔ぃ繧､繝ｫ縺係AV縺九▽PCM繝輔か繝ｼ繝槭ャ繝医°蜷ｦ縺玖ｪｿ縺ｹ繧九]
+ //-----------------
+ SoundStream ws = null;
+ try
+ {
+ using (ws = new SoundStream(new FileStream(str繝輔ぃ繧､繝ｫ蜷, FileMode.Open, FileAccess.Read, FileShare.ReadWrite)))
+ {
+ if (ws.Format.Encoding != WaveFormatEncoding.Pcm)
+ b繝輔ぃ繧､繝ｫ縺係AV縺九▽PCM繝輔か繝ｼ繝槭ャ繝医〒縺ゅｋ = false;
+ }
+ }
+ catch
+ {
+ b繝輔ぃ繧､繝ｫ縺係AV縺九▽PCM繝輔か繝ｼ繝槭ャ繝医〒縺ゅｋ = false;
+ }
+ finally
+ {
+ if (ws != null)
+ {
+ ws.Close();
+ ws.Dispose();
+ }
+ }
+ //-----------------
+ #endregion
+
+ if (b繝輔ぃ繧､繝ｫ縺係AV縺九▽PCM繝輔か繝ｼ繝槭ャ繝医〒縺ゅｋ)
+ {
+ #region [ 繝輔ぃ繧､繝ｫ繧定ｪｭ縺ｿ霎ｼ繧薙〒 byArrWAV繝輔ぃ繧､繝ｫ繧､繝｡繝ｼ繧ｸ縺ｸ譬ｼ邏阪]
+ //-----------------
+ var fs = File.Open(str繝輔ぃ繧､繝ｫ蜷, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
+ var br = new BinaryReader(fs);
+
+ byArrWAV繝輔ぃ繧､繝ｫ繧､繝｡繝ｼ繧ｸ = new byte[fs.Length];
+ br.Read(byArrWAV繝輔ぃ繧､繝ｫ繧､繝｡繝ｼ繧ｸ, 0, (int)fs.Length);
+
+ br.Close();
+ fs.Close();
+ //-----------------
+ #endregion
+ }
+ else
+ {
+ #region [ DirectShow 縺ｧ繝繧ｳ繝ｼ繝牙､画鋤縺励 byArrWAV繝輔ぃ繧､繝ｫ繧､繝｡繝ｼ繧ｸ縺ｸ譬ｼ邏阪]
+ //-----------------
+ CDStoWAVFileImage.t螟画鋤(str繝輔ぃ繧､繝ｫ蜷, out byArrWAV繝輔ぃ繧､繝ｫ繧､繝｡繝ｼ繧ｸ);
+ //-----------------
+ #endregion
+ }
+ }
+
+ // 縺ゅ→縺ｯ縺ゅ■繧峨〒縲
+
+ this.tDirectSound繧ｵ繧ｦ繝ｳ繝峨ｒ菴懈舌☆繧(byArrWAV繝輔ぃ繧､繝ｫ繧､繝｡繝ｼ繧ｸ, DirectSound);
+ }
+
+ public void tDirectSound繧ｵ繧ｦ繝ｳ繝峨ｒ菴懈舌☆繧( byte[] byArrWAV繝輔ぃ繧､繝ｫ繧､繝｡繝ｼ繧ｸ, DirectSound DirectSound )
+ {
+ this.tDirectSound繧ｵ繧ｦ繝ｳ繝峨ｒ菴懈舌☆繧( byArrWAV繝輔ぃ繧､繝ｫ繧､繝｡繝ｼ繧ｸ, DirectSound, CSoundDeviceDirectSound.DefaultFlags );
+ }
+ public void tDirectSound繧ｵ繧ｦ繝ｳ繝峨ｒ菴懈舌☆繧( byte[] byArrWAV繝輔ぃ繧､繝ｫ繧､繝｡繝ｼ繧ｸ, DirectSound DirectSound, BufferFlags flags )
+ {
+ if( this.e菴懈先婿豕 == E菴懈先婿豕.Unknown )
+ this.e菴懈先婿豕 = E菴懈先婿豕.WAV繝輔ぃ繧､繝ｫ繧､繝｡繝ｼ繧ｸ縺九ｉ;
+
+ WaveFormat wfx = null;
+ int nPCM繝繝ｼ繧ｿ縺ｮ蜈磯ｭ繧､繝ｳ繝繝繧ｯ繧ｹ = -1;
+ int nPCM繧ｵ繧､繧ｺbyte = -1;
+
+ #region [ byArrWAV繝輔ぃ繧､繝ｫ繧､繝｡繝ｼ繧ｸ[] 縺九ｉ荳願ｨ假ｼ薙▽縺ｮ繝繝ｼ繧ｿ繧貞叙蠕励]
+ //-----------------
+ var ms = new MemoryStream( byArrWAV繝輔ぃ繧､繝ｫ繧､繝｡繝ｼ繧ｸ );
+ var br = new BinaryReader( ms );
+
+ try
+ {
+ // 'RIFF'ｼ騎IFF繝繝ｼ繧ｿ繧ｵ繧､繧ｺ
+
+ if( br.ReadUInt32() != 0x46464952 )
+ throw new InvalidDataException( "RIFF繝輔ぃ繧､繝ｫ縺ｧ縺ｯ縺ゅｊ縺ｾ縺帙ｓ縲" );
+ br.ReadInt32();
+
+ // 'WAVE'
+ if( br.ReadUInt32() != 0x45564157 )
+ throw new InvalidDataException( "WAVE繝輔ぃ繧､繝ｫ縺ｧ縺ｯ縺ゅｊ縺ｾ縺帙ｓ縲" );
+
+ // 繝√Ε繝ｳ繧ｯ
+ while( ( ms.Position + 8 ) < ms.Length ) // +8 縺ｯ縲√メ繝｣繝ｳ繧ｯ蜷搾ｼ九メ繝｣繝ｳ繧ｯ繧ｵ繧､繧ｺ縲よｮ九ｊ8繝舌う繝域悴貅縺ｪ繧峨Ν繝ｼ繝礼ｵゆｺ縲
+ {
+ uint chunkName = br.ReadUInt32();
+
+ // 'fmt '
+ if( chunkName == 0x20746D66 )
+ {
+ long chunkSize = (long) br.ReadUInt32();
+
+ var tag = (WaveFormatEncoding)br.ReadUInt16();
+ int Channels = br.ReadInt16();
+ int SamplesPerSecond = br.ReadInt32();
+ int AverageBytesPerSecond = br.ReadInt32();
+ int BlockAlignment = br.ReadInt16();
+ int BitsPerSample = br.ReadInt16();
+
+ if (tag == WaveFormatEncoding.Pcm) wfx = new WaveFormat();
+ else if (tag == WaveFormatEncoding.Extensible) wfx = new WaveFormatExtensible(SamplesPerSecond, BitsPerSample, Channels); // 縺薙ｮ繧ｯ繝ｩ繧ｹ縺ｯ WaveFormat 繧堤ｶ呎価縺励※縺繧九
+ else
+ throw new InvalidDataException( string.Format( "譛ｪ蟇ｾ蠢懊ｮWAVE繝輔か繝ｼ繝槭ャ繝医ち繧ｰ縺ｧ縺吶(Tag:{0})", tag.ToString() ) );
+
+ wfx = WaveFormat.CreateCustomFormat((WaveFormatEncoding)tag, SamplesPerSecond, Channels, AverageBytesPerSecond, BlockAlignment, BitsPerSample);
+
+ long n繝輔か繝ｼ繝槭ャ繝医し繧､繧ｺbyte = 16;
+
+ if (wfx.Encoding == WaveFormatEncoding.Extensible)
+ {
+ br.ReadUInt16(); // 諡｡蠑ｵ鬆伜沺繧ｵ繧､繧ｺbyte
+ var wfxEx = (SharpDX.Multimedia.WaveFormatExtensible)wfx;
+ int ValidBitsPerSample = br.ReadInt16();
+ wfxEx.ChannelMask = (Speakers) br.ReadInt32();
+ wfxEx.GuidSubFormat = new Guid(br.ReadBytes(16)); // GUID 縺ｯ 16byte (128bit)
+
+ n繝輔か繝ｼ繝槭ャ繝医し繧､繧ｺbyte += 24;
+ }
+
+ ms.Seek( chunkSize - n繝輔か繝ｼ繝槭ャ繝医し繧､繧ｺbyte, SeekOrigin.Current );
+ continue;
+ }
+
+ // 'data'
+ else if( chunkName == 0x61746164 )
+ {
+ nPCM繧ｵ繧､繧ｺbyte = br.ReadInt32();
+ nPCM繝繝ｼ繧ｿ縺ｮ蜈磯ｭ繧､繝ｳ繝繝繧ｯ繧ｹ = (int) ms.Position;
+
+ ms.Seek( nPCM繧ｵ繧､繧ｺbyte, SeekOrigin.Current );
+ continue;
+ }
+
+ // 縺昴ｮ莉
+ else
+ {
+ long chunkSize = (long) br.ReadUInt32();
+ ms.Seek( chunkSize, SeekOrigin.Current );
+ continue;
+ }
+ }
+
+ if( wfx == null )
+ throw new InvalidDataException( "fmt 繝√Ε繝ｳ繧ｯ縺悟ｭ伜惠縺励∪縺帙ｓ縲ゆｸ肴ｭ｣縺ｪ繧ｵ繧ｦ繝ｳ繝峨ョ繝ｼ繧ｿ縺ｧ縺吶" );
+ if( nPCM繧ｵ繧､繧ｺbyte < 0 )
+ throw new InvalidDataException( "data 繝√Ε繝ｳ繧ｯ縺悟ｭ伜惠縺励∪縺帙ｓ縲ゆｸ肴ｭ｣縺ｪ繧ｵ繧ｦ繝ｳ繝峨ョ繝ｼ繧ｿ縺ｧ縺吶" );
+ }
+ finally
+ {
+ ms.Close();
+ br.Close();
+ }
+ //-----------------
+ #endregion
+
+
+ // 繧ｻ繧ｫ繝ｳ繝繝ｪ繝舌ャ繝輔ぃ繧剃ｽ懈舌＠縲￣CM繝繝ｼ繧ｿ繧呈嶌縺崎ｾｼ繧縲
+ tDirectSound繧ｵ繧ｦ繝ｳ繝峨ｒ菴懈舌☆繧祇繧ｻ繧ｫ繝ｳ繝繝ｪ繝舌ャ繝輔ぃ縺ｮ菴懈舌→WAV繝繝ｼ繧ｿ譖ｸ縺崎ｾｼ縺ｿ(
+ ref byArrWAV繝輔ぃ繧､繝ｫ繧､繝｡繝ｼ繧ｸ, DirectSound, flags, wfx, nPCM繧ｵ繧､繧ｺbyte, nPCM繝繝ｼ繧ｿ縺ｮ蜈磯ｭ繧､繝ｳ繝繝繧ｯ繧ｹ );
+ }
+
+ private void tDirectSound繧ｵ繧ｦ繝ｳ繝峨ｒ菴懈舌☆繧祇繧ｻ繧ｫ繝ｳ繝繝ｪ繝舌ャ繝輔ぃ縺ｮ菴懈舌→WAV繝繝ｼ繧ｿ譖ｸ縺崎ｾｼ縺ｿ
+ ( ref byte[] byArrWAV繝輔ぃ繧､繝ｫ繧､繝｡繝ｼ繧ｸ, DirectSound DirectSound, BufferFlags flags, WaveFormat wfx,
+ int nPCM繧ｵ繧､繧ｺbyte, int nPCM繝繝ｼ繧ｿ縺ｮ蜈磯ｭ繧､繝ｳ繝繝繧ｯ繧ｹ )
+ {
+ this._Format = wfx;
+ // 繧ｻ繧ｫ繝ｳ繝繝ｪ繝舌ャ繝輔ぃ繧剃ｽ懈舌＠縲￣CM繝繝ｼ繧ｿ繧呈嶌縺崎ｾｼ繧縲
+
+ this.Buffer = new SecondarySoundBuffer( DirectSound, new SoundBufferDescription()
+ {
+ Format = (wfx.Encoding == WaveFormatEncoding.Pcm) ? wfx : (SharpDX.Multimedia.WaveFormatExtensible)wfx,
+ Flags = flags,
+ BufferBytes = nPCM繧ｵ繧､繧ｺbyte,
+ });
+ this.Buffer.Write( byArrWAV繝輔ぃ繧､繝ｫ繧､繝｡繝ｼ繧ｸ, nPCM繝繝ｼ繧ｿ縺ｮ蜈磯ｭ繧､繝ｳ繝繝繧ｯ繧ｹ, nPCM繧ｵ繧､繧ｺbyte, 0, LockFlags.None );
+
+ // 菴懈仙ｮ御ｺ縲
+
+ this.e繝繝舌う繧ｹ遞ｮ蛻･ = ESoundDeviceType.DirectSound;
+ this.DirectSoundBufferFlags = flags;
+ this.byArrWAV繝輔ぃ繧､繝ｫ繧､繝｡繝ｼ繧ｸ = byArrWAV繝輔ぃ繧､繝ｫ繧､繝｡繝ｼ繧ｸ;
+ this.DirectSound = DirectSound;
+
+ // DTXMania逕ｨ縺ｫ霑ｽ蜉
+ this.n繧ｪ繝ｪ繧ｸ繝翫Ν縺ｮ蜻ｨ豕｢謨ｰ = wfx.SampleRate;
+ n邱乗ｼ泌･乗凾髢杜s = (int)(((double)nPCM繧ｵ繧､繧ｺbyte) / (this._Format.AverageBytesPerSecond * 0.001));
+
+
+ // 繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ繝ｪ繧ｹ繝医↓逋ｻ骭ｲ縲
+
+ CSound.list繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ.Add( this );
+ }
+
+ #region [ DTXMania逕ｨ縺ｮ螟画鋤 ]
+
+ public void t繧ｵ繧ｦ繝ｳ繝峨ｒ遐ｴ譽縺吶ｋ( CSound cs )
+ {
+ cs.t隗｣謾ｾ縺吶ｋ();
+ }
+ public void t蜀咲函繧帝幕蟋九☆繧()
+ {
+ t蜀咲函菴咲ｽｮ繧貞磯ｭ縺ｫ謌ｻ縺();
+ if (!b騾溷ｺｦ荳翫£縺吶℃蝠城｡)
+ t繧ｵ繧ｦ繝ｳ繝峨ｒ蜀咲函縺吶ｋ(false);
+ }
+ public void t蜀咲函繧帝幕蟋九☆繧( bool b繝ｫ繝ｼ繝励☆繧 )
+ {
+ if ( bBASS繧ｵ繧ｦ繝ｳ繝峨〒縺ゅｋ )
+ {
+ if ( b繝ｫ繝ｼ繝励☆繧 )
+ {
+ Bass.BASS_ChannelFlags( this.hBassStream, BASSFlag.BASS_SAMPLE_LOOP, BASSFlag.BASS_SAMPLE_LOOP );
+ }
+ else
+ {
+ Bass.BASS_ChannelFlags( this.hBassStream, BASSFlag.BASS_DEFAULT, BASSFlag.BASS_DEFAULT );
+ }
+ }
+ t蜀咲函菴咲ｽｮ繧貞磯ｭ縺ｫ謌ｻ縺();
+ t繧ｵ繧ｦ繝ｳ繝峨ｒ蜀咲函縺吶ｋ( b繝ｫ繝ｼ繝励☆繧 );
+ }
+ public void t蜀咲函繧貞●豁｢縺吶ｋ()
+ {
+ t繧ｵ繧ｦ繝ｳ繝峨ｒ蛛懈ｭ｢縺吶ｋ();
+ t蜀咲函菴咲ｽｮ繧貞磯ｭ縺ｫ謌ｻ縺();
+ }
+ public void t蜀咲函繧剃ｸ譎ょ●豁｢縺吶ｋ()
+ {
+ t繧ｵ繧ｦ繝ｳ繝峨ｒ蛛懈ｭ｢縺吶ｋ(true);
+ this.n荳譎ょ●豁｢蝗樊焚++;
+ }
+ public void t蜀咲函繧貞埼幕縺吶ｋ( long t ) // 笘笘笘笘笘笘笘笘笘笘笘笘笘笘笘笘笘笘笘笘笘笘笘笘笘笘笘笘
+ {
+ Debug.WriteLine( "t蜀咲函繧貞埼幕縺吶ｋ(long " + t + ")" );
+ t蜀咲函菴咲ｽｮ繧貞､画峩縺吶ｋ( t );
+ t繧ｵ繧ｦ繝ｳ繝峨ｒ蜀咲函縺吶ｋ();
+ this.n荳譎ょ●豁｢蝗樊焚--;
+ }
+ public bool b荳譎ょ●豁｢荳ｭ
+ {
+ get
+ {
+ if ( this.bBASS繧ｵ繧ｦ繝ｳ繝峨〒縺ゅｋ )
+ {
+ bool ret = ( BassMix.BASS_Mixer_ChannelIsActive( this.hBassStream ) == BASSActive.BASS_ACTIVE_PAUSED ) &
+ ( BassMix.BASS_Mixer_ChannelGetPosition( this.hBassStream ) > 0 );
+ return ret;
+ }
+ else
+ {
+ return ( this.n荳譎ょ●豁｢蝗樊焚 > 0 );
+ }
+ }
+ }
+ public bool b蜀咲函荳ｭ
+ {
+ get
+ {
+ if ( this.e繝繝舌う繧ｹ遞ｮ蛻･ == ESoundDeviceType.DirectSound )
+ {
+ return ((this.Buffer.Status & (int)BufferStatus.Playing) != (int)BufferStatus.None);
+ }
+ else
+ {
+ // 蝓ｺ譛ｬ逧縺ｫ縺ｯBASS_ACTIVE_PLAYING縺ｪ繧牙咲函荳ｭ縺縺後∵怙蠕後∪縺ｧ蜀咲函縺励″縺｣縺歡hannel繧
+ // BASS_ACTIVE_PLAYING縺ｮ縺ｾ縺ｾ縺ｫ縺ｪ縺｣縺ｦ縺繧九ｮ縺ｧ縲∝ｰ冗ｴｰ蟾･縺悟ｿ隕√
+ bool ret = ( BassMix.BASS_Mixer_ChannelIsActive( this.hBassStream ) == BASSActive.BASS_ACTIVE_PLAYING );
+ if ( BassMix.BASS_Mixer_ChannelGetPosition( this.hBassStream ) >= nBytes )
+ {
+ ret = false;
+ }
+ return ret;
+ }
+ }
+ }
+ //public lint t譎ょ綾縺九ｉ菴咲ｽｮ繧定ｿ斐☆( long t )
+ //{
+ // double num = ( n譎ょ綾 * this.db蜀咲函騾溷ｺｦ ) * this.db蜻ｨ豕｢謨ｰ蛟咲紫;
+ // return (int) ( ( num * 0.01 ) * this.nSamplesPerSecond );
+ //}
+ #endregion
+
+
+ public void t隗｣謾ｾ縺吶ｋ()
+ {
+ t隗｣謾ｾ縺吶ｋ( false );
+ }
+
+ public void t隗｣謾ｾ縺吶ｋ( bool _b繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ蜑企勁 )
+ {
+ if ( this.bBASS繧ｵ繧ｦ繝ｳ繝峨〒縺ゅｋ ) // stream謨ｰ縺ｮ蜑頑ｸ帷畑
+ {
+ tBASS繧ｵ繧ｦ繝ｳ繝峨ｒ繝溘く繧ｵ繝ｼ縺九ｉ蜑企勁縺吶ｋ();
+ _cbEndofStream = null;
+ //_cbStreamXA = null;
+ CSound邂｡逅.nStreams--;
+ }
+ bool bManaged繧りｧ｣謾ｾ縺吶ｋ = true;
+ bool b繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ蜑企勁 = _b繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ蜑企勁; // CSound縺ｮ蜀榊晄悄蛹匁凾縺ｯ縲√う繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｯ蟄倡ｶ壹☆繧九
+ this.Dispose( bManaged繧りｧ｣謾ｾ縺吶ｋ, b繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ蜑企勁 );
+//Debug.WriteLine( "Disposed: " + _b繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ蜑企勁 + " : " + Path.GetFileName( this.str繝輔ぃ繧､繝ｫ蜷 ) );
+ }
+ public void t繧ｵ繧ｦ繝ｳ繝峨ｒ蜀咲函縺吶ｋ()
+ {
+ t繧ｵ繧ｦ繝ｳ繝峨ｒ蜀咲函縺吶ｋ( false );
+ }
+ private void t繧ｵ繧ｦ繝ｳ繝峨ｒ蜀咲函縺吶ｋ( bool b繝ｫ繝ｼ繝励☆繧 )
+ {
+ if ( this.bBASS繧ｵ繧ｦ繝ｳ繝峨〒縺ゅｋ ) // BASS繧ｵ繧ｦ繝ｳ繝画凾縺ｮ繝ｫ繝ｼ繝怜ｦ逅縺ｯ縲》蜀咲函繧帝幕蟋九☆繧()蛛ｴ縺ｫ螳溯｣縲ゅ％縺薙〒縺ｯ縲恵繝ｫ繝ｼ繝励☆繧九阪ｯ譛ｪ菴ｿ逕ｨ縲
+ {
+//Debug.WriteLine( "蜀咲函荳ｭ?: " + System.IO.Path.GetFileName(this.str繝輔ぃ繧､繝ｫ蜷) + " status=" + BassMix.BASS_Mixer_ChannelIsActive( this.hBassStream ) + " current=" + BassMix.BASS_Mixer_ChannelGetPosition( this.hBassStream ) + " nBytes=" + nBytes );
+ bool b = BassMix.BASS_Mixer_ChannelPlay( this.hBassStream );
+ if ( !b )
+ {
+//Debug.WriteLine( "蜀咲函縺励ｈ縺縺ｨ縺励◆縺後｀ixer縺ｫ逋ｻ骭ｲ縺輔ｌ縺ｦ縺縺ｪ縺九▲縺: " + Path.GetFileName( this.str繝輔ぃ繧､繝ｫ蜷 ) + ", stream#=" + this.hBassStream + ", ErrCode=" + Bass.BASS_ErrorGetCode() );
+
+ bool bb = tBASS繧ｵ繧ｦ繝ｳ繝峨ｒ繝溘く繧ｵ繝ｼ縺ｫ霑ｽ蜉縺吶ｋ();
+ if ( !bb )
+ {
+Debug.WriteLine( "Mixer縺ｸ縺ｮ逋ｻ骭ｲ縺ｫ螟ｱ謨: " + Path.GetFileName( this.str繝輔ぃ繧､繝ｫ蜷 ) + ", ErrCode=" + Bass.BASS_ErrorGetCode() );
+ }
+ else
+ {
+//Debug.WriteLine( "Mixer縺ｸ縺ｮ逋ｻ骭ｲ縺ｫ謌仙粥: " + Path.GetFileName( this.str繝輔ぃ繧､繝ｫ蜷 ) + ": " + Bass.BASS_ErrorGetCode() );
+ }
+ //this.t蜀咲函菴咲ｽｮ繧貞磯ｭ縺ｫ謌ｻ縺();
+
+ bool bbb = BassMix.BASS_Mixer_ChannelPlay( this.hBassStream );
+ if (!bbb)
+ {
+Debug.WriteLine("譖ｴ縺ｫ蜀咲函縺ｫ螟ｱ謨: " + Path.GetFileName(this.str繝輔ぃ繧､繝ｫ蜷) + ", ErrCode=" + Bass.BASS_ErrorGetCode() );
+ }
+ else
+ {
+// Debug.WriteLine("蜀咲函謌仙粥(繝溘く繧ｵ繝ｼ霑ｽ蜉蠕) : " + Path.GetFileName(this.str繝輔ぃ繧､繝ｫ蜷));
+ }
+ }
+ else
+ {
+//Debug.WriteLine( "蜀咲函謌仙粥: " + Path.GetFileName( this.str繝輔ぃ繧､繝ｫ蜷 ) + " (" + hBassStream + ")" );
+ }
+ }
+ else if( this.bDirectSound縺ｧ縺ゅｋ )
+ {
+ PlayFlags pf = ( b繝ｫ繝ｼ繝励☆繧 ) ? PlayFlags.Looping : PlayFlags.None;
+ this.Buffer.Play( 0, pf );
+ }
+ }
+ public void t繧ｵ繧ｦ繝ｳ繝峨ｒ蛛懈ｭ｢縺励※Mixer縺九ｉ繧ょ炎髯､縺吶ｋ()
+ {
+ t繧ｵ繧ｦ繝ｳ繝峨ｒ蛛懈ｭ｢縺吶ｋ( false );
+ if ( bBASS繧ｵ繧ｦ繝ｳ繝峨〒縺ゅｋ )
+ {
+ tBASS繧ｵ繧ｦ繝ｳ繝峨ｒ繝溘く繧ｵ繝ｼ縺九ｉ蜑企勁縺吶ｋ();
+ }
+ }
+ public void t繧ｵ繧ｦ繝ｳ繝峨ｒ蛛懈ｭ｢縺吶ｋ()
+ {
+ t繧ｵ繧ｦ繝ｳ繝峨ｒ蛛懈ｭ｢縺吶ｋ( false );
+ }
+ public void t繧ｵ繧ｦ繝ｳ繝峨ｒ蛛懈ｭ｢縺吶ｋ( bool pause )
+ {
+ if( this.bBASS繧ｵ繧ｦ繝ｳ繝峨〒縺ゅｋ )
+ {
+//Debug.WriteLine( "蛛懈ｭ｢: " + System.IO.Path.GetFileName( this.str繝輔ぃ繧､繝ｫ蜷 ) + " status=" + BassMix.BASS_Mixer_ChannelIsActive( this.hBassStream ) + " current=" + BassMix.BASS_Mixer_ChannelGetPosition( this.hBassStream ) + " nBytes=" + nBytes );
+ BassMix.BASS_Mixer_ChannelPause( this.hBassStream );
+ if ( !pause )
+ {
+ // tBASS繧ｵ繧ｦ繝ｳ繝峨ｒ繝溘く繧ｵ繝ｼ縺九ｉ蜑企勁縺吶ｋ(); // PAUSE縺ｨ蜀咲函蛛懈ｭ｢繧貞玄蛻･縺ｧ縺阪ｋ繧医≧縺ｫ縺吶ｋ縺薙→!!
+ }
+ }
+ else if( this.bDirectSound縺ｧ縺ゅｋ )
+ {
+ try
+ {
+ this.Buffer.Stop();
+ }
+ catch ( Exception )
+ {
+ // WASAPI/ASIO縺ｨDirectSound繧貞酔譎ゆｽｿ逕ｨ縺吶ｋ縺ｨ縲。uffer縺畦ost縺励※縺薙％縺ｧ萓句､也匱逕溘☆繧九や catch縺励※辟｡隕悶☆繧九
+ // DTXC縺九ｉDTXMania繧貞他縺ｳ蜃ｺ縺吶→縲．TXC邨ゆｺ譎ゅ↓縺薙ｮ迴ｾ雎｡縺檎匱逕溘☆繧九
+ }
+ }
+ this.n荳譎ょ●豁｢蝗樊焚 = 0;
+ }
+
+ public void t蜀咲函菴咲ｽｮ繧貞磯ｭ縺ｫ謌ｻ縺()
+ {
+ if( this.bBASS繧ｵ繧ｦ繝ｳ繝峨〒縺ゅｋ )
+ {
+ BassMix.BASS_Mixer_ChannelSetPosition( this.hBassStream, 0 );
+ //pos = 0;
+ }
+ else if( this.bDirectSound縺ｧ縺ゅｋ )
+ {
+ this.Buffer.CurrentPosition = 0;
+ }
+ }
+ public void t蜀咲函菴咲ｽｮ繧貞､画峩縺吶ｋ( long n菴咲ｽｮms )
+ {
+ if( this.bBASS繧ｵ繧ｦ繝ｳ繝峨〒縺ゅｋ )
+ {
+ bool b = true;
+ try
+ {
+ b = BassMix.BASS_Mixer_ChannelSetPosition( this.hBassStream, Bass.BASS_ChannelSeconds2Bytes( this.hBassStream, n菴咲ｽｮms * this.db蜻ｨ豕｢謨ｰ蛟咲紫 * this.db蜀咲函騾溷ｺｦ / 1000.0 ), BASSMode.BASS_POS_BYTES );
+ }
+ catch( Exception e )
+ {
+ Trace.TraceError( e.ToString() );
+ Trace.TraceInformation( Path.GetFileName( this.str繝輔ぃ繧､繝ｫ蜷 ) + ": Seek error: " + e.ToString() + ": " + n菴咲ｽｮms + "ms" );
+ }
+ finally
+ {
+ if ( !b )
+ {
+ BASSError be = Bass.BASS_ErrorGetCode();
+ Trace.TraceInformation( Path.GetFileName( this.str繝輔ぃ繧､繝ｫ蜷 ) + ": Seek error: " + be.ToString() + ": " + n菴咲ｽｮms + "MS" );
+ }
+ }
+ //if ( this.n邱乗ｼ泌･乗凾髢杜s > 5000 )
+ //{
+ // Trace.TraceInformation( Path.GetFileName( this.str繝輔ぃ繧､繝ｫ蜷 ) + ": Seeked to " + n菴咲ｽｮms + "ms = " + Bass.BASS_ChannelSeconds2Bytes( this.hBassStream, n菴咲ｽｮms * this.db蜻ｨ豕｢謨ｰ蛟咲紫 * this.db蜀咲函騾溷ｺｦ / 1000.0 ) );
+ //}
+ }
+ else if( this.bDirectSound縺ｧ縺ゅｋ )
+ {
+ int n菴咲ｽｮsample = (int)(this._Format.SampleRate * n菴咲ｽｮms * 0.001 * _db蜻ｨ豕｢謨ｰ蛟咲紫 * _db蜀咲函騾溷ｺｦ); // #30839 2013.2.24 yyagi; add _db蜻ｨ豕｢謨ｰ蛟咲紫 and _db蜀咲函騾溷ｺｦ
+ try
+ {
+ this.Buffer.CurrentPosition = n菴咲ｽｮsample * this._Format.BlockAlign;
+ }
+ catch
+ {
+ Trace.TraceError( "{0}: Seek error: {1}", Path.GetFileName( this.str繝輔ぃ繧､繝ｫ蜷 ), n菴咲ｽｮms);
+ Trace.TraceError( "萓句､悶′逋ｺ逕溘＠縺ｾ縺励◆縺悟ｦ逅繧堤ｶ咏ｶ壹＠縺ｾ縺吶 (95dee242-1f92-4fcf-aaf6-b162ad2bfc03)" );
+ }
+ //if ( this.n邱乗ｼ泌･乗凾髢杜s > 5000 )
+ //{
+ // Trace.TraceInformation( Path.GetFileName( this.str繝輔ぃ繧､繝ｫ蜷 ) + ": Seeked to " + n菴咲ｽｮms + "ms = " + n菴咲ｽｮsample );
+ //}
+ }
+ }
+ ///
+ /// 繝繝舌ャ繧ｰ逕ｨ
+ ///
+ ///
+ ///
+ public void t蜀咲函菴咲ｽｮ繧貞叙蠕励☆繧( out long n菴咲ｽｮbyte, out double db菴咲ｽｮms )
+ {
+ if ( this.bBASS繧ｵ繧ｦ繝ｳ繝峨〒縺ゅｋ )
+ {
+ n菴咲ｽｮbyte = BassMix.BASS_Mixer_ChannelGetPosition( this.hBassStream );
+ db菴咲ｽｮms = Bass.BASS_ChannelBytes2Seconds( this.hBassStream, n菴咲ｽｮbyte );
+ }
+ else if ( this.bDirectSound縺ｧ縺ゅｋ )
+ {
+ this.Buffer.GetCurrentPosition(out int n菴咲ｽｮtmp, out int _);
+ n菴咲ｽｮbyte = (long)n菴咲ｽｮtmp;
+ db菴咲ｽｮms = n菴咲ｽｮbyte / this._Format.SampleRate / 0.001 / _db蜻ｨ豕｢謨ｰ蛟咲紫 / _db蜀咲函騾溷ｺｦ;
+ }
+ else
+ {
+ n菴咲ｽｮbyte = 0;
+ db菴咲ｽｮms = 0.0;
+ }
+ }
+
+
+ public static void t縺吶∋縺ｦ縺ｮ繧ｵ繧ｦ繝ｳ繝峨ｒ蛻晄悄迥ｶ諷九↓謌ｻ縺()
+ {
+ foreach ( var sound in CSound.list繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ )
+ {
+ sound.t隗｣謾ｾ縺吶ｋ( false );
+ }
+ }
+ internal static void t縺吶∋縺ｦ縺ｮ繧ｵ繧ｦ繝ｳ繝峨ｒ蜀肴ｧ狗ｯ峨☆繧( ISoundDevice device )
+ {
+ if( CSound.list繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ.Count == 0 )
+ return;
+
+
+ // 繧ｵ繧ｦ繝ｳ繝峨ｒ蜀咲函縺吶ｋ髫帙↓繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ繝ｪ繧ｹ繝医ｂ譖ｴ譁ｰ縺輔ｌ繧九ｮ縺ｧ縲驟榊励↓繧ｳ繝斐ｼ繧貞叙縺｣縺ｦ縺翫″縲√Μ繧ｹ繝医ｯ繧ｯ繝ｪ繧｢縺吶ｋ縲
+
+ var sounds = CSound.list繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ.ToArray();
+ CSound.list繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ.Clear();
+
+
+ // 驟榊励↓蝓ｺ縺･縺縺ｦ蛟九縺ｮ繧ｵ繧ｦ繝ｳ繝峨ｒ菴懈舌☆繧九
+
+ for( int i = 0; i < sounds.Length; i++ )
+ {
+ switch( sounds[ i ].e菴懈先婿豕 )
+ {
+ #region [ 繝輔ぃ繧､繝ｫ縺九ｉ ]
+ case E菴懈先婿豕.繝輔ぃ繧､繝ｫ縺九ｉ:
+ string str繝輔ぃ繧､繝ｫ蜷 = sounds[ i ].str繝輔ぃ繧､繝ｫ蜷;
+ sounds[ i ].Dispose( true, false );
+ device.t繧ｵ繧ｦ繝ｳ繝峨ｒ菴懈舌☆繧( str繝輔ぃ繧､繝ｫ蜷, sounds[ i ] );
+ break;
+ #endregion
+ #region [ WAV繝輔ぃ繧､繝ｫ繧､繝｡繝ｼ繧ｸ縺九ｉ ]
+ case E菴懈先婿豕.WAV繝輔ぃ繧､繝ｫ繧､繝｡繝ｼ繧ｸ縺九ｉ:
+ if( sounds[ i ].bBASS繧ｵ繧ｦ繝ｳ繝峨〒縺ゅｋ )
+ {
+ byte[] byArrWave繝輔ぃ繧､繝ｫ繧､繝｡繝ｼ繧ｸ = sounds[ i ].byArrWAV繝輔ぃ繧､繝ｫ繧､繝｡繝ｼ繧ｸ;
+ sounds[ i ].Dispose( true, false );
+ device.t繧ｵ繧ｦ繝ｳ繝峨ｒ菴懈舌☆繧( byArrWave繝輔ぃ繧､繝ｫ繧､繝｡繝ｼ繧ｸ, sounds[ i ] );
+ }
+ else if( sounds[ i ].bDirectSound縺ｧ縺ゅｋ )
+ {
+ byte[] byArrWave繝輔ぃ繧､繝ｫ繧､繝｡繝ｼ繧ｸ = sounds[ i ].byArrWAV繝輔ぃ繧､繝ｫ繧､繝｡繝ｼ繧ｸ;
+ var flags = sounds[ i ].DirectSoundBufferFlags;
+ sounds[ i ].Dispose( true, false );
+ ( (CSoundDeviceDirectSound) device ).t繧ｵ繧ｦ繝ｳ繝峨ｒ菴懈舌☆繧( byArrWave繝輔ぃ繧､繝ｫ繧､繝｡繝ｼ繧ｸ, flags, sounds[ i ] );
+ }
+ break;
+ #endregion
+ }
+ }
+ }
+
+ #region [ Dispose-Finalize繝代ち繝ｼ繝ｳ螳溯｣ ]
+ //-----------------
+ public void Dispose()
+ {
+ this.Dispose( true, true );
+ GC.SuppressFinalize( this );
+ }
+ private void Dispose( bool bManaged繧りｧ｣謾ｾ縺吶ｋ, bool b繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ蜑企勁 )
+ {
+ if( this.bBASS繧ｵ繧ｦ繝ｳ繝峨〒縺ゅｋ )
+ {
+ #region [ ASIO, WASAPI 縺ｮ隗｣謾ｾ ]
+ //-----------------
+ if ( _hTempoStream != 0 )
+ {
+ BassMix.BASS_Mixer_ChannelRemove( this._hTempoStream );
+ Bass.BASS_StreamFree( this._hTempoStream );
+ }
+ BassMix.BASS_Mixer_ChannelRemove( this._hBassStream );
+ Bass.BASS_StreamFree( this._hBassStream );
+ this.hBassStream = -1;
+ this._hBassStream = -1;
+ this._hTempoStream = 0;
+ //-----------------
+ #endregion
+ }
+
+ if( bManaged繧りｧ｣謾ｾ縺吶ｋ )
+ {
+ //int freeIndex = -1;
+
+ //if ( CSound.list繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ != null )
+ //{
+ // freeIndex = CSound.list繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ.IndexOf( this );
+ // if ( freeIndex == -1 )
+ // {
+ // Debug.WriteLine( "ERR: freeIndex==-1 : Count=" + CSound.list繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ.Count + ", filename=" + Path.GetFileName( this.str繝輔ぃ繧､繝ｫ蜷 ) );
+ // }
+ //}
+
+ if( this.e繝繝舌う繧ｹ遞ｮ蛻･ == ESoundDeviceType.DirectSound )
+ {
+ #region [ DirectSound 縺ｮ隗｣謾ｾ ]
+ //-----------------
+ if( this.Buffer != null )
+ {
+ try
+ {
+ this.Buffer.Stop();
+ }
+ catch (Exception e)
+ {
+ // 貍泌･冗ｵゆｺ蠕後髟ｷ譎る俣隗｣謾ｾ縺励↑縺縺ｧ縺繧九→縲√◆縺ｾ縺ｫ AccessViolationException 縺檎匱逕溘☆繧九％縺ｨ縺後≠繧九
+ Trace.TraceError( e.ToString() );
+ Trace.TraceError( "萓句､悶′逋ｺ逕溘＠縺ｾ縺励◆縺悟ｦ逅繧堤ｶ咏ｶ壹＠縺ｾ縺吶 (19bcaa24-5259-4198-bf74-41eb1114ba28)" );
+ }
+ C蜈ｱ騾.tDispose縺吶ｋ( ref this.Buffer );
+ }
+ //-----------------
+ #endregion
+ }
+
+ if( this.e菴懈先婿豕 == E菴懈先婿豕.WAV繝輔ぃ繧､繝ｫ繧､繝｡繝ｼ繧ｸ縺九ｉ &&
+ this.e繝繝舌う繧ｹ遞ｮ蛻･ != ESoundDeviceType.DirectSound ) // DirectSound 縺ｯ hGC 譛ｪ菴ｿ逕ｨ縲
+ {
+ if ( this.hGC != null && this.hGC.IsAllocated )
+ {
+ this.hGC.Free();
+ this.hGC = default( GCHandle );
+ }
+ }
+ if ( this.byArrWAV繝輔ぃ繧､繝ｫ繧､繝｡繝ｼ繧ｸ != null )
+ {
+ this.byArrWAV繝輔ぃ繧､繝ｫ繧､繝｡繝ｼ繧ｸ = null;
+ }
+
+ this.e繝繝舌う繧ｹ遞ｮ蛻･ = ESoundDeviceType.Unknown;
+
+ if ( b繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ蜑企勁 )
+ {
+ //try
+ //{
+ // CSound.list繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ.RemoveAt( freeIndex );
+ //}
+ //catch
+ //{
+ // Debug.WriteLine( "FAILED to remove CSound.list繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ: Count=" + CSound.list繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ.Count + ", filename=" + Path.GetFileName( this.str繝輔ぃ繧､繝ｫ蜷 ) );
+ //}
+ bool b = CSound.list繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ.Remove( this ); // 縺薙ｌ縺縺ｨ縲，lone()縺励◆繧ｵ繧ｦ繝ｳ繝峨ｮremove縺ｫ螟ｱ謨励☆繧
+ if ( !b )
+ {
+ Debug.WriteLine( "FAILED to remove CSound.list繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ: Count=" + CSound.list繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ.Count + ", filename=" + Path.GetFileName( this.str繝輔ぃ繧､繝ｫ蜷 ) );
+ }
+
+ }
+ }
+ }
+ ~CSound()
+ {
+ this.Dispose( false, true );
+ }
+ //-----------------
+ #endregion
+
+ #region [ protected ]
+ //-----------------
+ protected enum E菴懈先婿豕 { 繝輔ぃ繧､繝ｫ縺九ｉ, WAV繝輔ぃ繧､繝ｫ繧､繝｡繝ｼ繧ｸ縺九ｉ, Unknown }
+ protected E菴懈先婿豕 e菴懈先婿豕 = E菴懈先婿豕.Unknown;
+ protected ESoundDeviceType e繝繝舌う繧ｹ遞ｮ蛻･ = ESoundDeviceType.Unknown;
+ public string str繝輔ぃ繧､繝ｫ蜷 = null;
+ protected byte[] byArrWAV繝輔ぃ繧､繝ｫ繧､繝｡繝ｼ繧ｸ = null; // WAV繝輔ぃ繧､繝ｫ繧､繝｡繝ｼ繧ｸ縲√ｂ縺励￥縺ｯchunk縺ｮDATA驛ｨ縺ｮ縺ｿ
+ protected GCHandle hGC;
+ protected int _hTempoStream = 0;
+ protected int _hBassStream = -1; // ASIO, WASAPI 逕ｨ
+ protected int hBassStream = 0; // #31076 2013.4.1 yyagi; 繝励Ο繝代ユ繧｣縺ｨ縺励※螳溯｣縺吶ｋ縺ｨ蜍穂ｽ懊′菴朱溘↓縺ｪ縺｣縺溘◆繧√
+ // tBASS繧ｵ繧ｦ繝ｳ繝峨ｒ菴懈舌☆繧祇繧ｹ繝医Μ繝ｼ繝逕滓仙ｾ後ｮ蜈ｱ騾壼ｦ逅()縺ｮ繧ｿ繧､繝溘Φ繧ｰ縺ｨ縲
+ // 蜀咲函騾溷ｺｦ繧貞､画峩縺励◆繧ｿ繧､繝溘Φ繧ｰ縺ｧ縺ｮ縺ｿ縲
+ // hBassStream繧呈峩譁ｰ縺吶ｋ繧医≧縺ｫ縺励◆縲
+ //{
+ // get
+ // {
+ // if ( _hTempoStream != 0 && !this.bIs1蛟埼溷咲函 ) // 蜀咲函騾溷ｺｦ縺警1.000縺ｮ縺ｨ縺阪ｯ縲ゝempoStream繧堤畑縺縺ｪ縺繧医≧縺ｫ縺励※鬮倬溷喧縺吶ｋ
+ // {
+ // return _hTempoStream;
+ // }
+ // else
+ // {
+ // return _hBassStream;
+ // }
+ // }
+ // set
+ // {
+ // _hBassStream = value;
+ // }
+ //}
+ protected SoundBuffer Buffer = null; // DirectSound 逕ｨ
+ protected DirectSound DirectSound;
+ protected int hMixer = -1; // 險ｭ險亥｣翫＠縺ｦ繧ｴ繝｡繝ｳ Mixer縺ｫ蠕後〒逋ｻ骭ｲ縺吶ｋ縺ｨ縺阪↓菴ｿ縺
+ //-----------------
+ #endregion
+
+ #region [ private ]
+ //-----------------
+ private bool bDirectSound縺ｧ縺ゅｋ
+ {
+ get { return ( this.e繝繝舌う繧ｹ遞ｮ蛻･ == ESoundDeviceType.DirectSound ); }
+ }
+ private bool bBASS繧ｵ繧ｦ繝ｳ繝峨〒縺ゅｋ
+ {
+ get
+ {
+ return (
+ this.e繝繝舌う繧ｹ遞ｮ蛻･ == ESoundDeviceType.ASIO ||
+ this.e繝繝舌う繧ｹ遞ｮ蛻･ == ESoundDeviceType.ExclusiveWASAPI ||
+ this.e繝繝舌う繧ｹ遞ｮ蛻･ == ESoundDeviceType.SharedWASAPI );
+ }
+ }
+ private int _n菴咲ｽｮ = 0;
+ private int _n菴咲ｽｮdb;
+ private Lufs _gain = DefaultGain;
+ private Lufs? _truePeak = null;
+ private int _automationLevel = DefaultAutomationLevel;
+ private int _groupLevel = DefaultGroupLevel;
+ private long nBytes = 0;
+ private int n荳譎ょ●豁｢蝗樊焚 = 0;
+ private int n繧ｪ繝ｪ繧ｸ繝翫Ν縺ｮ蜻ｨ豕｢謨ｰ = 0;
+ private double _db蜻ｨ豕｢謨ｰ蛟咲紫 = 1.0;
+ private double _db蜀咲函騾溷ｺｦ = 1.0;
+ private bool bIs1蛟埼溷咲函 = true;
+ private WaveFormat _Format;
+
+ private void tBASS繧ｵ繧ｦ繝ｳ繝峨ｒ菴懈舌☆繧( string str繝輔ぃ繧､繝ｫ蜷, int hMixer, BASSFlag flags )
+ {
+ #region [ xa縺ｨwav(RIFF chunked vorbis)縺ｫ蟇ｾ縺励※縺ｯ蟆ら畑縺ｮ蜃ｦ逅繧偵☆繧 ]
+ switch ( Path.GetExtension( str繝輔ぃ繧､繝ｫ蜷 ).ToLower() )
+ {
+ case ".xa":
+ tBASS繧ｵ繧ｦ繝ｳ繝峨ｒ菴懈舌☆繧宜A( str繝輔ぃ繧､繝ｫ蜷, hMixer, flags );
+ return;
+
+ case ".wav":
+ if ( tRIFFchunkedVorbis縺ｪ繧吋irectShow縺ｧDecode縺吶ｋ( str繝輔ぃ繧､繝ｫ蜷, ref byArrWAV繝輔ぃ繧､繝ｫ繧､繝｡繝ｼ繧ｸ ) )
+ {
+ tBASS繧ｵ繧ｦ繝ｳ繝峨ｒ菴懈舌☆繧( byArrWAV繝輔ぃ繧､繝ｫ繧､繝｡繝ｼ繧ｸ, hMixer, flags );
+ return;
+ }
+ break;
+
+ default:
+ break;
+ }
+ #endregion
+
+ this.e菴懈先婿豕 = E菴懈先婿豕.繝輔ぃ繧､繝ｫ縺九ｉ;
+ this.str繝輔ぃ繧､繝ｫ蜷 = str繝輔ぃ繧､繝ｫ蜷;
+
+
+ // BASS繝輔ぃ繧､繝ｫ繧ｹ繝医Μ繝ｼ繝繧剃ｽ懈舌
+
+ this._hBassStream = Bass.BASS_StreamCreateFile( str繝輔ぃ繧､繝ｫ蜷, 0, 0, flags );
+ if( this._hBassStream == 0 )
+ throw new Exception( string.Format( "繧ｵ繧ｦ繝ｳ繝峨せ繝医Μ繝ｼ繝縺ｮ逕滓舌↓螟ｱ謨励＠縺ｾ縺励◆縲(BASS_StreamCreateFile)[{0}]", Bass.BASS_ErrorGetCode().ToString() ) );
+
+ nBytes = Bass.BASS_ChannelGetLength( this._hBassStream );
+
+ tBASS繧ｵ繧ｦ繝ｳ繝峨ｒ菴懈舌☆繧祇繧ｹ繝医Μ繝ｼ繝逕滓仙ｾ後ｮ蜈ｱ騾壼ｦ逅( hMixer );
+ }
+ private void tBASS繧ｵ繧ｦ繝ｳ繝峨ｒ菴懈舌☆繧( byte[] byArrWAV繝輔ぃ繧､繝ｫ繧､繝｡繝ｼ繧ｸ, int hMixer, BASSFlag flags )
+ {
+ this.e菴懈先婿豕 = E菴懈先婿豕.WAV繝輔ぃ繧､繝ｫ繧､繝｡繝ｼ繧ｸ縺九ｉ;
+ this.byArrWAV繝輔ぃ繧､繝ｫ繧､繝｡繝ｼ繧ｸ = byArrWAV繝輔ぃ繧､繝ｫ繧､繝｡繝ｼ繧ｸ;
+ this.hGC = GCHandle.Alloc( byArrWAV繝輔ぃ繧､繝ｫ繧､繝｡繝ｼ繧ｸ, GCHandleType.Pinned ); // byte[] 繧偵ヴ繝ｳ逡吶ａ
+
+
+ // BASS繝輔ぃ繧､繝ｫ繧ｹ繝医Μ繝ｼ繝繧剃ｽ懈舌
+
+ this._hBassStream = Bass.BASS_StreamCreateFile( hGC.AddrOfPinnedObject(), 0, byArrWAV繝輔ぃ繧､繝ｫ繧､繝｡繝ｼ繧ｸ.Length, flags );
+ if ( this._hBassStream == 0 )
+ throw new Exception( string.Format( "繧ｵ繧ｦ繝ｳ繝峨せ繝医Μ繝ｼ繝縺ｮ逕滓舌↓螟ｱ謨励＠縺ｾ縺励◆縲(BASS_StreamCreateFile)[{0}]", Bass.BASS_ErrorGetCode().ToString() ) );
+
+ nBytes = Bass.BASS_ChannelGetLength( this._hBassStream );
+
+ tBASS繧ｵ繧ｦ繝ｳ繝峨ｒ菴懈舌☆繧祇繧ｹ繝医Μ繝ｼ繝逕滓仙ｾ後ｮ蜈ｱ騾壼ｦ逅( hMixer );
+ }
+
+ ///
+ /// Decode "RIFF chunked Vorbis" to "raw wave"
+ /// because BASE.DLL has two problems for RIFF chunked Vorbis;
+ /// 1. time seek is not fine 2. delay occurs (about 10ms)
+ ///
+ /// wave filename
+ /// wav file image
+ ///
+ private bool tRIFFchunkedVorbis縺ｪ繧吋irectShow縺ｧDecode縺吶ｋ( string str繝輔ぃ繧､繝ｫ蜷, ref byte[] byArrWAV繝輔ぃ繧､繝ｫ繧､繝｡繝ｼ繧ｸ )
+ {
+ bool b繝輔ぃ繧､繝ｫ縺ｫVorbis繧ｳ繝ｳ繝繝翫′蜷ｫ縺ｾ繧後※縺繧 = false;
+
+ #region [ 繝輔ぃ繧､繝ｫ縺係AV縺九▽縲〃orbis繧ｳ繝ｳ繝繝翫′蜷ｫ縺ｾ繧後※縺繧九°繧定ｪｿ縺ｹ縲√◎繧後↓隧ｲ蠖薙☆繧九↑繧峨．irectShow縺ｧ繝繧ｳ繝ｼ繝峨☆繧九]
+ //-----------------
+ try
+ {
+ Stream str = File.Open(str繝輔ぃ繧､繝ｫ蜷, FileMode.Open, FileAccess.Read);
+ using (var ws = new SoundStream(str))
+ {
+ if (ws.Format.Encoding == (WaveFormatEncoding)0x6770 || // Ogg Vorbis Mode 2+
+ ws.Format.Encoding == (WaveFormatEncoding)0x6771) // Ogg Vorbis Mode 3+
+ {
+ Trace.TraceInformation( Path.GetFileName( str繝輔ぃ繧､繝ｫ蜷 ) + ": RIFF chunked Vorbis. Decode to raw Wave first, to avoid BASS.DLL troubles" );
+ try
+ {
+ CDStoWAVFileImage.t螟画鋤( str繝輔ぃ繧､繝ｫ蜷, out byArrWAV繝輔ぃ繧､繝ｫ繧､繝｡繝ｼ繧ｸ );
+ b繝輔ぃ繧､繝ｫ縺ｫVorbis繧ｳ繝ｳ繝繝翫′蜷ｫ縺ｾ繧後※縺繧 = true;
+ }
+ catch
+ {
+ Trace.TraceWarning( "Warning: " + Path.GetFileName( str繝輔ぃ繧､繝ｫ蜷 ) + " : RIFF chunked Vorbis縺ｮ繝繧ｳ繝ｼ繝峨↓螟ｱ謨励＠縺ｾ縺励◆縲" );
+ }
+ }
+ }
+ }
+ catch ( InvalidDataException )
+ {
+ // DirectShow縺ｮ繝繧ｳ繝ｼ繝峨↓螟ｱ謨励＠縺溘ｉ縲∵ｬ｡縺ｯACM縺ｧ縺ｮ繝繧ｳ繝ｼ繝峨ｒ隧ｦ縺吶％縺ｨ縺ｫ縺ｪ繧九◆繧√√％縺薙〒縺ｯ繧ｨ繝ｩ繝ｼ繝ｭ繧ｰ繧貞ｺ縺輔↑縺縲
+ // Trace.TraceWarning( "Warning: " + Path.GetFileName( str繝輔ぃ繧､繝ｫ蜷 ) + " : 繝繧ｳ繝ｼ繝峨↓螟ｱ謨励＠縺ｾ縺励◆縲" );
+ }
+ catch ( Exception e )
+ {
+ Trace.TraceWarning( e.ToString() );
+ Trace.TraceWarning( "Warning: " + Path.GetFileName( str繝輔ぃ繧､繝ｫ蜷 ) + " : 隱ｭ縺ｿ霎ｼ縺ｿ縺ｫ螟ｱ謨励＠縺ｾ縺励◆縲" );
+ }
+ #endregion
+
+ return b繝輔ぃ繧､繝ｫ縺ｫVorbis繧ｳ繝ｳ繝繝翫′蜷ｫ縺ｾ繧後※縺繧;
+ }
+
+ private void tBASS繧ｵ繧ｦ繝ｳ繝峨ｒ菴懈舌☆繧宜A( string str繝輔ぃ繧､繝ｫ蜷, int hMixer, BASSFlag flags )
+ {
+ int nPCM繝繝ｼ繧ｿ縺ｮ蜈磯ｭ繧､繝ｳ繝繝繧ｯ繧ｹ;
+ CWin32.WAVEFORMATEX wfx;
+ int totalPCMSize;
+
+ t繧ｪ繝ｳ繝｡繝｢繝ｪ譁ｹ蠑上〒繝繧ｳ繝ｼ繝峨☆繧( str繝輔ぃ繧､繝ｫ蜷, out this.byArrWAV繝輔ぃ繧､繝ｫ繧､繝｡繝ｼ繧ｸ,
+ out nPCM繝繝ｼ繧ｿ縺ｮ蜈磯ｭ繧､繝ｳ繝繝繧ｯ繧ｹ, out totalPCMSize, out wfx, true );
+
+ nBytes = totalPCMSize;
+
+ this.e菴懈先婿豕 = E菴懈先婿豕.WAV繝輔ぃ繧､繝ｫ繧､繝｡繝ｼ繧ｸ縺九ｉ; //.繝輔ぃ繧､繝ｫ縺九ｉ; // 蜀肴ｧ狗ｯ画凾縺ｯ繝繧ｳ繝ｼ繝牙ｾ後ｮ繧､繝｡繝ｼ繧ｸ繧呈ｵ∫畑縺吶ｋ&Dispose譎ゅ↓hGC繧定ｧ｣謾ｾ縺吶ｋ
+ this.str繝輔ぃ繧､繝ｫ蜷 = str繝輔ぃ繧､繝ｫ蜷;
+ this.hGC = GCHandle.Alloc( this.byArrWAV繝輔ぃ繧､繝ｫ繧､繝｡繝ｼ繧ｸ, GCHandleType.Pinned ); // byte[] 繧偵ヴ繝ｳ逡吶ａ
+
+ //_cbStreamXA = new STREAMPROC( CallbackPlayingXA );
+
+ // BASS繝輔ぃ繧､繝ｫ繧ｹ繝医Μ繝ｼ繝繧剃ｽ懈舌
+
+ //this.hBassStream = Bass.BASS_StreamCreate( xa.xaheader.nSamplesPerSec, xa.xaheader.nChannels, BASSFlag.BASS_STREAM_DECODE, _myStreamCreate, IntPtr.Zero );
+ //this._hBassStream = Bass.BASS_StreamCreate( (int) wfx.nSamplesPerSec, (int) wfx.nChannels, BASSFlag.BASS_STREAM_DECODE, _cbStreamXA, IntPtr.Zero );
+
+ // StreamCreate()縺ｧ菴懈舌＠縺殱tream縺ｯseek荳榊庄縺ｮ縺溘ａ縲ヾtreamCreateFile()繧剃ｽｿ縺縲
+ this._hBassStream = Bass.BASS_StreamCreateFile( this.hGC.AddrOfPinnedObject(), 0L, totalPCMSize, flags );
+ if ( this._hBassStream == 0 )
+ {
+ hGC.Free();
+ throw new Exception( string.Format( "繧ｵ繧ｦ繝ｳ繝峨せ繝医Μ繝ｼ繝縺ｮ逕滓舌↓螟ｱ謨励＠縺ｾ縺励◆縲(BASS_SampleCreate)[{0}]", Bass.BASS_ErrorGetCode().ToString() ) );
+ }
+
+ nBytes = Bass.BASS_ChannelGetLength( this._hBassStream );
+
+
+ tBASS繧ｵ繧ｦ繝ｳ繝峨ｒ菴懈舌☆繧祇繧ｹ繝医Μ繝ｼ繝逕滓仙ｾ後ｮ蜈ｱ騾壼ｦ逅( hMixer );
+ }
+
+
+ private void tBASS繧ｵ繧ｦ繝ｳ繝峨ｒ菴懈舌☆繧祇繧ｹ繝医Μ繝ｼ繝逕滓仙ｾ後ｮ蜈ｱ騾壼ｦ逅( int hMixer )
+ {
+ CSound邂｡逅.nStreams++;
+
+ // 蛟九縺ｮ繧ｹ繝医Μ繝ｼ繝縺ｮ蜃ｺ蜉帙ｒ繝繝ｳ繝晏､画峩縺ｮ繧ｹ繝医Μ繝ｼ繝縺ｫ蜈･蜉帙☆繧九ゅユ繝ｳ繝晏､画峩繧ｹ繝医Μ繝ｼ繝縺ｮ蜃ｺ蜉帙ｒ縲｀ixer縺ｫ蜃ｺ蜉帙☆繧九
+
+// if ( CSound邂｡逅.bIsTimeStretch ) // TimeStretch縺ｮON/OFF縺ｫ髢｢繧上ｊ縺ｪ縺上√ユ繝ｳ繝晏､画峩縺ｮ繧ｹ繝医Μ繝ｼ繝繧堤函謌舌☆繧九ょｾ後°繧碓N/OFF蛻繧頑崛縺亥庄閭ｽ縺ｨ縺吶ｋ縺溘ａ縲
+ {
+ this._hTempoStream = BassFx.BASS_FX_TempoCreate( this._hBassStream, BASSFlag.BASS_STREAM_DECODE | BASSFlag.BASS_FX_FREESOURCE );
+ if ( this._hTempoStream == 0 )
+ {
+ hGC.Free();
+ throw new Exception( string.Format( "繧ｵ繧ｦ繝ｳ繝峨せ繝医Μ繝ｼ繝縺ｮ逕滓舌↓螟ｱ謨励＠縺ｾ縺励◆縲(BASS_FX_TempoCreate)[{0}]", Bass.BASS_ErrorGetCode().ToString() ) );
+ }
+ else
+ {
+ Bass.BASS_ChannelSetAttribute( this._hTempoStream, BASSAttribute.BASS_ATTRIB_TEMPO_OPTION_USE_QUICKALGO, 1f ); // 鬮倬溷喧(髻ｳ縺ｮ蜩∬ｳｪ縺ｯ蟆代＠關ｽ縺｡繧)
+ }
+ }
+
+ if ( _hTempoStream != 0 && !this.bIs1蛟埼溷咲函 ) // 蜀咲函騾溷ｺｦ縺警1.000縺ｮ縺ｨ縺阪ｯ縲ゝempoStream繧堤畑縺縺ｪ縺繧医≧縺ｫ縺励※鬮倬溷喧縺吶ｋ
+ {
+ this.hBassStream = _hTempoStream;
+ }
+ else
+ {
+ this.hBassStream = _hBassStream;
+ }
+
+ // #32248 蜀咲函邨ゆｺ譎ゅ↓逋ｺ轣ｫ縺吶ｋcallback繧堤匳骭ｲ縺吶ｋ (貍泌･冗ｵゆｺ蠕後↓蜀咲函邨ゆｺ縺吶ｋ繝√ャ繝励ｒ髱槫酔譛溽噪縺ｫ繝溘く繧ｵ繝ｼ縺九ｉ蜑企勁縺吶ｋ縺溘ａ縲)
+ _cbEndofStream = new SYNCPROC( CallbackEndofStream );
+ Bass.BASS_ChannelSetSync( hBassStream, BASSSync.BASS_SYNC_END | BASSSync.BASS_SYNC_MIXTIME, 0, _cbEndofStream, IntPtr.Zero );
+
+ // n邱乗ｼ泌･乗凾髢薙ｮ蜿門ｾ; DTXMania逕ｨ縺ｫ霑ｽ蜉縲
+ double seconds = Bass.BASS_ChannelBytes2Seconds( this._hBassStream, nBytes );
+ this.n邱乗ｼ泌･乗凾髢杜s = (int) ( seconds * 1000 );
+ //this.pos = 0;
+ this.hMixer = hMixer;
+ float freq = 0.0f;
+ if ( !Bass.BASS_ChannelGetAttribute( this._hBassStream, BASSAttribute.BASS_ATTRIB_FREQ, ref freq ) )
+ {
+ hGC.Free();
+ throw new Exception( string.Format( "繧ｵ繧ｦ繝ｳ繝峨せ繝医Μ繝ｼ繝縺ｮ蜻ｨ豕｢謨ｰ蜿門ｾ励↓螟ｱ謨励＠縺ｾ縺励◆縲(BASS_ChannelGetAttribute)[{0}]", Bass.BASS_ErrorGetCode().ToString() ) );
+ }
+ this.n繧ｪ繝ｪ繧ｸ繝翫Ν縺ｮ蜻ｨ豕｢謨ｰ = (int) freq;
+
+ // 繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ繝ｪ繧ｹ繝医↓逋ｻ骭ｲ縲
+
+ CSound.list繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ.Add( this );
+ }
+ //-----------------
+
+ //private int pos = 0;
+ //private int CallbackPlayingXA( int handle, IntPtr buffer, int length, IntPtr user )
+ //{
+ // int bytesread = ( pos + length > Convert.ToInt32( nBytes ) ) ? Convert.ToInt32( nBytes ) - pos : length;
+
+ // Marshal.Copy( byArrWAV繝輔ぃ繧､繝ｫ繧､繝｡繝ｼ繧ｸ, pos, buffer, bytesread );
+ // pos += bytesread;
+ // if ( pos >= nBytes )
+ // {
+ // // set indicator flag
+ // bytesread |= (int) BASSStreamProc.BASS_STREAMPROC_END;
+ // }
+ // return bytesread;
+ //}
+ ///
+ /// 繧ｹ繝医Μ繝ｼ繝縺ｮ邨らｫｯ縺ｾ縺ｧ蜀咲函縺励◆縺ｨ縺阪↓蜻ｼ縺ｳ蜃ｺ縺輔ｌ繧九さ繝ｼ繝ｫ繝舌ャ繧ｯ
+ ///
+ ///
+ ///
+ ///
+ ///
+ private void CallbackEndofStream( int handle, int channel, int data, IntPtr user ) // #32248 2013.10.14 yyagi
+ {
+// Trace.TraceInformation( "Callback!(remove): " + Path.GetFileName( this.str繝輔ぃ繧､繝ｫ蜷 ) );
+ if ( b貍泌･冗ｵゆｺ蠕後ｂ蜀咲函縺檎ｶ壹￥繝√ャ繝励〒縺ゅｋ ) // 貍泌･冗ｵゆｺ蠕後↓蜀咲函邨ゆｺ縺吶ｋ繝√ャ繝鈴浹縺ｮ繝溘く繧ｵ繝ｼ蜑企勁縺ｯ縲∝咲函邨ゆｺ縺ｮ繧ｳ繝ｼ繝ｫ繝舌ャ繧ｯ縺ｫ蠑輔▲謗帙¢縺ｦ縲∬ｪ蜑阪〒陦後≧縲
+ { // 縺昴≧縺ｧ縺ｪ縺繧ゅｮ縺ｯ縲√Α繧ｭ繧ｵ繝ｼ蜑企勁莠亥ｮ壽凾蛻ｻ縺ｫ蜑企勁縺吶ｋ縲
+ tBASS繧ｵ繧ｦ繝ｳ繝峨ｒ繝溘く繧ｵ繝ｼ縺九ｉ蜑企勁縺吶ｋ( channel );
+ }
+ }
+
+// mixer縺九ｉ縺ｮ蜑企勁
+
+ public bool tBASS繧ｵ繧ｦ繝ｳ繝峨ｒ繝溘く繧ｵ繝ｼ縺九ｉ蜑企勁縺吶ｋ()
+ {
+ return tBASS繧ｵ繧ｦ繝ｳ繝峨ｒ繝溘く繧ｵ繝ｼ縺九ｉ蜑企勁縺吶ｋ( this.hBassStream );
+ }
+ public bool tBASS繧ｵ繧ｦ繝ｳ繝峨ｒ繝溘く繧ｵ繝ｼ縺九ｉ蜑企勁縺吶ｋ( int channel )
+ {
+ bool b = BassMix.BASS_Mixer_ChannelRemove( channel );
+ if ( b )
+ {
+ Interlocked.Decrement( ref CSound邂｡逅.nMixing );
+// Debug.WriteLine( "Removed: " + Path.GetFileName( this.str繝輔ぃ繧､繝ｫ蜷 ) + " (" + channel + ")" + " MixedStreams=" + CSound邂｡逅.nMixing );
+ }
+ return b;
+ }
+
+
+// mixer 縺ｸ縺ｮ霑ｽ蜉
+
+ public bool tBASS繧ｵ繧ｦ繝ｳ繝峨ｒ繝溘く繧ｵ繝ｼ縺ｫ霑ｽ蜉縺吶ｋ()
+ {
+ if ( BassMix.BASS_Mixer_ChannelGetMixer( hBassStream ) == 0 )
+ {
+ BASSFlag bf = BASSFlag.BASS_SPEAKER_FRONT | BASSFlag.BASS_MIXER_NORAMPIN | BASSFlag.BASS_MIXER_PAUSE;
+ Interlocked.Increment( ref CSound邂｡逅.nMixing );
+
+ // preload縺輔ｌ繧九％縺ｨ繧呈悄蠕縺励※縲∵覆縺医※flag縺九ｉ縺ｯBASS_MIXER_PAUSE繧貞､悶＠縺ｦAddChannel縺励◆荳翫〒縲√☆縺舌↓PAUSE縺吶ｋ
+ // -> ChannelUpdate縺ｧprebuffer縺ｧ縺阪ｋ縺薙→縺悟縺九▲縺溘◆繧√。ASS_MIXER_PAUSE繧剃ｽｿ逕ｨ縺吶ｋ縺薙→縺ｫ縺励◆
+
+ bool b1 = BassMix.BASS_Mixer_StreamAddChannel( this.hMixer, this.hBassStream, bf );
+ //bool b2 = BassMix.BASS_Mixer_ChannelPause( this.hBassStream );
+ t蜀咲函菴咲ｽｮ繧貞磯ｭ縺ｫ謌ｻ縺(); // StreamAddChannel縺ｮ蠕後〒蜀咲函菴咲ｽｮ繧呈綾縺輔↑縺縺ｨ繝繝｡縲る縺縺ｨ蜀咲函菴咲ｽｮ縺悟､峨ｏ繧峨↑縺縲
+//Trace.TraceInformation( "Add Mixer: " + Path.GetFileName( this.str繝輔ぃ繧､繝ｫ蜷 ) + " (" + hBassStream + ")" + " MixedStreams=" + CSound邂｡逅.nMixing );
+ Bass.BASS_ChannelUpdate( this.hBassStream, 0 ); // pre-buffer
+ return b1; // &b2;
+ }
+ return true;
+ }
+
+ #region [ t繧ｪ繝ｳ繝｡繝｢繝ｪ譁ｹ蠑上〒繝繧ｳ繝ｼ繝峨☆繧() ]
+ public void t繧ｪ繝ｳ繝｡繝｢繝ｪ譁ｹ蠑上〒繝繧ｳ繝ｼ繝峨☆繧( string str繝輔ぃ繧､繝ｫ蜷, out byte[] buffer,
+ out int nPCM繝繝ｼ繧ｿ縺ｮ蜈磯ｭ繧､繝ｳ繝繝繧ｯ繧ｹ, out int totalPCMSize, out CWin32.WAVEFORMATEX wfx,
+ bool bIntegrateWaveHeader )
+ {
+ nPCM繝繝ｼ繧ｿ縺ｮ蜈磯ｭ繧､繝ｳ繝繝繧ｯ繧ｹ = 0;
+ //int nPCM繧ｵ繧､繧ｺbyte = (int) ( xa.xaheader.nSamples * xa.xaheader.nChannels * 2 ); // nBytes = Bass.BASS_ChannelGetLength( this.hBassStream );
+
+ SoundDecoder sounddecoder;
+
+ if ( String.Compare( Path.GetExtension( str繝輔ぃ繧､繝ｫ蜷 ), ".xa", true ) == 0 )
+ {
+ sounddecoder = new Cxa();
+ }
+ else if ( String.Compare( Path.GetExtension( str繝輔ぃ繧､繝ｫ蜷 ), ".ogg", true ) == 0 )
+ {
+ sounddecoder = new Cogg();
+ }
+ else if ( String.Compare( Path.GetExtension( str繝輔ぃ繧､繝ｫ蜷 ), ".mp3", true ) == 0 )
+ {
+ sounddecoder = new Cmp3();
+ }
+ else
+ {
+ throw new NotImplementedException();
+ }
+
+ if ( !File.Exists( str繝輔ぃ繧､繝ｫ蜷 ) )
+ {
+ throw new Exception( string.Format( "繝輔ぃ繧､繝ｫ縺瑚ｦ九▽縺九ｊ縺ｾ縺帙ｓ縺ｧ縺励◆縲({0})", str繝輔ぃ繧､繝ｫ蜷 ) );
+ }
+ int nHandle = sounddecoder.Open( str繝輔ぃ繧､繝ｫ蜷 );
+ if ( nHandle < 0 )
+ {
+ throw new Exception( string.Format( "Open() 縺ｫ螟ｱ謨励＠縺ｾ縺励◆縲({0})({1})", nHandle, str繝輔ぃ繧､繝ｫ蜷 ) );
+ }
+ wfx = new CWin32.WAVEFORMATEX();
+ if ( sounddecoder.GetFormat( nHandle, ref wfx ) < 0 )
+ {
+ sounddecoder.Close( nHandle );
+ throw new Exception( string.Format( "GetFormat() 縺ｫ螟ｱ謨励＠縺ｾ縺励◆縲({0})", str繝輔ぃ繧､繝ｫ蜷 ) );
+ }
+ //totalPCMSize = (int) sounddecoder.nTotalPCMSize; // t繝繧ｳ繝ｼ繝牙ｾ後ｮ繧ｵ繧､繧ｺ繧定ｪｿ縺ｹ繧()縺ｧ譌｢縺ｫ蜿門ｾ玲ｸ医∩縺ｮ蛟､繧呈ｵ∫畑縺吶ｋ縲Ｎs蜊倅ｽ阪ｮ鬮倬溷喧縺縺後√メ繝繝鈴浹縺後◆縺上＆繧薙≠繧九→蝪ｵ遨阪〒邨先ｧ句柑譫懊′縺ゅｋ
+ totalPCMSize = (int) sounddecoder.GetTotalPCMSize( nHandle );
+ if ( totalPCMSize == 0 )
+ {
+ sounddecoder.Close( nHandle );
+ throw new Exception( string.Format( "GetTotalPCMSize() 縺ｫ螟ｱ謨励＠縺ｾ縺励◆縲({0})", str繝輔ぃ繧､繝ｫ蜷 ) );
+ }
+ totalPCMSize += ( ( totalPCMSize % 2 ) != 0 ) ? 1 : 0;
+ int wavheadersize = ( bIntegrateWaveHeader ) ? 44 : 0;
+ byte[] buffer_rawdata = new byte[ totalPCMSize ];
+ buffer = new byte[ wavheadersize + totalPCMSize ];
+ GCHandle handle = GCHandle.Alloc( buffer_rawdata, GCHandleType.Pinned );
+ try
+ {
+ if ( sounddecoder.Decode( nHandle, handle.AddrOfPinnedObject(), (uint) totalPCMSize, 0 ) < 0 )
+ {
+ buffer = null;
+ throw new Exception( string.Format( "繝繧ｳ繝ｼ繝峨↓螟ｱ謨励＠縺ｾ縺励◆縲({0})", str繝輔ぃ繧､繝ｫ蜷 ) );
+ }
+ if ( bIntegrateWaveHeader )
+ {
+ // wave header繧呈嶌縺崎ｾｼ繧
+
+ int wfx諡｡蠑ｵ鬆伜沺_Length = 0;
+ var ms = new MemoryStream();
+ var bw = new BinaryWriter( ms );
+ bw.Write( new byte[] { 0x52, 0x49, 0x46, 0x46 } ); // 'RIFF'
+ bw.Write( (UInt32) totalPCMSize + 44 - 8 ); // 繝輔ぃ繧､繝ｫ繧ｵ繧､繧ｺ - 8 [byte]ｼ帑ｻ翫ｯ荳肴弱↑縺ｮ縺ｧ蠕後〒荳頑嶌縺阪☆繧九
+ bw.Write( new byte[] { 0x57, 0x41, 0x56, 0x45 } ); // 'WAVE'
+ bw.Write( new byte[] { 0x66, 0x6D, 0x74, 0x20 } ); // 'fmt '
+ bw.Write( (UInt32) ( 16 + ( ( wfx諡｡蠑ｵ鬆伜沺_Length > 0 ) ? ( 2/*sizeof(WAVEFORMATEX.cbSize)*/ + wfx諡｡蠑ｵ鬆伜沺_Length ) : 0 ) ) ); // fmt繝√Ε繝ｳ繧ｯ縺ｮ繧ｵ繧､繧ｺ[byte]
+ bw.Write( (UInt16) wfx.wFormatTag ); // 繝輔か繝ｼ繝槭ャ繝IDｼ医Μ繝九いPCM縺ｪ繧1ｼ
+ bw.Write( (UInt16) wfx.nChannels ); // 繝√Ε繝ｳ繝阪Ν謨ｰ
+ bw.Write( (UInt32) wfx.nSamplesPerSec ); // 繧ｵ繝ｳ繝励Μ繝ｳ繧ｰ繝ｬ繝ｼ繝
+ bw.Write( (UInt32) wfx.nAvgBytesPerSec ); // 繝繝ｼ繧ｿ騾溷ｺｦ
+ bw.Write( (UInt16) wfx.nBlockAlign ); // 繝悶Ο繝繧ｯ繧ｵ繧､繧ｺ
+ bw.Write( (UInt16) wfx.wBitsPerSample ); // 繧ｵ繝ｳ繝励Ν縺ゅ◆繧翫ｮ繝薙ャ繝域焚
+ //if ( wfx諡｡蠑ｵ鬆伜沺_Length > 0 )
+ //{
+ // bw.Write( (UInt16) wfx諡｡蠑ｵ鬆伜沺.Length ); // 諡｡蠑ｵ鬆伜沺縺ｮ繧ｵ繧､繧ｺ[byte]
+ // bw.Write( wfx諡｡蠑ｵ鬆伜沺 ); // 諡｡蠑ｵ繝繝ｼ繧ｿ
+ //}
+ bw.Write( new byte[] { 0x64, 0x61, 0x74, 0x61 } ); // 'data'
+ //int nDATA繝√Ε繝ｳ繧ｯ繧ｵ繧､繧ｺ菴咲ｽｮ = (int) ms.Position;
+ bw.Write( (UInt32) totalPCMSize ); // data繝√Ε繝ｳ繧ｯ縺ｮ繧ｵ繧､繧ｺ[byte]
+
+ byte[] bs = ms.ToArray();
+
+ bw.Close();
+ ms.Close();
+
+ for ( int i = 0; i < bs.Length; i++ )
+ {
+ buffer[ i ] = bs[ i ];
+ }
+ }
+ int s = ( bIntegrateWaveHeader ) ? 44 : 0;
+ for ( int i = 0; i < totalPCMSize; i++ )
+ {
+ buffer[ i + s ] = buffer_rawdata[ i ];
+ }
+ totalPCMSize += wavheadersize;
+ nPCM繝繝ｼ繧ｿ縺ｮ蜈磯ｭ繧､繝ｳ繝繝繧ｯ繧ｹ = wavheadersize;
+ }
+ finally
+ {
+ handle.Free();
+ sounddecoder.Close( nHandle );
+ sounddecoder = null;
+ }
+ }
+ #endregion
+ #endregion
+ }
+}
diff --git a/FDK19/繧ｳ繝ｼ繝/03.繧ｵ繧ｦ繝ｳ繝/CSoundDeviceASIO.cs b/FDK19/繧ｳ繝ｼ繝/03.繧ｵ繧ｦ繝ｳ繝/CSoundDeviceASIO.cs
new file mode 100644
index 00000000..8012b8e7
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/03.繧ｵ繧ｦ繝ｳ繝/CSoundDeviceASIO.cs
@@ -0,0 +1,455 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Diagnostics;
+using Un4seen.Bass;
+using Un4seen.BassAsio;
+using Un4seen.Bass.AddOn.Mix;
+
+namespace FDK
+{
+ ///
+ /// 蜈ｨASIO繝繝舌う繧ｹ繧貞玲嫌縺吶ｋ髱咏噪繧ｯ繝ｩ繧ｹ縲
+ /// BASS_Init()繧ВASS_ASIO_Init()縺ｮ迥ｶ諷九→縺ｯ辟｡髢｢菫ゅ↓菴ｿ逕ｨ蜿ｯ閭ｽ縲
+ ///
+ public static class CEnumerateAllAsioDevices
+ {
+ public static string[] GetAllASIODevices()
+ {
+ //Debug.WriteLine( "BassAsio.BASS_ASIO_GetDeviceInfos():" );
+ BASS_ASIO_DEVICEINFO[] bassAsioDevInfo = BassAsio.BASS_ASIO_GetDeviceInfos();
+
+ List asioDeviceList = new List();
+
+ if ( bassAsioDevInfo.Length == 0 )
+ {
+ asioDeviceList.Add( "None" );
+ }
+ else
+ {
+ for ( int i = 0; i < bassAsioDevInfo.Length; i++ )
+ {
+ asioDeviceList.Add( bassAsioDevInfo[ i ].name );
+ //Trace.TraceInformation( "ASIO Device {0}: {1}", i, bassAsioDevInfo[ i ].name );
+ }
+ }
+
+ return asioDeviceList.ToArray();
+ }
+ }
+
+ internal class CSoundDeviceASIO : ISoundDevice
+ {
+ // 繝励Ο繝代ユ繧｣
+
+ public ESoundDeviceType e蜃ｺ蜉帙ョ繝舌う繧ｹ
+ {
+ get;
+ protected set;
+ }
+ public long n螳溷ｺ蜉幃≦蟒ｶms
+ {
+ get;
+ protected set;
+ }
+ public long n螳溘ヰ繝繝輔ぃ繧ｵ繧､繧ｺms
+ {
+ get;
+ protected set;
+ }
+ public int nASIODevice
+ {
+ get;
+ set;
+ }
+
+ // CSoundTimer 逕ｨ縺ｫ蜈ｬ髢九＠縺ｦ縺繧九励Ο繝代ユ繧｣
+
+ public long n邨碁℃譎る俣ms
+ {
+ get;
+ protected set;
+ }
+ public long n邨碁℃譎る俣繧呈峩譁ｰ縺励◆繧ｷ繧ｹ繝繝譎ょ綾ms
+ {
+ get;
+ protected set;
+ }
+ public CTimer tm繧ｷ繧ｹ繝繝繧ｿ繧､繝
+ {
+ get;
+ protected set;
+ }
+
+
+ // 繝槭せ繧ｿ繝ｼ繝懊Μ繝･繝ｼ繝縺ｮ蛻ｶ蠕｡繧ｳ繝ｼ繝峨ｯ縲仝ASAPI/ASIO縺ｧ蜈ｨ縺丞酔縺倥
+ public int nMasterVolume
+ {
+ get
+ {
+ float f髻ｳ驥 = 0.0f;
+ bool b = Bass.BASS_ChannelGetAttribute( this.hMixer, BASSAttribute.BASS_ATTRIB_VOL, ref f髻ｳ驥 );
+ if ( !b )
+ {
+ BASSError be = Bass.BASS_ErrorGetCode();
+ Trace.TraceInformation( "ASIO Master Volume Get Error: " + be.ToString() );
+ }
+ else
+ {
+ //Trace.TraceInformation( "ASIO Master Volume Get Success: " + (f髻ｳ驥 * 100) );
+
+ }
+ return (int) ( f髻ｳ驥 * 100 );
+ }
+ set
+ {
+ bool b = Bass.BASS_ChannelSetAttribute( this.hMixer, BASSAttribute.BASS_ATTRIB_VOL, (float) ( value / 100.0 ) );
+ if ( !b )
+ {
+ BASSError be = Bass.BASS_ErrorGetCode();
+ Trace.TraceInformation( "ASIO Master Volume Set Error: " + be.ToString() );
+ }
+ else
+ {
+ // int n = this.nMasterVolume;
+ // Trace.TraceInformation( "ASIO Master Volume Set Success: " + value );
+ }
+ }
+ }
+
+ // 繝｡繧ｽ繝繝
+
+ public CSoundDeviceASIO( long n蟶梧悍繝舌ャ繝輔ぃ繧ｵ繧､繧ｺms, int _nASIODevice )
+ {
+ // 蛻晄悄蛹悶
+
+ Trace.TraceInformation( "BASS (ASIO) 縺ｮ蛻晄悄蛹悶ｒ髢句ｧ九＠縺ｾ縺吶" );
+ this.e蜃ｺ蜉帙ョ繝舌う繧ｹ = ESoundDeviceType.Unknown;
+ this.n螳溷ｺ蜉幃≦蟒ｶms = 0;
+ this.n邨碁℃譎る俣ms = 0;
+ this.n邨碁℃譎る俣繧呈峩譁ｰ縺励◆繧ｷ繧ｹ繝繝譎ょ綾ms = CTimer.n譛ｪ菴ｿ逕ｨ;
+ this.tm繧ｷ繧ｹ繝繝繧ｿ繧､繝 = new CTimer( CTimer.E遞ｮ蛻･.MultiMedia );
+ this.nASIODevice = _nASIODevice;
+
+ #region [ BASS registration ]
+ // BASS.NET 繝ｦ繝ｼ繧ｶ逋ｻ骭ｲｼBASS繧ｹ繝励Λ繝繧ｷ繝･縺碁撼陦ｨ遉ｺ縺ｫ縺ｪ繧具ｼ峨
+ BassNet.Registration( "dtx2013@gmail.com", "2X9181017152222" );
+ #endregion
+
+ #region [ BASS Version Check ]
+ // BASS 縺ｮ繝舌ｼ繧ｸ繝ｧ繝ｳ繝√ぉ繝繧ｯ縲
+ int nBASSVersion = Utils.HighWord( Bass.BASS_GetVersion() );
+ if( nBASSVersion != Bass.BASSVERSION )
+ throw new DllNotFoundException( string.Format( "bass.dll 縺ｮ繝舌ｼ繧ｸ繝ｧ繝ｳ縺檎焚縺ｪ繧翫∪縺({0})縲ゅ％縺ｮ繝励Ο繧ｰ繝ｩ繝縺ｯ繝舌ｼ繧ｸ繝ｧ繝ｳ{1}縺ｧ蜍穂ｽ懊＠縺ｾ縺吶", nBASSVersion, Bass.BASSVERSION ) );
+
+ int nBASSMixVersion = Utils.HighWord( BassMix.BASS_Mixer_GetVersion() );
+ if( nBASSMixVersion != BassMix.BASSMIXVERSION )
+ throw new DllNotFoundException( string.Format( "bassmix.dll 縺ｮ繝舌ｼ繧ｸ繝ｧ繝ｳ縺檎焚縺ｪ繧翫∪縺({0})縲ゅ％縺ｮ繝励Ο繧ｰ繝ｩ繝縺ｯ繝舌ｼ繧ｸ繝ｧ繝ｳ{1}縺ｧ蜍穂ｽ懊＠縺ｾ縺吶", nBASSMixVersion, BassMix.BASSMIXVERSION ) );
+
+ int nBASSASIO = Utils.HighWord( BassAsio.BASS_ASIO_GetVersion() );
+ if( nBASSASIO != BassAsio.BASSASIOVERSION )
+ throw new DllNotFoundException( string.Format( "bassasio.dll 縺ｮ繝舌ｼ繧ｸ繝ｧ繝ｳ縺檎焚縺ｪ繧翫∪縺({0})縲ゅ％縺ｮ繝励Ο繧ｰ繝ｩ繝縺ｯ繝舌ｼ繧ｸ繝ｧ繝ｳ{1}縺ｧ蜍穂ｽ懊＠縺ｾ縺吶", nBASSASIO, BassAsio.BASSASIOVERSION ) );
+ #endregion
+
+ // BASS 縺ｮ險ｭ螳壹
+
+ this.bIsBASSFree = true;
+
+ if (!Bass.BASS_SetConfig( BASSConfig.BASS_CONFIG_UPDATEPERIOD, 0 )) // 0:BASS繧ｹ繝医Μ繝ｼ繝縺ｮ閾ｪ蜍墓峩譁ｰ繧定｡後ｏ縺ｪ縺縲
+ {
+ Trace.TraceWarning($"BASS_SetConfig({nameof(BASSConfig.BASS_CONFIG_UPDATEPERIOD)}) 縺ｫ螟ｱ謨励＠縺ｾ縺励◆縲[{Bass.BASS_ErrorGetCode()}]");
+ }
+ if (!Bass.BASS_SetConfig( BASSConfig.BASS_CONFIG_UPDATETHREADS, 0 )) // 0:BASS繧ｹ繝医Μ繝ｼ繝縺ｮ閾ｪ蜍墓峩譁ｰ繧定｡後ｏ縺ｪ縺縲
+ {
+ Trace.TraceWarning($"BASS_SetConfig({nameof(BASSConfig.BASS_CONFIG_UPDATETHREADS)}) 縺ｫ螟ｱ謨励＠縺ｾ縺励◆縲[{Bass.BASS_ErrorGetCode()}]");
+ }
+
+ // BASS 縺ｮ蛻晄悄蛹悶
+
+ int n繝繝舌う繧ｹ = 0; // 0:"no device" 窶ｦ BASS 縺九ｉ縺ｯ繝繝舌う繧ｹ縺ｸ繧｢繧ｯ繧ｻ繧ｹ縺輔○縺ｪ縺縲ゅい繧ｯ繧ｻ繧ｹ縺ｯ BASSASIO 繧｢繝峨が繝ｳ縺九ｉ陦後≧縲
+ int n蜻ｨ豕｢謨ｰ = 44100; // 莉ｮ豎ｺ繧√よ怙邨ら噪縺ｪ蜻ｨ豕｢謨ｰ縺ｯ繝繝舌う繧ｹｼ遺旺繝峨Λ繧､繝撰ｼ峨′豎ｺ繧√ｋ縲
+ if( !Bass.BASS_Init( n繝繝舌う繧ｹ, n蜻ｨ豕｢謨ｰ, BASSInit.BASS_DEVICE_DEFAULT, IntPtr.Zero ) )
+ throw new Exception( string.Format( "BASS 縺ｮ蛻晄悄蛹悶↓螟ｱ謨励＠縺ｾ縺励◆縲(BASS_Init)[{0}]", Bass.BASS_ErrorGetCode().ToString() ) );
+
+ Bass.BASS_SetConfig(BASSConfig.BASS_CONFIG_CURVE_VOL, true);
+
+//Debug.WriteLine( "BASS_Init()螳御ｺ縲" );
+ #region [ 繝繝舌ャ繧ｰ逕ｨ: ASIO繝繝舌う繧ｹ縺ｮenumerate縺ｨ縲√Ο繧ｰ蜃ｺ蜉 ]
+// CEnumerateAllAsioDevices.GetAllASIODevices();
+//Debug.WriteLine( "BassAsio.BASS_ASIO_GetDeviceInfo():" );
+// int a, count = 0;
+// BASS_ASIO_DEVICEINFO asioDevInfo;
+// for ( a = 0; ( asioDevInfo = BassAsio.BASS_ASIO_GetDeviceInfo( a ) ) != null; a++ )
+// {
+// Trace.TraceInformation( "ASIO Device {0}: {1}, driver={2}", a, asioDevInfo.name, asioDevInfo.driver );
+// count++; // count it
+// }
+ #endregion
+
+ // BASS ASIO 縺ｮ蛻晄悄蛹悶
+ BASS_ASIO_INFO asioInfo = null;
+ if ( BassAsio.BASS_ASIO_Init( nASIODevice, BASSASIOInit.BASS_ASIO_THREAD ) ) // 蟆ら畑繧ｹ繝ｬ繝繝峨↓縺ｦ襍ｷ蜍
+ {
+ #region [ ASIO 縺ｮ蛻晄悄蛹悶↓謌仙粥縲]
+ //-----------------
+ this.e蜃ｺ蜉帙ョ繝舌う繧ｹ = ESoundDeviceType.ASIO;
+ asioInfo = BassAsio.BASS_ASIO_GetInfo();
+ this.n蜃ｺ蜉帙メ繝｣繝ｳ繝阪Ν謨ｰ = asioInfo.outputs;
+ this.db蜻ｨ豕｢謨ｰ = BassAsio.BASS_ASIO_GetRate();
+ this.fmtASIO繝繝舌う繧ｹ繝輔か繝ｼ繝槭ャ繝 = BassAsio.BASS_ASIO_ChannelGetFormat( false, 0 );
+
+ Trace.TraceInformation( "BASS 繧貞晄悄蛹悶＠縺ｾ縺励◆縲(ASIO, 繝繝舌う繧ｹ:\"{0}\", 蜈･蜉學1}, 蜃ｺ蜉學2}, {3}Hz, 繝舌ャ繝輔ぃ{4}ｽ桀6}sample ({5:0.###}ｽ桀7:0.###}ms), 繝繝舌う繧ｹ繝輔か繝ｼ繝槭ャ繝:{8})",
+ asioInfo.name,
+ asioInfo.inputs,
+ asioInfo.outputs,
+ this.db蜻ｨ豕｢謨ｰ.ToString( "0.###" ),
+ asioInfo.bufmin, asioInfo.bufmin * 1000 / this.db蜻ｨ豕｢謨ｰ,
+ asioInfo.bufmax, asioInfo.bufmax * 1000 / this.db蜻ｨ豕｢謨ｰ,
+ this.fmtASIO繝繝舌う繧ｹ繝輔か繝ｼ繝槭ャ繝.ToString()
+ );
+ this.bIsBASSFree = false;
+ #region [ debug: channel format ]
+ //BASS_ASIO_CHANNELINFO chinfo = new BASS_ASIO_CHANNELINFO();
+ //int chan = 0;
+ //while ( true )
+ //{
+ // if ( !BassAsio.BASS_ASIO_ChannelGetInfo( false, chan, chinfo ) )
+ // break;
+ // Debug.WriteLine( "Ch=" + chan + ": " + chinfo.name.ToString() + ", " + chinfo.group.ToString() + ", " + chinfo.format.ToString() );
+ // chan++;
+ //}
+ #endregion
+ //-----------------
+ #endregion
+ }
+ else
+ {
+ #region [ ASIO 縺ｮ蛻晄悄蛹悶↓螟ｱ謨励]
+ //-----------------
+ BASSError errcode = Bass.BASS_ErrorGetCode();
+ string errmes = errcode.ToString();
+ if ( errcode == BASSError.BASS_OK )
+ {
+ errmes = "BASS_OK; The device may be dissconnected";
+ }
+ Bass.BASS_Free();
+ this.bIsBASSFree = true;
+ throw new Exception( string.Format( "BASS (ASIO) 縺ｮ蛻晄悄蛹悶↓螟ｱ謨励＠縺ｾ縺励◆縲(BASS_ASIO_Init)[{0}]", errmes ) );
+ //-----------------
+ #endregion
+ }
+
+
+ // ASIO 蜃ｺ蜉帙メ繝｣繝ｳ繝阪Ν縺ｮ蛻晄悄蛹悶
+
+ this.tAsioProc = new ASIOPROC( this.tAsio蜃ｦ逅 ); // 繧｢繝ｳ繝槭ロ繝ｼ繧ｸ縺ｫ貂｡縺 delegate 縺ｯ縲√ヵ繧｣繝ｼ繝ｫ繝峨→縺励※菫晄戟縺励※縺翫°縺ｪ縺縺ｨGC縺ｧ繧｢繝峨Ξ繧ｹ縺悟､峨ｏ縺｣縺ｦ縺励∪縺縲
+ if ( !BassAsio.BASS_ASIO_ChannelEnable( false, 0, this.tAsioProc, IntPtr.Zero ) ) // 蜃ｺ蜉帙メ繝｣繝ｳ繝阪Ν0 縺ｮ譛牙柑蛹悶
+ {
+ #region [ ASIO 蜃ｺ蜉帙メ繝｣繝ｳ繝阪Ν縺ｮ蛻晄悄蛹悶↓螟ｱ謨励]
+ //-----------------
+ BassAsio.BASS_ASIO_Free();
+ Bass.BASS_Free();
+ this.bIsBASSFree = true;
+ throw new Exception( string.Format( "Failed BASS_ASIO_ChannelEnable() [{0}]", BassAsio.BASS_ASIO_ErrorGetCode().ToString() ) );
+ //-----------------
+ #endregion
+ }
+ for ( int i = 1; i < this.n蜃ｺ蜉帙メ繝｣繝ｳ繝阪Ν謨ｰ; i++ ) // 蜃ｺ蜉帙メ繝｣繝阪Ν繧貞ｨ縺ｦ繝√Ε繝阪Ν0縺ｨ繧ｰ繝ｫ繝ｼ繝怜喧縺吶ｋ縲
+ { // 繝√Ε繝阪Ν1縺縺代ｒ0縺ｨ繧ｰ繝ｫ繝ｼ繝怜喧縺吶ｋ縺ｨ縲3ch莉･荳翫ｮ蜃ｺ蜉帙ｒ繧ｵ繝昴ｼ繝医＠縺溘き繝ｼ繝峨〒縺ｮ蜍穂ｽ懊′縺翫°縺励￥縺ｪ繧
+ if ( !BassAsio.BASS_ASIO_ChannelJoin( false, i, 0 ) )
+ {
+ #region [ 蛻晄悄蛹悶↓螟ｱ謨励]
+ //-----------------
+ BassAsio.BASS_ASIO_Free();
+ Bass.BASS_Free();
+ this.bIsBASSFree = true;
+ throw new Exception( string.Format( "Failed BASS_ASIO_ChannelJoin({1}) [{0}]", BassAsio.BASS_ASIO_ErrorGetCode().ToString(), i ) );
+ //-----------------
+ #endregion
+ }
+ }
+ if ( !BassAsio.BASS_ASIO_ChannelSetFormat( false, 0, this.fmtASIO繝√Ε繝ｳ繝阪Ν繝輔か繝ｼ繝槭ャ繝 ) ) // 蜃ｺ蜉帙メ繝｣繝ｳ繝阪Ν0縺ｮ繝輔か繝ｼ繝槭ャ繝
+ {
+ #region [ ASIO 蜃ｺ蜉帙メ繝｣繝ｳ繝阪Ν縺ｮ蛻晄悄蛹悶↓螟ｱ謨励]
+ //-----------------
+ BassAsio.BASS_ASIO_Free();
+ Bass.BASS_Free();
+ this.bIsBASSFree = true;
+ throw new Exception( string.Format( "Failed BASS_ASIO_ChannelSetFormat() [{0}]", BassAsio.BASS_ASIO_ErrorGetCode().ToString() ) );
+ //-----------------
+ #endregion
+ }
+
+ // ASIO 蜃ｺ蜉帙→蜷後§繝輔か繝ｼ繝槭ャ繝医ｒ謖√▽ BASS 繝溘く繧ｵ繝ｼ繧剃ｽ懈舌
+
+ var flag = BASSFlag.BASS_MIXER_NONSTOP | BASSFlag.BASS_STREAM_DECODE; // 繝繧ｳ繝ｼ繝峨ｮ縺ｿｼ晉匱螢ｰ縺励↑縺縲ASIO 縺ｫ蜃ｺ蜉帙＆繧後ｋ縺縺代
+ if( this.fmtASIO繝繝舌う繧ｹ繝輔か繝ｼ繝槭ャ繝 == BASSASIOFormat.BASS_ASIO_FORMAT_FLOAT )
+ flag |= BASSFlag.BASS_SAMPLE_FLOAT;
+ this.hMixer = BassMix.BASS_Mixer_StreamCreate( (int) this.db蜻ｨ豕｢謨ｰ, this.n蜃ｺ蜉帙メ繝｣繝ｳ繝阪Ν謨ｰ, flag );
+
+ if ( this.hMixer == 0 )
+ {
+ BASSError err = Bass.BASS_ErrorGetCode();
+ BassAsio.BASS_ASIO_Free();
+ Bass.BASS_Free();
+ this.bIsBASSFree = true;
+ throw new Exception( string.Format( "BASS繝溘く繧ｵ(mixing)縺ｮ菴懈舌↓螟ｱ謨励＠縺ｾ縺励◆縲[{0}]", err ) );
+ }
+
+ // BASS 繝溘く繧ｵ繝ｼ縺ｮ1遘偵≠縺溘ｊ縺ｮ繝舌う繝域焚繧堤ｮ怜ｺ縲
+
+ var mixerInfo = Bass.BASS_ChannelGetInfo( this.hMixer );
+ int n繧ｵ繝ｳ繝励Ν繧ｵ繧､繧ｺbyte = 0;
+ switch( this.fmtASIO繝√Ε繝ｳ繝阪Ν繝輔か繝ｼ繝槭ャ繝 )
+ {
+ case BASSASIOFormat.BASS_ASIO_FORMAT_16BIT: n繧ｵ繝ｳ繝励Ν繧ｵ繧､繧ｺbyte = 2; break;
+ case BASSASIOFormat.BASS_ASIO_FORMAT_24BIT: n繧ｵ繝ｳ繝励Ν繧ｵ繧､繧ｺbyte = 3; break;
+ case BASSASIOFormat.BASS_ASIO_FORMAT_32BIT: n繧ｵ繝ｳ繝励Ν繧ｵ繧､繧ｺbyte = 4; break;
+ case BASSASIOFormat.BASS_ASIO_FORMAT_FLOAT: n繧ｵ繝ｳ繝励Ν繧ｵ繧､繧ｺbyte = 4; break;
+ }
+ //long n繝溘く繧ｵ繝ｼ縺ｮ1繧ｵ繝ｳ繝励Ν縺ゅ◆繧翫ｮ繝舌う繝域焚 = /*mixerInfo.chans*/ 2 * n繧ｵ繝ｳ繝励Ν繧ｵ繧､繧ｺbyte;
+ long n繝溘く繧ｵ繝ｼ縺ｮ1繧ｵ繝ｳ繝励Ν縺ゅ◆繧翫ｮ繝舌う繝域焚 = mixerInfo.chans * n繧ｵ繝ｳ繝励Ν繧ｵ繧､繧ｺbyte;
+ this.n繝溘く繧ｵ繝ｼ縺ｮ1遘偵≠縺溘ｊ縺ｮ繝舌う繝域焚 = n繝溘く繧ｵ繝ｼ縺ｮ1繧ｵ繝ｳ繝励Ν縺ゅ◆繧翫ｮ繝舌う繝域焚 * mixerInfo.freq;
+
+
+ // 蜊倡ｴ斐↓縲”Mixer縺ｮ髻ｳ驥上ｒMasterVolume縺ｨ縺励※蛻ｶ蠕｡縺励※繧ゅ
+ // ChannelGetData()縺ｮ蜀螳ｹ縺ｫ縺ｯ蜿肴丐縺輔ｌ縺ｪ縺縲
+ // 縺昴ｮ縺溘ａ縲√ｂ縺荳谿ｵmixer繧貞剱縺ｾ縺帙※縲∽ｸ谿ｵ蜈医ｮmixer縺九ｉChannelGetData()縺吶ｋ縺薙→縺ｧ縲
+ // hMixer縺ｮ髻ｳ驥丞宛蠕｡繧貞渚譏縺輔○繧九
+ this.hMixer_DeviceOut = BassMix.BASS_Mixer_StreamCreate(
+ (int) this.db蜻ｨ豕｢謨ｰ, this.n蜃ｺ蜉帙メ繝｣繝ｳ繝阪Ν謨ｰ, flag );
+ if ( this.hMixer_DeviceOut == 0 )
+ {
+ BASSError errcode = Bass.BASS_ErrorGetCode();
+ BassAsio.BASS_ASIO_Free();
+ Bass.BASS_Free();
+ this.bIsBASSFree = true;
+ throw new Exception( string.Format( "BASS繝溘く繧ｵ(譛邨よｮｵ)縺ｮ菴懈舌↓螟ｱ謨励＠縺ｾ縺励◆縲[{0}]", errcode ) );
+ }
+ {
+ bool b1 = BassMix.BASS_Mixer_StreamAddChannel( this.hMixer_DeviceOut, this.hMixer, BASSFlag.BASS_DEFAULT );
+ if ( !b1 )
+ {
+ BASSError errcode = Bass.BASS_ErrorGetCode();
+ BassAsio.BASS_ASIO_Free();
+ Bass.BASS_Free();
+ this.bIsBASSFree = true;
+ throw new Exception( string.Format( "BASS繝溘く繧ｵ(譛邨よｮｵ縺ｨmixing)縺ｮ謗･邯壹↓螟ｱ謨励＠縺ｾ縺励◆縲[{0}]", errcode ) );
+ };
+ }
+
+
+ // 蜃ｺ蜉帙ｒ髢句ｧ九
+
+ this.n繝舌ャ繝輔ぃ繧ｵ繧､繧ｺsample = (int) ( n蟶梧悍繝舌ャ繝輔ぃ繧ｵ繧､繧ｺms * this.db蜻ｨ豕｢謨ｰ / 1000.0 );
+ //this.n繝舌ャ繝輔ぃ繧ｵ繧､繧ｺsample = (int) n繝舌ャ繝輔ぃ繧ｵ繧､繧ｺbyte;
+ if ( !BassAsio.BASS_ASIO_Start( this.n繝舌ャ繝輔ぃ繧ｵ繧､繧ｺsample ) ) // 遽蝗ｲ螟悶ｮ蛟､繧呈欠螳壹＠縺溷ｴ蜷医ｯ閾ｪ蜍慕噪縺ｫ繝繝輔か繝ｫ繝亥､縺ｫ險ｭ螳壹＆繧後ｋ縲
+ {
+ BASSError err = BassAsio.BASS_ASIO_ErrorGetCode();
+ BassAsio.BASS_ASIO_Free();
+ Bass.BASS_Free();
+ this.bIsBASSFree = true;
+ throw new Exception( "ASIO 繝繝舌う繧ｹ蜃ｺ蜉幃幕蟋九↓螟ｱ謨励＠縺ｾ縺励◆縲" + err.ToString() );
+ }
+ else
+ {
+ int n驕蟒ｶsample = BassAsio.BASS_ASIO_GetLatency( false ); // 縺薙ｮ髢｢謨ｰ縺ｯ BASS_ASIO_Start() 蠕後↓縺励°蜻ｼ縺ｳ蜃ｺ縺帙↑縺縲
+ int n蟶梧悍驕蟒ｶsample = (int) ( n蟶梧悍繝舌ャ繝輔ぃ繧ｵ繧､繧ｺms * this.db蜻ｨ豕｢謨ｰ / 1000.0 );
+ this.n螳溘ヰ繝繝輔ぃ繧ｵ繧､繧ｺms = this.n螳溷ｺ蜉幃≦蟒ｶms = (long) ( n驕蟒ｶsample * 1000.0f / this.db蜻ｨ豕｢謨ｰ );
+ Trace.TraceInformation( "ASIO 繝繝舌う繧ｹ蜃ｺ蜉幃幕蟋具ｼ壹ヰ繝繝輔ぃ{0}sample(蟶梧悍{1}) [{2}ms(蟶梧悍{3}ms)]", n驕蟒ｶsample, n蟶梧悍驕蟒ｶsample, this.n螳溷ｺ蜉幃≦蟒ｶms, n蟶梧悍繝舌ャ繝輔ぃ繧ｵ繧､繧ｺms );
+ }
+ }
+
+ #region [ t繧ｵ繧ｦ繝ｳ繝峨ｒ菴懈舌☆繧() ]
+ public CSound t繧ｵ繧ｦ繝ｳ繝峨ｒ菴懈舌☆繧( string str繝輔ぃ繧､繝ｫ蜷, ESoundGroup soundGroup )
+ {
+ var sound = new CSound(soundGroup);
+ sound.tASIO繧ｵ繧ｦ繝ｳ繝峨ｒ菴懈舌☆繧( str繝輔ぃ繧､繝ｫ蜷, this.hMixer );
+ return sound;
+ }
+
+ public void t繧ｵ繧ｦ繝ｳ繝峨ｒ菴懈舌☆繧( string str繝輔ぃ繧､繝ｫ蜷, CSound sound )
+ {
+ sound.tASIO繧ｵ繧ｦ繝ｳ繝峨ｒ菴懈舌☆繧( str繝輔ぃ繧､繝ｫ蜷, this.hMixer );
+ }
+ public void t繧ｵ繧ｦ繝ｳ繝峨ｒ菴懈舌☆繧( byte[] byArrWAV繝輔ぃ繧､繝ｫ繧､繝｡繝ｼ繧ｸ, CSound sound )
+ {
+ sound.tASIO繧ｵ繧ｦ繝ｳ繝峨ｒ菴懈舌☆繧( byArrWAV繝輔ぃ繧､繝ｫ繧､繝｡繝ｼ繧ｸ, this.hMixer );
+ }
+ #endregion
+
+
+ #region [ Dispose-Finallize繝代ち繝ｼ繝ｳ螳溯｣ ]
+ //-----------------
+ public void Dispose()
+ {
+ this.Dispose( true );
+ GC.SuppressFinalize( this );
+ }
+ protected void Dispose( bool bManagedDispose )
+ {
+ this.e蜃ｺ蜉帙ョ繝舌う繧ｹ = ESoundDeviceType.Unknown; // 縺ｾ縺壼ｺ蜉帛●豁｢縺吶ｋ(Dispose荳ｭ縺ｫ繧ｯ繝ｩ繧ｹ蜀縺ｫ繧｢繧ｯ繧ｻ繧ｹ縺輔ｌ繧九％縺ｨ繧帝亟縺)
+ if ( hMixer != -1 )
+ {
+ Bass.BASS_StreamFree( this.hMixer );
+ }
+ if ( !this.bIsBASSFree )
+ {
+ BassAsio.BASS_ASIO_Free(); // 繧ｷ繧ｹ繝繝繧ｿ繧､繝槭ｈ繧雁医↓蜻ｼ縺ｳ蜃ｺ縺吶％縺ｨ縲ゑｼtAsio蜃ｦ逅() 縺ｮ荳ｭ縺ｧ繧ｷ繧ｹ繝繝繧ｿ繧､繝槭ｒ蜿らｧ縺励※繧九◆繧ｼ
+ Bass.BASS_Free();
+ }
+
+ if( bManagedDispose )
+ {
+ C蜈ｱ騾.tDispose縺吶ｋ( this.tm繧ｷ繧ｹ繝繝繧ｿ繧､繝 );
+ this.tm繧ｷ繧ｹ繝繝繧ｿ繧､繝 = null;
+ }
+ }
+ ~CSoundDeviceASIO()
+ {
+ this.Dispose( false );
+ }
+ //-----------------
+ #endregion
+
+
+ protected int hMixer = -1;
+ protected int hMixer_DeviceOut = -1;
+ protected int n蜃ｺ蜉帙メ繝｣繝ｳ繝阪Ν謨ｰ = 0;
+ protected double db蜻ｨ豕｢謨ｰ = 0.0;
+ protected int n繝舌ャ繝輔ぃ繧ｵ繧､繧ｺsample = 0;
+ protected BASSASIOFormat fmtASIO繝繝舌う繧ｹ繝輔か繝ｼ繝槭ャ繝 = BASSASIOFormat.BASS_ASIO_FORMAT_UNKNOWN;
+ protected BASSASIOFormat fmtASIO繝√Ε繝ｳ繝阪Ν繝輔か繝ｼ繝槭ャ繝 = BASSASIOFormat.BASS_ASIO_FORMAT_16BIT; // 16bit 蝗ｺ螳
+ //protected BASSASIOFormat fmtASIO繝√Ε繝ｳ繝阪Ν繝輔か繝ｼ繝槭ャ繝 = BASSASIOFormat.BASS_ASIO_FORMAT_32BIT;// 16bit 蝗ｺ螳
+ protected ASIOPROC tAsioProc = null;
+
+ protected int tAsio蜃ｦ逅( bool input, int channel, IntPtr buffer, int length, IntPtr user )
+ {
+ if( input ) return 0;
+
+
+ // BASS繝溘く繧ｵ縺九ｉ縺ｮ蜃ｺ蜉帙ョ繝ｼ繧ｿ繧偵◎縺ｮ縺ｾ縺ｾ ASIO buffer 縺ｸ荳ｸ謚輔£縲
+
+ int num = Bass.BASS_ChannelGetData( this.hMixer_DeviceOut, buffer, length ); // num = 螳滄圀縺ｫ霆｢騾√＠縺滄聞縺
+
+ if ( num == -1 ) num = 0;
+
+
+ // 邨碁℃譎る俣繧呈峩譁ｰ縲
+ // 繝繝ｼ繧ｿ縺ｮ霆｢騾∝ｷｮ蛻縺ｧ縺ｯ縺ｪ縺冗ｴｯ遨崎ｻ｢騾√ヰ繧､繝域焚縺九ｉ邂怜ｺ縺吶ｋ縲
+
+ this.n邨碁℃譎る俣ms = ( this.n邏ｯ遨崎ｻ｢騾√ヰ繧､繝域焚 * 1000 / this.n繝溘く繧ｵ繝ｼ縺ｮ1遘偵≠縺溘ｊ縺ｮ繝舌う繝域焚 ) - this.n螳溷ｺ蜉幃≦蟒ｶms;
+ this.n邨碁℃譎る俣繧呈峩譁ｰ縺励◆繧ｷ繧ｹ繝繝譎ょ綾ms = this.tm繧ｷ繧ｹ繝繝繧ｿ繧､繝.n繧ｷ繧ｹ繝繝譎ょ綾ms;
+
+
+ // 邨碁℃譎る俣繧呈峩譁ｰ蠕後↓縲∽ｻ雁屓蛻縺ｮ邏ｯ遨崎ｻ｢騾√ヰ繧､繝域焚繧貞渚譏縲
+
+ this.n邏ｯ遨崎ｻ｢騾√ヰ繧､繝域焚 += num;
+ return num;
+ }
+
+ private long n繝溘く繧ｵ繝ｼ縺ｮ1遘偵≠縺溘ｊ縺ｮ繝舌う繝域焚 = 0;
+ private long n邏ｯ遨崎ｻ｢騾√ヰ繧､繝域焚 = 0;
+ private bool bIsBASSFree = true;
+ }
+}
diff --git a/FDK19/繧ｳ繝ｼ繝/03.繧ｵ繧ｦ繝ｳ繝/CSoundDeviceDirectSound.cs b/FDK19/繧ｳ繝ｼ繝/03.繧ｵ繧ｦ繝ｳ繝/CSoundDeviceDirectSound.cs
new file mode 100644
index 00000000..13a27965
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/03.繧ｵ繧ｦ繝ｳ繝/CSoundDeviceDirectSound.cs
@@ -0,0 +1,278 @@
+ｻｿusing System;
+using System.Collections.Generic;
+using System.Text;
+using System.Diagnostics;
+using System.IO;
+using System.Threading;
+using SlimDX;
+using SharpDX.DirectSound;
+
+namespace FDK
+{
+ internal class CSoundDeviceDirectSound : ISoundDevice
+ {
+ // 繝励Ο繝代ユ繧｣
+
+ public ESoundDeviceType e蜃ｺ蜉帙ョ繝舌う繧ｹ
+ {
+ get;
+ protected set;
+ }
+ public long n螳溷ｺ蜉幃≦蟒ｶms
+ {
+ get;
+ protected set;
+ }
+ public long n螳溘ヰ繝繝輔ぃ繧ｵ繧､繧ｺms
+ {
+ get;
+ protected set;
+ }
+
+ public static readonly BufferFlags DefaultFlags = BufferFlags.Defer | BufferFlags.GetCurrentPosition2 | BufferFlags.GlobalFocus | BufferFlags.ControlVolume | BufferFlags.ControlPan | BufferFlags.ControlFrequency;
+
+ // CSoundTimer 逕ｨ縺ｫ蜈ｬ髢九＠縺ｦ縺繧九励Ο繝代ユ繧｣
+
+ public long n邨碁℃譎る俣ms
+ {
+ get
+ {
+ if ( ctimer != null )
+ {
+ this.sd邨碁℃譎る俣險域ｸｬ逕ｨ繧ｵ繧ｦ繝ｳ繝峨ヰ繝繝輔ぃ.DirectSoundBuffer.GetCurrentPosition(out int n迴ｾ蝨ｨ菴咲ｽｮ, out int _);
+ long n迴ｾ蝨ｨ縺ｮ繧ｷ繧ｹ繝繝譎ょ綾ms = this.tm繧ｷ繧ｹ繝繝繧ｿ繧､繝.n繧ｷ繧ｹ繝繝譎ょ綾ms;
+
+
+ // 繝ｫ繝ｼ繝怜屓謨ｰ繧定ｪｿ謨ｴ縲
+
+ long n繧ｷ繧ｹ繝繝譎ょ綾縺ｧ縺ｮ髢馴囈ms = n迴ｾ蝨ｨ縺ｮ繧ｷ繧ｹ繝繝譎ょ綾ms - this.n蜑阪↓邨碁℃譎る俣繧呈ｸｬ螳壹＠縺溘す繧ｹ繝繝譎ょ綾ms;
+
+ while ( n繧ｷ繧ｹ繝繝譎ょ綾縺ｧ縺ｮ髢馴囈ms >= n蜊倅ｽ咲ｹｰ繧贋ｸ翫£髢馴囈ms ) // 蜑榊屓縺九ｉ蜊倅ｽ咲ｹｰ繧贋ｸ翫£髢馴囈莉･荳顔ｵ碁℃縺励※繧九↑繧臥｢ｺ螳溘↓繝ｫ繝ｼ繝励＠縺ｦ縺繧九りｪ､蟾ｮ縺ｯ螟ｧ縺阪￥縺ｪ縺縺繧阪≧縺九ｉ辟｡隕悶
+ {
+ this.n繝ｫ繝ｼ繝怜屓謨ｰ++;
+ n繧ｷ繧ｹ繝繝譎ょ綾縺ｧ縺ｮ髢馴囈ms -= n蜊倅ｽ咲ｹｰ繧贋ｸ翫£髢馴囈ms;
+ }
+
+ if ( n迴ｾ蝨ｨ菴咲ｽｮ < this.n蜑榊屓縺ｮ菴咲ｽｮ ) // 蜊倅ｽ咲ｹｰ繧贋ｸ翫£髢馴囈莉･蜀縺ｧ縺ゅ▲縺ｦ繧ゅ∫樟蝨ｨ菴咲ｽｮ縺悟燕蝗槭ｈ繧頑焔蜑阪↓縺ゅｋ縺ｪ繧1蝗槭Ν繝ｼ繝励＠縺ｦ縺繧九
+ this.n繝ｫ繝ｼ繝怜屓謨ｰ++;
+
+
+ // 邨碁℃譎る俣繧堤ｮ怜ｺ縲
+
+ long n邨碁℃譎る俣ms = (long) ( ( this.n繝ｫ繝ｼ繝怜屓謨ｰ * n蜊倅ｽ咲ｹｰ繧贋ｸ翫£髢馴囈ms ) + ( n迴ｾ蝨ｨ菴咲ｽｮ * 1000.0 / ( 44100.0 * 2 * 2 ) ) );
+
+
+ // 莉雁屓縺ｮ蛟､繧呈ｬ｡蝗槭↓蜷代¢縺ｦ菫晏ｭ倥
+
+ this.n蜑阪↓邨碁℃譎る俣繧呈ｸｬ螳壹＠縺溘す繧ｹ繝繝譎ょ綾ms = n迴ｾ蝨ｨ縺ｮ繧ｷ繧ｹ繝繝譎ょ綾ms;
+ this.n蜑榊屓縺ｮ菴咲ｽｮ = n迴ｾ蝨ｨ菴咲ｽｮ;
+
+ return n邨碁℃譎る俣ms;
+ }
+ else
+ {
+ long nRet = ctimer.n繧ｷ繧ｹ繝繝譎ょ綾ms - this.n蜑阪↓邨碁℃譎る俣繧呈ｸｬ螳壹＠縺溘す繧ｹ繝繝譎ょ綾ms;
+ if ( nRet < 0 ) // 繧ｫ繧ｦ繝ｳ繧ｿ縺後Ν繝ｼ繝励＠縺溘→縺阪ｯ
+ {
+ nRet = ( ctimer.n繧ｷ繧ｹ繝繝譎ょ綾 - long.MinValue ) + ( long.MaxValue - this.n蜑阪↓邨碁℃譎る俣繧呈ｸｬ螳壹＠縺溘す繧ｹ繝繝譎ょ綾ms ) + 1;
+ }
+ this.n蜑阪↓邨碁℃譎る俣繧呈ｸｬ螳壹＠縺溘す繧ｹ繝繝譎ょ綾ms = ctimer.n繧ｷ繧ｹ繝繝譎ょ綾ms;
+
+ return nRet;
+ }
+ }
+ }
+ public long n邨碁℃譎る俣繧呈峩譁ｰ縺励◆繧ｷ繧ｹ繝繝譎ょ綾ms
+ {
+ get { throw new NotImplementedException(); }
+ }
+ public CTimer tm繧ｷ繧ｹ繝繝繧ｿ繧､繝
+ {
+ get;
+ protected set;
+ }
+
+ public int nMasterVolume
+ {
+ get
+ {
+ return (int) 100;
+ }
+ set
+ {
+ // 迚ｹ縺ｫ菴輔ｂ縺励↑縺
+ }
+ }
+
+
+ // 繝｡繧ｽ繝繝
+
+ public CSoundDeviceDirectSound( IntPtr hWnd, long n驕蟒ｶ譎る俣ms, bool bUseOSTimer )
+ {
+ Trace.TraceInformation( "DirectSound 縺ｮ蛻晄悄蛹悶ｒ髢句ｧ九＠縺ｾ縺吶" );
+
+ this.e蜃ｺ蜉帙ョ繝舌う繧ｹ = ESoundDeviceType.Unknown;
+ this.n螳溘ヰ繝繝輔ぃ繧ｵ繧､繧ｺms = this.n螳溷ｺ蜉幃≦蟒ｶms = n驕蟒ｶ譎る俣ms;
+ this.tm繧ｷ繧ｹ繝繝繧ｿ繧､繝 = new CTimer( CTimer.E遞ｮ蛻･.MultiMedia );
+
+ #region [ DirectSound 繝繝舌う繧ｹ繧剃ｽ懈舌☆繧九]
+ //-----------------
+ this.DirectSound = new DirectSound(); // 螟ｱ謨励＠縺溘ｉ萓句､悶ｒ縺昴ｮ縺ｾ縺ｾ逋ｺ蜃ｺ縲
+
+ // 繝繝舌う繧ｹ縺ｮ蜊碑ｪｿ繝ｬ繝吶Ν繧定ｨｭ螳壹☆繧九
+
+ bool priority = true;
+ try
+ {
+ this.DirectSound.SetCooperativeLevel( hWnd, CooperativeLevel.Priority );
+ }
+ catch
+ {
+ this.DirectSound.SetCooperativeLevel( hWnd, CooperativeLevel.Normal ); // 縺薙ｌ縺ｧ繧ょ､ｱ謨励＠縺溘ｉ萓句､悶ｒ縺昴ｮ縺ｾ縺ｾ逋ｺ蜃ｺ縲
+ priority = false;
+ }
+
+ // 繝繝舌う繧ｹ菴懈仙ｮ御ｺ縲
+
+ this.e蜃ｺ蜉帙ョ繝舌う繧ｹ = ESoundDeviceType.DirectSound;
+ //-----------------
+ #endregion
+
+ if ( !bUseOSTimer )
+ {
+ #region [ 邨碁℃譎る俣險域ｸｬ逕ｨ繧ｵ繧ｦ繝ｳ繝峨ヰ繝繝輔ぃ繧剃ｽ懈舌＠縲√Ν繝ｼ繝怜咲函繧帝幕蟋九☆繧九]
+ //-----------------
+
+ // 蜊倅ｽ咲ｹｰ繧贋ｸ翫£髢馴囈[遘綻縺ｮ髟ｷ縺輔ｒ謖√▽辟｡髻ｳ縺ｮ繧ｵ繧ｦ繝ｳ繝峨ｒ菴懈舌
+
+ uint n繝繝ｼ繧ｿ繧ｵ繧､繧ｺbyte = n蜊倅ｽ咲ｹｰ繧贋ｸ翫£髢馴囈sec * 44100 * 2 * 2;
+ var ms = new MemoryStream();
+ var bw = new BinaryWriter( ms );
+ bw.Write( (uint) 0x46464952 ); // 'RIFF'
+ bw.Write( (uint) ( 44 + n繝繝ｼ繧ｿ繧ｵ繧､繧ｺbyte - 8 ) ); // 繝輔ぃ繧､繝ｫ繧ｵ繧､繧ｺ - 8
+ bw.Write( (uint) 0x45564157 ); // 'WAVE'
+ bw.Write( (uint) 0x20746d66 ); // 'fmt '
+ bw.Write( (uint) 16 ); // 繝舌う繝域焚
+ bw.Write( (ushort) 1 ); // 繝輔か繝ｼ繝槭ャ繝ID(繝ｪ繝九いPCM)
+ bw.Write( (ushort) 2 ); // 繝√Ε繝ｳ繝阪Ν謨ｰ
+ bw.Write( (uint) 44100 ); // 繧ｵ繝ｳ繝励Μ繝ｳ繧ｰ蜻ｨ豕｢謨ｰ
+ bw.Write( (uint) ( 44100 * 2 * 2 ) ); // bytes/sec
+ bw.Write( (ushort) ( 2 * 2 ) ); // block繧ｵ繧､繧ｺ
+ bw.Write( (ushort) 16 ); // bit/sample
+ bw.Write( (uint) 0x61746164 ); // 'data'
+ bw.Write( (uint) n繝繝ｼ繧ｿ繧ｵ繧､繧ｺbyte ); // 繝繝ｼ繧ｿ髟ｷ
+ for ( int i = 0; i < n繝繝ｼ繧ｿ繧ｵ繧､繧ｺbyte / sizeof( long ); i++ ) // PCM繝繝ｼ繧ｿ
+ bw.Write( (long) 0 );
+ var byArrWaveFleImage = ms.ToArray();
+ bw.Close();
+ ms = null;
+ bw = null;
+ this.sd邨碁℃譎る俣險域ｸｬ逕ｨ繧ｵ繧ｦ繝ｳ繝峨ヰ繝繝輔ぃ = this.t繧ｵ繧ｦ繝ｳ繝峨ｒ菴懈舌☆繧( byArrWaveFleImage, ESoundGroup.Unknown );
+
+ CSound.list繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ.Remove( this.sd邨碁℃譎る俣險域ｸｬ逕ｨ繧ｵ繧ｦ繝ｳ繝峨ヰ繝繝輔ぃ ); // 迚ｹ谿顔畑騾斐↑縺ｮ縺ｧ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ繝ｪ繧ｹ繝医°繧峨ｯ髯､螟悶☆繧九
+
+ // 繧ｵ繧ｦ繝ｳ繝峨ｮ繝ｫ繝ｼ繝怜咲函髢句ｧ九
+
+ this.n繝ｫ繝ｼ繝怜屓謨ｰ = 0;
+ this.n蜑榊屓縺ｮ菴咲ｽｮ = 0;
+ this.sd邨碁℃譎る俣險域ｸｬ逕ｨ繧ｵ繧ｦ繝ｳ繝峨ヰ繝繝輔ぃ.DirectSoundBuffer.Play( 0, PlayFlags.Looping );
+ this.n蜑阪↓邨碁℃譎る俣繧呈ｸｬ螳壹＠縺溘す繧ｹ繝繝譎ょ綾ms = this.tm繧ｷ繧ｹ繝繝繧ｿ繧､繝.n繧ｷ繧ｹ繝繝譎ょ綾ms;
+ //-----------------
+ #endregion
+ }
+ else
+ {
+ ctimer = new CTimer( CTimer.E遞ｮ蛻･.MultiMedia );
+ }
+ Trace.TraceInformation( "DirectSound 繧貞晄悄蛹悶＠縺ｾ縺励◆縲({0})({1})", ( priority ) ? "Priority" : "Normal", bUseOSTimer? "OStimer" : "FDKtimer" );
+ }
+
+ public CSound t繧ｵ繧ｦ繝ｳ繝峨ｒ菴懈舌☆繧( string str繝輔ぃ繧､繝ｫ蜷, ESoundGroup soundGroup )
+ {
+ var sound = new CSound(soundGroup);
+ sound.tDirectSound繧ｵ繧ｦ繝ｳ繝峨ｒ菴懈舌☆繧( str繝輔ぃ繧､繝ｫ蜷, this.DirectSound );
+ return sound;
+ }
+
+ private CSound t繧ｵ繧ｦ繝ｳ繝峨ｒ菴懈舌☆繧( byte[] byArrWAV繝輔ぃ繧､繝ｫ繧､繝｡繝ｼ繧ｸ, ESoundGroup soundGroup )
+ {
+ var sound = new CSound(soundGroup);
+ sound.tDirectSound繧ｵ繧ｦ繝ｳ繝峨ｒ菴懈舌☆繧( byArrWAV繝輔ぃ繧､繝ｫ繧､繝｡繝ｼ繧ｸ, this.DirectSound );
+ return sound;
+ }
+
+ // 譌｢蟄倥ｮ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹｼ育函謌千峩蠕 or Dispose貂医∩ｼ峨↓蟇ｾ縺励※繧ｵ繧ｦ繝ｳ繝峨ｒ逕滓舌☆繧九
+ public void t繧ｵ繧ｦ繝ｳ繝峨ｒ菴懈舌☆繧( string str繝輔ぃ繧､繝ｫ蜷, CSound sound )
+ {
+ sound.tDirectSound繧ｵ繧ｦ繝ｳ繝峨ｒ菴懈舌☆繧( str繝輔ぃ繧､繝ｫ蜷, this.DirectSound );
+ }
+ public void t繧ｵ繧ｦ繝ｳ繝峨ｒ菴懈舌☆繧( byte[] byArrWAV繝輔ぃ繧､繝ｫ繧､繝｡繝ｼ繧ｸ, CSound sound )
+ {
+ sound.tDirectSound繧ｵ繧ｦ繝ｳ繝峨ｒ菴懈舌☆繧( byArrWAV繝輔ぃ繧､繝ｫ繧､繝｡繝ｼ繧ｸ, this.DirectSound );
+ }
+ public void t繧ｵ繧ｦ繝ｳ繝峨ｒ菴懈舌☆繧( byte[] byArrWAV繝輔ぃ繧､繝ｫ繧､繝｡繝ｼ繧ｸ, BufferFlags flags, CSound sound )
+ {
+ sound.tDirectSound繧ｵ繧ｦ繝ｳ繝峨ｒ菴懈舌☆繧( byArrWAV繝輔ぃ繧､繝ｫ繧､繝｡繝ｼ繧ｸ, this.DirectSound, flags );
+ }
+
+ #region [ Dispose-Finallize繝代ち繝ｼ繝ｳ螳溯｣ ]
+ //-----------------
+ public void Dispose()
+ {
+ this.Dispose( true );
+ GC.SuppressFinalize( this );
+ }
+ protected void Dispose( bool bManagedDispose )
+ {
+ this.e蜃ｺ蜉帙ョ繝舌う繧ｹ = ESoundDeviceType.Unknown; // 縺ｾ縺壼ｺ蜉帛●豁｢縺吶ｋ(Dispose荳ｭ縺ｫ繧ｯ繝ｩ繧ｹ蜀縺ｫ繧｢繧ｯ繧ｻ繧ｹ縺輔ｌ繧九％縺ｨ繧帝亟縺)
+ if ( bManagedDispose )
+ {
+ #region [ 邨檎ｷｯ譎る俣險域ｸｬ逕ｨ繧ｵ繧ｦ繝ｳ繝峨ヰ繝繝輔ぃ繧定ｧ｣謾ｾ縲]
+ //-----------------
+ if ( this.sd邨碁℃譎る俣險域ｸｬ逕ｨ繧ｵ繧ｦ繝ｳ繝峨ヰ繝繝輔ぃ != null )
+ {
+ this.sd邨碁℃譎る俣險域ｸｬ逕ｨ繧ｵ繧ｦ繝ｳ繝峨ヰ繝繝輔ぃ.t繧ｵ繧ｦ繝ｳ繝峨ｒ蛛懈ｭ｢縺吶ｋ();
+ C蜈ｱ騾.tDispose縺吶ｋ( ref this.sd邨碁℃譎る俣險域ｸｬ逕ｨ繧ｵ繧ｦ繝ｳ繝峨ヰ繝繝輔ぃ );
+ }
+ //-----------------
+ #endregion
+ #region [ 蜊倅ｽ咲ｹｰ繧贋ｸ翫£逕ｨ繧ｹ繝ｬ繝繝牙●豁｢縲]
+ //-----------------
+ if( this.th邨碁℃譎る俣貂ｬ螳夂畑繧ｹ繝ｬ繝繝 != null )
+ {
+ this.th邨碁℃譎る俣貂ｬ螳夂畑繧ｹ繝ｬ繝繝.Abort();
+ this.th邨碁℃譎る俣貂ｬ螳夂畑繧ｹ繝ｬ繝繝 = null;
+
+ }
+ //-----------------
+ #endregion
+
+ C蜈ｱ騾.tDispose縺吶ｋ( ref this.DirectSound );
+ C蜈ｱ騾.tDispose縺吶ｋ( this.tm繧ｷ繧ｹ繝繝繧ｿ繧､繝 );
+ }
+ if ( ctimer != null )
+ {
+ C蜈ｱ騾.tDispose縺吶ｋ( ref this.ctimer );
+ }
+ }
+ ~CSoundDeviceDirectSound()
+ {
+ this.Dispose( false );
+ }
+ //-----------------
+ #endregion
+
+ protected DirectSound DirectSound = null;
+ protected CSound sd邨碁℃譎る俣險域ｸｬ逕ｨ繧ｵ繧ｦ繝ｳ繝峨ヰ繝繝輔ぃ = null;
+ protected Thread th邨碁℃譎る俣貂ｬ螳夂畑繧ｹ繝ｬ繝繝 = null;
+// protected AutoResetEvent autoResetEvent = new AutoResetEvent( false );
+ protected const uint n蜊倅ｽ咲ｹｰ繧贋ｸ翫£髢馴囈sec = 1; // [遘綻
+ protected const uint n蜊倅ｽ咲ｹｰ繧贋ｸ翫£髢馴囈ms = n蜊倅ｽ咲ｹｰ繧贋ｸ翫£髢馴囈sec * 1000; // [繝溘Μ遘綻
+ protected int n繝ｫ繝ｼ繝怜屓謨ｰ = 0;
+
+ private long n蜑阪↓邨碁℃譎る俣繧呈ｸｬ螳壹＠縺溘す繧ｹ繝繝譎ょ綾ms = CTimer.n譛ｪ菴ｿ逕ｨ;
+ private int n蜑榊屓縺ｮ菴咲ｽｮ = 0;
+
+ private CTimer ctimer = null;
+ }
+}
diff --git a/FDK19/繧ｳ繝ｼ繝/03.繧ｵ繧ｦ繝ｳ繝/CSoundDeviceWASAPI.cs b/FDK19/繧ｳ繝ｼ繝/03.繧ｵ繧ｦ繝ｳ繝/CSoundDeviceWASAPI.cs
new file mode 100644
index 00000000..8e1cd920
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/03.繧ｵ繧ｦ繝ｳ繝/CSoundDeviceWASAPI.cs
@@ -0,0 +1,447 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Diagnostics;
+using Un4seen.Bass;
+using Un4seen.BassWasapi;
+using Un4seen.Bass.AddOn.Mix;
+
+namespace FDK
+{
+ internal class CSoundDeviceWASAPI : ISoundDevice
+ {
+ // 繝励Ο繝代ユ繧｣
+
+ public ESoundDeviceType e蜃ｺ蜉帙ョ繝舌う繧ｹ
+ {
+ get;
+ protected set;
+ }
+ public long n螳溷ｺ蜉幃≦蟒ｶms
+ {
+ get;
+ protected set;
+ }
+ public long n螳溘ヰ繝繝輔ぃ繧ｵ繧､繧ｺms
+ {
+ get;
+ protected set;
+ }
+
+ // CSoundTimer 逕ｨ縺ｫ蜈ｬ髢九＠縺ｦ縺繧九励Ο繝代ユ繧｣
+
+ public long n邨碁℃譎る俣ms
+ {
+ get;
+ protected set;
+ }
+ public long n邨碁℃譎る俣繧呈峩譁ｰ縺励◆繧ｷ繧ｹ繝繝譎ょ綾ms
+ {
+ get;
+ protected set;
+ }
+ public CTimer tm繧ｷ繧ｹ繝繝繧ｿ繧､繝
+ {
+ get;
+ protected set;
+ }
+
+ public enum E繝繝舌う繧ｹ繝｢繝ｼ繝 { 謗剃ｻ, 蜈ｱ譛 }
+
+ public int nMasterVolume
+ {
+ get
+ {
+ float f髻ｳ驥 = 0.0f;
+ //if ( BassMix.BASS_Mixer_ChannelGetEnvelopePos( this.hMixer, BASSMIXEnvelope.BASS_MIXER_ENV_VOL, ref f髻ｳ驥 ) == -1 )
+ // return 100;
+ //bool b = Bass.BASS_ChannelGetAttribute( this.hMixer, BASSAttribute.BASS_ATTRIB_VOL, ref f髻ｳ驥 );
+ bool b = Bass.BASS_ChannelGetAttribute( this.hMixer, BASSAttribute.BASS_ATTRIB_VOL, ref f髻ｳ驥 );
+ if ( !b )
+ {
+ BASSError be = Bass.BASS_ErrorGetCode();
+ Trace.TraceInformation( "WASAPI Master Volume Get Error: " + be.ToString() );
+ }
+ else
+ {
+ Trace.TraceInformation( "WASAPI Master Volume Get Success: " + (f髻ｳ驥 * 100) );
+
+ }
+ return (int) ( f髻ｳ驥 * 100 );
+ }
+ set
+ {
+ // bool b = Bass.BASS_SetVolume( value / 100.0f );
+ // 竊脱xclusive繝｢繝ｼ繝画凾縺ｯ辟｡蜉ｹ
+
+// bool b = BassWasapi.BASS_WASAPI_SetVolume( BASSWASAPIVolume.BASS_WASAPI_VOL_SESSION, (float) ( value / 100 ) );
+// bool b = BassWasapi.BASS_WASAPI_SetVolume( BASSWASAPIVolume.BASS_WASAPI_CURVE_WINDOWS, (float) ( value / 100 ) );
+ bool b = Bass.BASS_ChannelSetAttribute( this.hMixer, BASSAttribute.BASS_ATTRIB_VOL, (float) ( value / 100.0 ) );
+ // If you would like to have a volume control in exclusive mode too, and you're using the BASSmix add-on,
+ // you can adjust the source's BASS_ATTRIB_VOL setting via BASS_ChannelSetAttribute.
+ // 縺励°縺励”Mixer縺ｫ蟇ｾ縺吶ｋBASS_ChannelSetAttribute()縺ｧBASS_ATTRIB_VOL繧貞､画峩: 縺ｪ縺懊°蜃ｺ蜉幃浹驥上↓蜿肴丐縺輔ｌ縺
+
+ // Bass_SetVolume(): BASS_ERROR_NOTAVIL ("no sound" device縺ｫ縺ｯ驕ｩ逕ｨ荳榊庄)
+
+ // Mixer_ChannelSetEnvelope():
+
+ //var nodes = new BASS_MIXER_NODE[ 1 ] { new BASS_MIXER_NODE( 0, (float) value ) };
+ //bool b = BassMix.BASS_Mixer_ChannelSetEnvelope( this.hMixer, BASSMIXEnvelope.BASS_MIXER_ENV_VOL, nodes );
+ //bool b = Bass.BASS_ChannelSetAttribute( this.hMixer, BASSAttribute.BASS_ATTRIB_VOL, value / 100.0f );
+ if ( !b )
+ {
+ BASSError be = Bass.BASS_ErrorGetCode();
+ Trace.TraceInformation( "WASAPI Master Volume Set Error: " + be.ToString() );
+ }
+ else
+ {
+ // int n = this.nMasterVolume;
+ // Trace.TraceInformation( "WASAPI Master Volume Set Success: " + value );
+
+ }
+ }
+ }
+ // 繝｡繧ｽ繝繝
+
+ ///
+ /// WASAPI縺ｮ蛻晄悄蛹
+ ///
+ ///
+ /// (譛ｪ菴ｿ逕ｨ; 譛ｬ繝｡繧ｽ繝繝牙縺ｧ閾ｪ蜍戊ｨｭ螳壹☆繧)
+ /// (譛ｪ菴ｿ逕ｨ; 譛ｬ繝｡繧ｽ繝繝牙縺ｧ閾ｪ蜍戊ｨｭ螳壹☆繧)
+ public CSoundDeviceWASAPI( E繝繝舌う繧ｹ繝｢繝ｼ繝 mode, long n蟶梧悍繝舌ャ繝輔ぃ繧ｵ繧､繧ｺms, long n譖ｴ譁ｰ髢馴囈ms )
+ {
+ // 蛻晄悄蛹悶
+
+ Trace.TraceInformation( "BASS (WASAPI) 縺ｮ蛻晄悄蛹悶ｒ髢句ｧ九＠縺ｾ縺吶" );
+
+ this.e蜃ｺ蜉帙ョ繝舌う繧ｹ = ESoundDeviceType.Unknown;
+ this.n螳溷ｺ蜉幃≦蟒ｶms = 0;
+ this.n邨碁℃譎る俣ms = 0;
+ this.n邨碁℃譎る俣繧呈峩譁ｰ縺励◆繧ｷ繧ｹ繝繝譎ょ綾ms = CTimer.n譛ｪ菴ｿ逕ｨ;
+ this.tm繧ｷ繧ｹ繝繝繧ｿ繧､繝 = new CTimer( CTimer.E遞ｮ蛻･.MultiMedia );
+ this.b譛蛻昴ｮ螳溷ｺ蜉幃≦蟒ｶ邂怜ｺ = true;
+
+ #region [ BASS registration ]
+ // BASS.NET 繝ｦ繝ｼ繧ｶ逋ｻ骭ｲｼBASS繧ｹ繝励Λ繝繧ｷ繝･縺碁撼陦ｨ遉ｺ縺ｫ縺ｪ繧具ｼ峨
+
+ BassNet.Registration( "dtx2013@gmail.com", "2X9181017152222" );
+ #endregion
+
+ #region [ BASS Version Check ]
+ // BASS 縺ｮ繝舌ｼ繧ｸ繝ｧ繝ｳ繝√ぉ繝繧ｯ縲
+ int nBASSVersion = Utils.HighWord( Bass.BASS_GetVersion() );
+ if( nBASSVersion != Bass.BASSVERSION )
+ throw new DllNotFoundException( string.Format( "bass.dll 縺ｮ繝舌ｼ繧ｸ繝ｧ繝ｳ縺檎焚縺ｪ繧翫∪縺({0})縲ゅ％縺ｮ繝励Ο繧ｰ繝ｩ繝縺ｯ繝舌ｼ繧ｸ繝ｧ繝ｳ{1}縺ｧ蜍穂ｽ懊＠縺ｾ縺吶", nBASSVersion, Bass.BASSVERSION ) );
+
+ int nBASSMixVersion = Utils.HighWord( BassMix.BASS_Mixer_GetVersion() );
+ if( nBASSMixVersion != BassMix.BASSMIXVERSION )
+ throw new DllNotFoundException( string.Format( "bassmix.dll 縺ｮ繝舌ｼ繧ｸ繝ｧ繝ｳ縺檎焚縺ｪ繧翫∪縺({0})縲ゅ％縺ｮ繝励Ο繧ｰ繝ｩ繝縺ｯ繝舌ｼ繧ｸ繝ｧ繝ｳ{1}縺ｧ蜍穂ｽ懊＠縺ｾ縺吶", nBASSMixVersion, BassMix.BASSMIXVERSION ) );
+
+ int nBASSWASAPIVersion = Utils.HighWord( BassWasapi.BASS_WASAPI_GetVersion() );
+ if( nBASSWASAPIVersion != BassWasapi.BASSWASAPIVERSION )
+ throw new DllNotFoundException( string.Format( "basswasapi.dll 縺ｮ繝舌ｼ繧ｸ繝ｧ繝ｳ縺檎焚縺ｪ繧翫∪縺({0})縲ゅ％縺ｮ繝励Ο繧ｰ繝ｩ繝縺ｯ繝舌ｼ繧ｸ繝ｧ繝ｳ{1}縺ｧ蜍穂ｽ懊＠縺ｾ縺吶", nBASSWASAPIVersion, BassWasapi.BASSWASAPIVERSION ) );
+ #endregion
+
+ // BASS 縺ｮ險ｭ螳壹
+
+ this.bIsBASSFree = true;
+
+ if (!Bass.BASS_SetConfig( BASSConfig.BASS_CONFIG_UPDATEPERIOD, 0 )) // 0:BASS繧ｹ繝医Μ繝ｼ繝縺ｮ閾ｪ蜍墓峩譁ｰ繧定｡後ｏ縺ｪ縺縲
+ {
+ Trace.TraceWarning($"BASS_SetConfig({nameof(BASSConfig.BASS_CONFIG_UPDATEPERIOD)}) 縺ｫ螟ｱ謨励＠縺ｾ縺励◆縲[{Bass.BASS_ErrorGetCode()}]");
+ }
+ if (!Bass.BASS_SetConfig( BASSConfig.BASS_CONFIG_UPDATETHREADS, 0 )) // 0:BASS繧ｹ繝医Μ繝ｼ繝縺ｮ閾ｪ蜍墓峩譁ｰ繧定｡後ｏ縺ｪ縺縲
+ {
+ Trace.TraceWarning($"BASS_SetConfig({nameof(BASSConfig.BASS_CONFIG_UPDATETHREADS)}) 縺ｫ螟ｱ謨励＠縺ｾ縺励◆縲[{Bass.BASS_ErrorGetCode()}]");
+ }
+
+ // BASS 縺ｮ蛻晄悄蛹悶
+
+ int n繝繝舌う繧ｹ = 0; // 0:"no device" 窶ｦ BASS 縺九ｉ縺ｯ繝繝舌う繧ｹ縺ｸ繧｢繧ｯ繧ｻ繧ｹ縺輔○縺ｪ縺縲ゅい繧ｯ繧ｻ繧ｹ縺ｯ BASSWASAPI 繧｢繝峨が繝ｳ縺九ｉ陦後≧縲
+ int n蜻ｨ豕｢謨ｰ = 44100; // 莉ｮ豎ｺ繧√Ｍ繝繝舌う繧ｹｼ遺旺繝峨Λ繧､繝撰ｼ峨′繝阪う繝繧｣繝悶↓蟇ｾ蠢懊＠縺ｦ縺繧句捉豕｢謨ｰ縺ｧ縺ゅｌ縺ｰ菴輔〒繧ゅ＞縺ｼ溘ｈ縺縺縲BASSWASAPI縺ｧ繝繝舌う繧ｹ縺ｮ蜻ｨ豕｢謨ｰ縺ｯ螟峨∴繧峨ｌ繧九ゅ＞縺壹ｌ縺ｫ縺励ｍBASSMX縺ｧ閾ｪ蜍慕噪縺ｫ繝ｪ繧ｵ繝ｳ繝励Μ繝ｳ繧ｰ縺輔ｌ繧九
+ if( !Bass.BASS_Init( n繝繝舌う繧ｹ, n蜻ｨ豕｢謨ｰ, BASSInit.BASS_DEVICE_DEFAULT, IntPtr.Zero ) )
+ throw new Exception( string.Format( "BASS (WASAPI) 縺ｮ蛻晄悄蛹悶↓螟ｱ謨励＠縺ｾ縺励◆縲(BASS_Init)[{0}]", Bass.BASS_ErrorGetCode().ToString() ) );
+
+ Bass.BASS_SetConfig(BASSConfig.BASS_CONFIG_CURVE_VOL, true);
+
+ #region [ 繝繝舌ャ繧ｰ逕ｨ: WASAPI繝繝舌う繧ｹ縺ｮenumerate縺ｨ縲√Ο繧ｰ蜃ｺ蜉 ]
+ // (繝繝舌ャ繧ｰ逕ｨ)
+ //Trace.TraceInformation( "WASAPI繝繝舌う繧ｹ荳隕ｧ:" );
+ //int a, count = 0;
+ //BASS_WASAPI_DEVICEINFO wasapiDevInfo;
+ //for ( a = 0; ( wasapiDevInfo = BassWasapi.BASS_WASAPI_GetDeviceInfo( a ) ) != null; a++ )
+ //{
+ // if ( ( wasapiDevInfo.flags & BASSWASAPIDeviceInfo.BASS_DEVICE_INPUT ) == 0 // device is an output device (not input)
+ // && ( wasapiDevInfo.flags & BASSWASAPIDeviceInfo.BASS_DEVICE_ENABLED ) != 0 ) // and it is enabled
+ // {
+ // Trace.TraceInformation( "WASAPI Device #{0}: {1}", a, wasapiDevInfo.name );
+ // count++; // count it
+ // }
+ //}
+ #endregion
+
+ // BASS WASAPI 縺ｮ蛻晄悄蛹悶
+
+ n繝繝舌う繧ｹ = -1;
+ n蜻ｨ豕｢謨ｰ = 0; // 繝繝輔か繝ｫ繝医ョ繝舌う繧ｹ縺ｮ蜻ｨ豕｢謨ｰ (0="mix format" sample rate)
+ int n繝√Ε繝ｳ繝阪Ν謨ｰ = 0; // 繝繝輔か繝ｫ繝医ョ繝舌う繧ｹ縺ｮ繝√Ε繝ｳ繝阪Ν謨ｰ (0="mix format" channels)
+ this.tWasapiProc = new WASAPIPROC( this.tWASAPI蜃ｦ逅 ); // 繧｢繝ｳ繝槭ロ繝ｼ繧ｸ縺ｫ貂｡縺 delegate 縺ｯ縲√ヵ繧｣繝ｼ繝ｫ繝峨→縺励※菫晄戟縺励※縺翫°縺ｪ縺縺ｨGC縺ｧ繧｢繝峨Ξ繧ｹ縺悟､峨ｏ縺｣縺ｦ縺励∪縺縲
+
+ // WASAPI縺ｮ譖ｴ譁ｰ髢馴囈(period)縺ｯ縲√ヰ繝繝輔ぃ繧ｵ繧､繧ｺ縺ｫ繧ょｽｱ髻ｿ繧剃ｸ弱∴繧九
+ // 譖ｴ譁ｰ髢馴囈繧呈怙蟆上↓縺吶ｋ縺ｫ縺ｯ縲。assWasapi.BASS_WASAPI_GetDeviceInfo( ndevNo ).minperiod 縺ｮ蛟､繧剃ｽｿ縺医ｰ繧医＞縲
+ // 縺薙ｌ繧偵ｄ繧峨↑縺縺ｨ縲∵峩譁ｰ髢馴囈ms=6ms 縺ｨ縺ｪ繧翫√ヰ繝繝輔ぃ繧ｵ繧､繧ｺ繧 6ms x 4 = 24ms繧医ｊ蟆上＆縺上〒縺阪↑縺縲
+ #region [ 譌｢螳壹ｮ蜃ｺ蜉帙ョ繝舌う繧ｹ縺ｨ險ｭ螳壹＆繧後※縺繧妓ASAPI繝繝舌う繧ｹ繧呈､懃ｴ｢縺励∵峩譁ｰ髢馴囈ms繧定ｨｭ螳壹〒縺阪ｋ譛蟆丞､縺ｫ縺吶ｋ ]
+ int nDevNo = -1;
+ BASS_WASAPI_DEVICEINFO deviceInfo;
+ for ( int n = 0; ( deviceInfo = BassWasapi.BASS_WASAPI_GetDeviceInfo( n ) ) != null; n++ )
+ {
+ if ( deviceInfo.IsDefault )
+ {
+ nDevNo = n;
+ break;
+ }
+ }
+ if ( nDevNo != -1 )
+ {
+ // Trace.TraceInformation( "Selected Default WASAPI Device: {0}", deviceInfo.name );
+ // Trace.TraceInformation( "MinPeriod={0}, DefaultPeriod={1}", deviceInfo.minperiod, deviceInfo.defperiod );
+ n譖ｴ譁ｰ髢馴囈ms = (long) ( deviceInfo.minperiod * 1000 );
+ if ( n蟶梧悍繝舌ャ繝輔ぃ繧ｵ繧､繧ｺms <= 0 || n蟶梧悍繝舌ャ繝輔ぃ繧ｵ繧､繧ｺms < n譖ｴ譁ｰ髢馴囈ms + 1 )
+ {
+ n蟶梧悍繝舌ャ繝輔ぃ繧ｵ繧､繧ｺms = n譖ｴ譁ｰ髢馴囈ms + 1; // 2013.4.25 #31237 yyagi; 繝舌ャ繝輔ぃ繧ｵ繧､繧ｺ險ｭ螳壹ｮ螳悟ｨ閾ｪ蜍募喧縲よ峩譁ｰ髢馴囈ｼ昴ヰ繝繝輔ぃ繧ｵ繧､繧ｺ縺ｫ縺吶ｋ縺ｨBASS_ERROR_UNKNOWN縺ｫ縺ｪ繧九ｮ縺ｧ+1縺吶ｋ縲
+ }
+ }
+ else
+ {
+ Trace.TraceError( "Error: Default WASAPI Device is not found." );
+ }
+ #endregion
+
+//Retry:
+ var flags = ( mode == E繝繝舌う繧ｹ繝｢繝ｼ繝.謗剃ｻ ) ? BASSWASAPIInit.BASS_WASAPI_AUTOFORMAT | BASSWASAPIInit.BASS_WASAPI_EXCLUSIVE : BASSWASAPIInit.BASS_WASAPI_AUTOFORMAT;
+ //var flags = ( mode == E繝繝舌う繧ｹ繝｢繝ｼ繝.謗剃ｻ ) ? BASSWASAPIInit.BASS_WASAPI_AUTOFORMAT | BASSWASAPIInit.BASS_WASAPI_EVENT | BASSWASAPIInit.BASS_WASAPI_EXCLUSIVE : BASSWASAPIInit.BASS_WASAPI_AUTOFORMAT | BASSWASAPIInit.BASS_WASAPI_EVENT;
+ if ( BassWasapi.BASS_WASAPI_Init( n繝繝舌う繧ｹ, n蜻ｨ豕｢謨ｰ, n繝√Ε繝ｳ繝阪Ν謨ｰ, flags, ( n蟶梧悍繝舌ャ繝輔ぃ繧ｵ繧､繧ｺms / 1000.0f ), ( n譖ｴ譁ｰ髢馴囈ms / 1000.0f ), this.tWasapiProc, IntPtr.Zero ) )
+ {
+ if( mode == E繝繝舌う繧ｹ繝｢繝ｼ繝.謗剃ｻ )
+ {
+ #region [ 謗剃ｻ悶Δ繝ｼ繝峨〒菴懈先仙粥縲]
+ //-----------------
+ this.e蜃ｺ蜉帙ョ繝舌う繧ｹ = ESoundDeviceType.ExclusiveWASAPI;
+
+ nDevNo = BassWasapi.BASS_WASAPI_GetDevice();
+ deviceInfo = BassWasapi.BASS_WASAPI_GetDeviceInfo( nDevNo );
+ var wasapiInfo = BassWasapi.BASS_WASAPI_GetInfo();
+ int n1繧ｵ繝ｳ繝励Ν縺ｮ繝舌う繝域焚 = 2 * wasapiInfo.chans; // default;
+ switch( wasapiInfo.format ) // BASS WASAPI 縺ｧ謇ｱ縺繧ｵ繝ｳ繝励Ν縺ｯ縺吶∋縺ｦ 32bit float 縺ｧ蝗ｺ螳壹＆繧後※縺繧九′縲√ョ繝舌う繧ｹ縺ｯ縺昴≧縺ｨ縺ｯ髯舌ｉ縺ｪ縺縲
+ {
+ case BASSWASAPIFormat.BASS_WASAPI_FORMAT_8BIT: n1繧ｵ繝ｳ繝励Ν縺ｮ繝舌う繝域焚 = 1 * wasapiInfo.chans; break;
+ case BASSWASAPIFormat.BASS_WASAPI_FORMAT_16BIT: n1繧ｵ繝ｳ繝励Ν縺ｮ繝舌う繝域焚 = 2 * wasapiInfo.chans; break;
+ case BASSWASAPIFormat.BASS_WASAPI_FORMAT_24BIT: n1繧ｵ繝ｳ繝励Ν縺ｮ繝舌う繝域焚 = 3 * wasapiInfo.chans; break;
+ case BASSWASAPIFormat.BASS_WASAPI_FORMAT_32BIT: n1繧ｵ繝ｳ繝励Ν縺ｮ繝舌う繝域焚 = 4 * wasapiInfo.chans; break;
+ case BASSWASAPIFormat.BASS_WASAPI_FORMAT_FLOAT: n1繧ｵ繝ｳ繝励Ν縺ｮ繝舌う繝域焚 = 4 * wasapiInfo.chans; break;
+ }
+ int n1遘偵ｮ繝舌う繝域焚 = n1繧ｵ繝ｳ繝励Ν縺ｮ繝舌う繝域焚 * wasapiInfo.freq;
+ this.n螳溘ヰ繝繝輔ぃ繧ｵ繧､繧ｺms = (long) ( wasapiInfo.buflen * 1000.0f / n1遘偵ｮ繝舌う繝域焚 );
+ this.n螳溷ｺ蜉幃≦蟒ｶms = 0; // 蛻晄悄蛟､縺ｯ繧ｼ繝ｭ
+ Trace.TraceInformation( "菴ｿ逕ｨ繝繝舌う繧ｹ: #" + nDevNo + " : " + deviceInfo.name + ", flags=" + deviceInfo.flags );
+ Trace.TraceInformation( "BASS 繧貞晄悄蛹悶＠縺ｾ縺励◆縲(WASAPI謗剃ｻ悶Δ繝ｼ繝, {0}Hz, {1}ch, 繝輔か繝ｼ繝槭ャ繝:{2}, 繝舌ャ繝輔ぃ{3}bytes [{4}ms(蟶梧悍{5}ms)], 譖ｴ譁ｰ髢馴囈{6}ms)",
+ wasapiInfo.freq,
+ wasapiInfo.chans,
+ wasapiInfo.format.ToString(),
+ wasapiInfo.buflen,
+ n螳溘ヰ繝繝輔ぃ繧ｵ繧､繧ｺms.ToString(),
+ n蟶梧悍繝舌ャ繝輔ぃ繧ｵ繧､繧ｺms.ToString(),
+ n譖ｴ譁ｰ髢馴囈ms.ToString() );
+ Trace.TraceInformation( "繝繝舌う繧ｹ縺ｮ譛蟆乗峩譁ｰ譎る俣={0}ms, 譌｢螳壹ｮ譖ｴ譁ｰ譎る俣={1}ms", deviceInfo.minperiod * 1000, deviceInfo.defperiod * 1000 );
+ this.bIsBASSFree = false;
+ //-----------------
+ #endregion
+ }
+ else
+ {
+ #region [ 蜈ｱ譛峨Δ繝ｼ繝峨〒菴懈先仙粥縲]
+ //-----------------
+ this.e蜃ｺ蜉帙ョ繝舌う繧ｹ = ESoundDeviceType.SharedWASAPI;
+
+ this.n螳溷ｺ蜉幃≦蟒ｶms = 0; // 蛻晄悄蛟､縺ｯ繧ｼ繝ｭ
+ var devInfo = BassWasapi.BASS_WASAPI_GetDeviceInfo( BassWasapi.BASS_WASAPI_GetDevice() ); // 蜈ｱ譛峨Δ繝ｼ繝峨ｮ蝣ｴ蜷医∵峩譁ｰ髢馴囈縺ｯ繝繝舌う繧ｹ縺ｮ繝繝輔か繝ｫ繝亥､縺ｫ蝗ｺ螳壹＆繧後ｋ縲
+ Trace.TraceInformation( "BASS 繧貞晄悄蛹悶＠縺ｾ縺励◆縲(WASAPI蜈ｱ譛峨Δ繝ｼ繝, {0}ms, 譖ｴ譁ｰ髢馴囈{1}ms)", n蟶梧悍繝舌ャ繝輔ぃ繧ｵ繧､繧ｺms, devInfo.defperiod * 1000.0f );
+ this.bIsBASSFree = false;
+ //-----------------
+ #endregion
+ }
+ }
+ #region [ #31737 WASAPI謗剃ｻ悶Δ繝ｼ繝峨ｮ縺ｿ蛻ｩ逕ｨ蜿ｯ閭ｽ縺ｨ縺励仝ASAPI蜈ｱ譛峨Δ繝ｼ繝峨ｯ菴ｿ逕ｨ縺ｧ縺阪↑縺繧医≧縺ｫ縺吶ｋ縺溘ａ縺ｫ縲仝ASAPI蜈ｱ譛峨Δ繝ｼ繝峨〒縺ｮ蛻晄悄蛹悶ヵ繝ｭ繝ｼ繧貞炎髯､縺吶ｋ縲 ]
+ //else if ( mode == E繝繝舌う繧ｹ繝｢繝ｼ繝.謗剃ｻ )
+ //{
+ // Trace.TraceInformation("Failed to initialize setting BASS (WASAPI) mode [{0}]", Bass.BASS_ErrorGetCode().ToString() );
+ // #region [ 謗剃ｻ悶Δ繝ｼ繝峨↓螟ｱ謨励＠縺溘ｮ縺ｪ繧牙ｱ譛峨Δ繝ｼ繝峨〒繝ｪ繝医Λ繧､縲]
+ // //-----------------
+ // mode = E繝繝舌う繧ｹ繝｢繝ｼ繝.蜈ｱ譛;
+ // goto Retry;
+ // //-----------------
+ // #endregion
+ //}
+ #endregion
+ else
+ {
+ #region [ 縺昴ｌ縺ｧ繧ょ､ｱ謨励＠縺溘ｉ萓句､也匱逕溘]
+ //-----------------
+ BASSError errcode = Bass.BASS_ErrorGetCode();
+ Bass.BASS_Free();
+ this.bIsBASSFree = true;
+ throw new Exception( string.Format( "BASS (WASAPI) 縺ｮ蛻晄悄蛹悶↓螟ｱ謨励＠縺ｾ縺励◆縲(BASS_WASAPI_Init)[{0}]", errcode ) );
+ //-----------------
+ #endregion
+ }
+
+
+ // WASAPI蜃ｺ蜉帙→蜷後§繝輔か繝ｼ繝槭ャ繝医ｒ謖√▽ BASS 繝溘く繧ｵ繝ｼ繧剃ｽ懈舌
+
+ var info = BassWasapi.BASS_WASAPI_GetInfo();
+ this.hMixer = BassMix.BASS_Mixer_StreamCreate(
+ info.freq,
+ info.chans,
+ BASSFlag.BASS_MIXER_NONSTOP | BASSFlag.BASS_SAMPLE_FLOAT | BASSFlag.BASS_STREAM_DECODE ); // 繝繧ｳ繝ｼ繝峨ｮ縺ｿｼ晉匱螢ｰ縺励↑縺縲８ASAPI縺ｫ蜃ｺ蜉帙＆繧後ｋ縺縺代
+ if ( this.hMixer == 0 )
+ {
+ BASSError errcode = Bass.BASS_ErrorGetCode();
+ BassWasapi.BASS_WASAPI_Free();
+ Bass.BASS_Free();
+ this.bIsBASSFree = true;
+ throw new Exception( string.Format( "BASS繝溘く繧ｵ(mixing)縺ｮ菴懈舌↓螟ｱ謨励＠縺ｾ縺励◆縲[{0}]", errcode ) );
+ }
+
+
+ // BASS 繝溘く繧ｵ繝ｼ縺ｮ1遘偵≠縺溘ｊ縺ｮ繝舌う繝域焚繧堤ｮ怜ｺ縲
+
+ var mixerInfo = Bass.BASS_ChannelGetInfo( this.hMixer );
+ long n繝溘く繧ｵ繝ｼ縺ｮ1繧ｵ繝ｳ繝励Ν縺ゅ◆繧翫ｮ繝舌う繝域焚 = mixerInfo.chans * 4; // 4 = sizeof(FLOAT)
+ this.n繝溘く繧ｵ繝ｼ縺ｮ1遘偵≠縺溘ｊ縺ｮ繝舌う繝域焚 = n繝溘く繧ｵ繝ｼ縺ｮ1繧ｵ繝ｳ繝励Ν縺ゅ◆繧翫ｮ繝舌う繝域焚 * mixerInfo.freq;
+
+
+
+ // 蜊倡ｴ斐↓縲”Mixer縺ｮ髻ｳ驥上ｒMasterVolume縺ｨ縺励※蛻ｶ蠕｡縺励※繧ゅ
+ // ChannelGetData()縺ｮ蜀螳ｹ縺ｫ縺ｯ蜿肴丐縺輔ｌ縺ｪ縺縲
+ // 縺昴ｮ縺溘ａ縲√ｂ縺荳谿ｵmixer繧貞剱縺ｾ縺帙※縲∽ｸ谿ｵ蜈医ｮmixer縺九ｉChannelGetData()縺吶ｋ縺薙→縺ｧ縲
+ // hMixer縺ｮ髻ｳ驥丞宛蠕｡繧貞渚譏縺輔○繧九
+ this.hMixer_DeviceOut = BassMix.BASS_Mixer_StreamCreate(
+ info.freq,
+ info.chans,
+ BASSFlag.BASS_MIXER_NONSTOP | BASSFlag.BASS_SAMPLE_FLOAT | BASSFlag.BASS_STREAM_DECODE ); // 繝繧ｳ繝ｼ繝峨ｮ縺ｿｼ晉匱螢ｰ縺励↑縺縲８ASAPI縺ｫ蜃ｺ蜉帙＆繧後ｋ縺縺代
+ if ( this.hMixer_DeviceOut == 0 )
+ {
+ BASSError errcode = Bass.BASS_ErrorGetCode();
+ BassWasapi.BASS_WASAPI_Free();
+ Bass.BASS_Free();
+ this.bIsBASSFree = true;
+ throw new Exception( string.Format( "BASS繝溘く繧ｵ(譛邨よｮｵ)縺ｮ菴懈舌↓螟ｱ謨励＠縺ｾ縺励◆縲[{0}]", errcode ) );
+ }
+
+ {
+ bool b1 = BassMix.BASS_Mixer_StreamAddChannel( this.hMixer_DeviceOut, this.hMixer, BASSFlag.BASS_DEFAULT );
+ if ( !b1 )
+ {
+ BASSError errcode = Bass.BASS_ErrorGetCode();
+ BassWasapi.BASS_WASAPI_Free();
+ Bass.BASS_Free();
+ this.bIsBASSFree = true;
+ throw new Exception( string.Format( "BASS繝溘く繧ｵ(譛邨よｮｵ縺ｨmixing)縺ｮ謗･邯壹↓螟ｱ謨励＠縺ｾ縺励◆縲[{0}]", errcode ) );
+ };
+ }
+
+
+ // 蜃ｺ蜉帙ｒ髢句ｧ九
+
+ BassWasapi.BASS_WASAPI_Start();
+ }
+ #region [ t繧ｵ繧ｦ繝ｳ繝峨ｒ菴懈舌☆繧() ]
+ public CSound t繧ｵ繧ｦ繝ｳ繝峨ｒ菴懈舌☆繧( string str繝輔ぃ繧､繝ｫ蜷, ESoundGroup soundGroup )
+ {
+ var sound = new CSound(soundGroup);
+ sound.tWASAPI繧ｵ繧ｦ繝ｳ繝峨ｒ菴懈舌☆繧( str繝輔ぃ繧､繝ｫ蜷, this.hMixer, this.e蜃ｺ蜉帙ョ繝舌う繧ｹ );
+ return sound;
+ }
+
+ public void t繧ｵ繧ｦ繝ｳ繝峨ｒ菴懈舌☆繧( string str繝輔ぃ繧､繝ｫ蜷, CSound sound )
+ {
+ sound.tWASAPI繧ｵ繧ｦ繝ｳ繝峨ｒ菴懈舌☆繧( str繝輔ぃ繧､繝ｫ蜷, this.hMixer, this.e蜃ｺ蜉帙ョ繝舌う繧ｹ );
+ }
+ public void t繧ｵ繧ｦ繝ｳ繝峨ｒ菴懈舌☆繧( byte[] byArrWAV繝輔ぃ繧､繝ｫ繧､繝｡繝ｼ繧ｸ, CSound sound )
+ {
+ sound.tWASAPI繧ｵ繧ｦ繝ｳ繝峨ｒ菴懈舌☆繧( byArrWAV繝輔ぃ繧､繝ｫ繧､繝｡繝ｼ繧ｸ, this.hMixer, this.e蜃ｺ蜉帙ョ繝舌う繧ｹ );
+ }
+ #endregion
+
+ #region [ Dispose-Finallize繝代ち繝ｼ繝ｳ螳溯｣ ]
+ //-----------------
+ public void Dispose()
+ {
+ this.Dispose( true );
+ GC.SuppressFinalize( this );
+ }
+ protected void Dispose( bool bManagedDispose )
+ {
+ this.e蜃ｺ蜉帙ョ繝舌う繧ｹ = ESoundDeviceType.Unknown; // 縺ｾ縺壼ｺ蜉帛●豁｢縺吶ｋ(Dispose荳ｭ縺ｫ繧ｯ繝ｩ繧ｹ蜀縺ｫ繧｢繧ｯ繧ｻ繧ｹ縺輔ｌ繧九％縺ｨ繧帝亟縺)
+ if ( hMixer != -1 )
+ {
+ Bass.BASS_StreamFree( this.hMixer );
+ }
+ if ( !this.bIsBASSFree )
+ {
+ BassWasapi.BASS_WASAPI_Free(); // 繧ｷ繧ｹ繝繝繧ｿ繧､繝槭ｈ繧雁医↓蜻ｼ縺ｳ蜃ｺ縺吶％縺ｨ縲ゑｼtWasapi蜃ｦ逅() 縺ｮ荳ｭ縺ｧ繧ｷ繧ｹ繝繝繧ｿ繧､繝槭ｒ蜿らｧ縺励※繧九◆繧ｼ
+ Bass.BASS_Free();
+ }
+ if( bManagedDispose )
+ {
+ C蜈ｱ騾.tDispose縺吶ｋ( this.tm繧ｷ繧ｹ繝繝繧ｿ繧､繝 );
+ this.tm繧ｷ繧ｹ繝繝繧ｿ繧､繝 = null;
+ }
+ }
+ ~CSoundDeviceWASAPI()
+ {
+ this.Dispose( false );
+ }
+ //-----------------
+ #endregion
+
+ protected int hMixer = -1;
+ protected int hMixer_DeviceOut = -1;
+ protected WASAPIPROC tWasapiProc = null;
+
+ protected int tWASAPI蜃ｦ逅( IntPtr buffer, int length, IntPtr user )
+ {
+ // BASS繝溘く繧ｵ縺九ｉ縺ｮ蜃ｺ蜉帙ョ繝ｼ繧ｿ繧偵◎縺ｮ縺ｾ縺ｾ WASAPI buffer 縺ｸ荳ｸ謚輔£縲
+
+ int num = Bass.BASS_ChannelGetData( this.hMixer_DeviceOut, buffer, length ); // num = 螳滄圀縺ｫ霆｢騾√＠縺滄聞縺
+ if ( num == -1 ) num = 0;
+
+
+ // 邨碁℃譎る俣繧呈峩譁ｰ縲
+ // 繝繝ｼ繧ｿ縺ｮ霆｢騾∝ｷｮ蛻縺ｧ縺ｯ縺ｪ縺冗ｴｯ遨崎ｻ｢騾√ヰ繧､繝域焚縺九ｉ邂怜ｺ縺吶ｋ縲
+
+ int n譛ｪ蜀咲函繝舌う繝域焚 = BassWasapi.BASS_WASAPI_GetData( null, (int) BASSData.BASS_DATA_AVAILABLE ); // 隱､蟾ｮ蜑頑ｸ帙ｮ縺溘ａ縲∝ｿ隕√→縺ｪ繧九ぐ繝ｪ繧ｮ繝ｪ逶ｴ蜑阪↓蜿門ｾ励☆繧九
+ this.n邨碁℃譎る俣ms = ( this.n邏ｯ遨崎ｻ｢騾√ヰ繧､繝域焚 - n譛ｪ蜀咲函繝舌う繝域焚 ) * 1000 / this.n繝溘く繧ｵ繝ｼ縺ｮ1遘偵≠縺溘ｊ縺ｮ繝舌う繝域焚;
+ this.n邨碁℃譎る俣繧呈峩譁ｰ縺励◆繧ｷ繧ｹ繝繝譎ょ綾ms = this.tm繧ｷ繧ｹ繝繝繧ｿ繧､繝.n繧ｷ繧ｹ繝繝譎ょ綾ms;
+
+ // 螳溷ｺ蜉幃≦蟒ｶ繧呈峩譁ｰ縲
+ // 譛ｪ蜀咲函繝舌う繝域焚縺ｮ蟷ｳ蝮蛟､縲
+
+ long n莉雁屓縺ｮ驕蟒ｶms = n譛ｪ蜀咲函繝舌う繝域焚 * 1000 / this.n繝溘く繧ｵ繝ｼ縺ｮ1遘偵≠縺溘ｊ縺ｮ繝舌う繝域焚;
+ this.n螳溷ｺ蜉幃≦蟒ｶms = ( this.b譛蛻昴ｮ螳溷ｺ蜉幃≦蟒ｶ邂怜ｺ ) ? n莉雁屓縺ｮ驕蟒ｶms : ( this.n螳溷ｺ蜉幃≦蟒ｶms + n莉雁屓縺ｮ驕蟒ｶms ) / 2;
+ this.b譛蛻昴ｮ螳溷ｺ蜉幃≦蟒ｶ邂怜ｺ = false;
+
+
+ // 邨碁℃譎る俣繧呈峩譁ｰ蠕後↓縲∽ｻ雁屓蛻縺ｮ邏ｯ遨崎ｻ｢騾√ヰ繧､繝域焚繧貞渚譏縲
+
+ this.n邏ｯ遨崎ｻ｢騾√ヰ繧､繝域焚 += num;
+ return num;
+ }
+
+ private long n繝溘く繧ｵ繝ｼ縺ｮ1遘偵≠縺溘ｊ縺ｮ繝舌う繝域焚 = 0;
+ private long n邏ｯ遨崎ｻ｢騾√ヰ繧､繝域焚 = 0;
+ private bool b譛蛻昴ｮ螳溷ｺ蜉幃≦蟒ｶ邂怜ｺ = true;
+ private bool bIsBASSFree = true;
+ }
+}
diff --git a/FDK19/繧ｳ繝ｼ繝/03.繧ｵ繧ｦ繝ｳ繝/CSoundTimer.cs b/FDK19/繧ｳ繝ｼ繝/03.繧ｵ繧ｦ繝ｳ繝/CSoundTimer.cs
new file mode 100644
index 00000000..86060758
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/03.繧ｵ繧ｦ繝ｳ繝/CSoundTimer.cs
@@ -0,0 +1,214 @@
+ｻｿusing System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading;
+using System.Runtime.InteropServices;
+using System.Diagnostics;
+
+namespace FDK
+{
+ public class CSoundTimer : CTimerBase
+ {
+ public override long n繧ｷ繧ｹ繝繝譎ょ綾ms
+ {
+ get
+ {
+ if( this.Device.e蜃ｺ蜉帙ョ繝舌う繧ｹ == ESoundDeviceType.ExclusiveWASAPI ||
+ this.Device.e蜃ｺ蜉帙ョ繝舌う繧ｹ == ESoundDeviceType.SharedWASAPI ||
+ this.Device.e蜃ｺ蜉帙ョ繝舌う繧ｹ == ESoundDeviceType.ASIO )
+ {
+ // BASS 邉ｻ縺ｮ ISoundDevice.n邨碁℃譎る俣ms 縺ｯ繧ｪ繝ｼ繝繧｣繧ｪ繝舌ャ繝輔ぃ縺ｮ譖ｴ譁ｰ髢馴囈縺壹▽縺ｧ縺励°譖ｴ譁ｰ縺輔ｌ縺ｪ縺縺溘ａ縲∝腰縺ｫ縺薙ｌ繧定ｿ斐☆縺縺代〒縺ｯ縺ｨ縺ｳ縺ｨ縺ｳ縺ｮ蛟､縺ｫ縺ｪ繧九
+ // 縺昴％縺ｧ縲∵峩譁ｰ髢馴囈縺ｮ譛荳ｭ縺ｫ蜻ｼ縺ｰ繧後◆蝣ｴ蜷医ｯ縲√す繧ｹ繝繝繧ｿ繧､繝槭ｒ菴ｿ縺｣縺ｦ陬憺俣縺吶ｋ縲
+ // 縺薙ｮ蝣ｴ蜷医ｮ邨碁℃譎る俣縺ｨ縺ｮ隱､蟾ｮ縺ｯ譖ｴ譁ｰ髢馴囈莉･蜀縺ｫ蜿弱∪繧九ｮ縺ｧ蝠城｡後↑縺縺ｨ蛻､譁ｭ縺吶ｋ縲
+ // 縺溘□縺励、SIO縺ｮ蝣ｴ蜷医ｯ縲∬ｻ｢騾｜yte謨ｰ縺九ｉ譎る俣邂怜ｺ縺励※縺繧九◆繧√、SIO縺ｮ髻ｳ螢ｰ蜷域仙ｦ逅縺ｮ雋闕ｷ縺悟､ｧ縺阪☆縺弱ｋ蝣ｴ蜷(蜃ｦ逅譎る俣縺悟ｮ滓凾髢薙ｒ雜縺医※縺繧句ｴ蜷)縺ｯ
+ // 蜍穂ｽ懊′縺翫°縺励￥縺ｪ繧九(蜈ｷ菴鍋噪縺ｫ縺ｯ縲√％縺薙〒霑斐☆繧ｿ繧､繝槭ｼ蛟､縺ｮ騾陦後′逋ｺ逕溘＠縲√せ繧ｯ繝ｭ繝ｼ繝ｫ縺悟ｷｻ縺肴綾繧)
+ // 縺薙ｮ蝣ｴ蜷医ｮ蟇ｾ遲悶ｯ縲、SIO縺ｮ繝舌ャ繝輔ぃ驥上ｒ蠅励ｄ縺励※縲、SIO縺ｮ髻ｳ螢ｰ蜷域仙ｦ逅縺ｮ雋闕ｷ繧剃ｸ九£繧九％縺ｨ縲
+
+ if ( this.Device.n邨碁℃譎る俣繧呈峩譁ｰ縺励◆繧ｷ繧ｹ繝繝譎ょ綾ms == CTimer.n譛ｪ菴ｿ逕ｨ ) // #33890 2014.5.27 yyagi
+ {
+ // 迺ｰ蠅縺ｫ繧医▲縺ｦ縺ｯ縲、SIO繝吶ｼ繧ｹ縺ｮ貍泌･上ち繧､繝槭ｼ縺悟虚菴懊☆繧句燕(縺､縺ｾ繧晦SIO縺ｮ繧ｵ繧ｦ繝ｳ繝芽ｻ｢騾√′蟋九∪繧句燕)縺ｫ
+ // DTX繝繝ｼ繧ｿ縺ｮ貍泌･上′蟋九∪繧句ｴ蜷医′縺ゅｋ縲
+ // 縺昴ｮ蝣ｴ蜷医"this.Device.n邨碁℃譎る俣繧呈峩譁ｰ縺励◆繧ｷ繧ｹ繝繝譎ょ綾" 縺梧ｭ｣縺励＞蛟､縺ｧ縺ｪ縺縺溘ａ縲
+ // 貍泌･上ち繧､繝槭ｮ蛟､縺梧ｭ｣縺励＞繧ゅｮ縺ｨ縺ｯ縺ｪ繧峨↑縺縲ゅ◎縺励※縲∵ｼ泌･上ち繧､繝槭ｼ縺ｮ蜍穂ｽ懊′蟋九∪繧九→蜷梧凾縺ｫ縲
+ // 貍泌･上ち繧､繝槭ｮ蛟､縺後☆縺｣鬟帙ｶ(讌ｵ遶ｯ縺ｪ雋縺ｮ蛟､縺ｫ縺ｪ繧)縺溘ａ縲∵ｼ泌･上ｮ縺ｿ縺ｪ繧峨★逕ｻ髱｢陦ｨ遉ｺ繧ゅ＆繧後↑縺迥ｶ諷九→縺ｪ繧九
+ // (逕ｻ髱｢陦ｨ遉ｺ縺ｯ繧ｿ繧､繝槭ｮ蛟､縺ｫ騾｣蜍輔＠縺ｦ陦後ｏ繧後ｋ縺後0莉･荳翫ｮ繧ｿ繧､繝槫､縺ｫ蜷医ｏ縺帙※蜍穂ｽ懊☆繧九◆繧√
+ // 荳阪ｮ蛟､縺梧擂繧九→逕ｻ髱｢縺ｫ菴輔ｂ陦ｨ遉ｺ縺輔ｌ縺ｪ縺上↑繧)
+
+ // 縺昴％縺ｧ縲∵ｼ泌･上ち繧､繝槭′蜍穂ｽ懊ｒ蟋九ａ繧句燕(this.Device.n邨碁℃譎る俣繧呈峩譁ｰ縺励◆繧ｷ繧ｹ繝繝譎ょ綾ms == CTimer.n譛ｪ菴ｿ逕ｨ)縺ｯ縲
+ // 陬懈ｭ｣驛ｨ蛻繧偵ぞ繝ｭ縺ｫ縺励※縲］邨碁℃譎る俣ms縺縺代ｒ霑斐☆繧医≧縺ｫ縺吶ｋ縲
+ // 縺薙≧縺吶ｋ縺薙→縺ｧ縲∵ｼ泌･上ち繧､繝槭′蜍穂ｽ懊ｒ蟋九ａ縺ｦ繧ゅ∫ｴ邯ｻ縺励↑縺上↑繧九
+ return this.Device.n邨碁℃譎る俣ms;
+ }
+ else
+ {
+ if ( FDK.CSound邂｡逅.bUseOSTimer )
+ //if ( true )
+ {
+ return ctDInputTimer.n繧ｷ繧ｹ繝繝譎ょ綾ms; // 莉ｮ縺ｫCSoundTimer繧辰Timer逶ｸ蠖薙ｮ蜍穂ｽ懊↓縺励※縺ｿ縺
+ }
+ else
+ {
+ return this.Device.n邨碁℃譎る俣ms
+ + ( this.Device.tm繧ｷ繧ｹ繝繝繧ｿ繧､繝.n繧ｷ繧ｹ繝繝譎ょ綾ms - this.Device.n邨碁℃譎る俣繧呈峩譁ｰ縺励◆繧ｷ繧ｹ繝繝譎ょ綾ms );
+ }
+ }
+ }
+ else if( this.Device.e蜃ｺ蜉帙ョ繝舌う繧ｹ == ESoundDeviceType.DirectSound )
+ {
+ //return this.Device.n邨碁℃譎る俣ms; // #24820 2013.2.3 yyagi TESTCODE DirectSound縺ｧ繧ｹ繧ｯ繝ｭ繝ｼ繝ｫ縺梧ｻ代ｉ縺九↓縺ｪ繧峨↑縺縺溘ａ縲
+ return ct.n繧ｷ繧ｹ繝繝譎ょ綾ms; // 莉ｮ縺ｫCSoundTimer繧辰Timer逶ｸ蠖薙ｮ蜍穂ｽ懊↓縺励※縺ｿ縺
+ }
+ return CTimerBase.n譛ｪ菴ｿ逕ｨ;
+ }
+ }
+
+ internal CSoundTimer( ISoundDevice device )
+ {
+ this.Device = device;
+
+ if ( this.Device.e蜃ｺ蜉帙ョ繝舌う繧ｹ != ESoundDeviceType.DirectSound )
+ {
+ TimerCallback timerDelegate = new TimerCallback( SnapTimers ); // CSoundTimer繧偵す繧ｹ繝繝譎ょ綾縺ｫ螟画鋤縺吶ｋ縺溘ａ縺ｫ縲
+ timer = new Timer( timerDelegate, null, 0, 1000 ); // CSoundTimer縺ｨCTimer繧剃ｸ｡譁ｹ縺ｨ繧りｵｰ繧峨○縺ｦ縺翫″縲
+ ctDInputTimer = new CTimer( CTimer.E遞ｮ蛻･.MultiMedia ); // 1遘偵↓1蝗樊凾蟾ｮ繧呈ｸｬ螳壹☆繧九ｈ縺縺ｫ縺励※縺翫￥
+ }
+ else // TESTCODE DirectSound譎ゅｮ縺ｿ縲，SoundTimer縺ｧ縺ｪ縺修Timer繧剃ｽｿ縺
+ {
+ ct = new CTimer( CTimer.E遞ｮ蛻･.MultiMedia );
+ }
+ }
+
+ private void SnapTimers(object o) // 1遘偵↓1蝗槫他縺ｳ蜃ｺ縺輔ｌ縲2縺､縺ｮ繧ｿ繧､繝槭ｼ髢薙ｮ迴ｾ蝨ｨ蛟､繧偵◎繧後◇繧御ｿ晄戟縺吶ｋ縲
+ {
+ if ( this.Device.e蜃ｺ蜉帙ョ繝舌う繧ｹ != ESoundDeviceType.DirectSound )
+ {
+ try
+ {
+ this.nDInputTimerCounter = this.ctDInputTimer.n繧ｷ繧ｹ繝繝譎ょ綾ms;
+ this.nSoundTimerCounter = this.n繧ｷ繧ｹ繝繝譎ょ綾ms;
+ //Debug.WriteLine( "BaseCounter: " + nDInputTimerCounter + ", " + nSoundTimerCounter );
+ }
+ catch ( Exception e )
+ // 繧ｵ繧ｦ繝ｳ繝芽ｨｭ螳壼､画峩譎ゅ↓縲》imer.Dispose()縺励◆蠕後》imer縺悟ｮ滄圀縺ｫ蛛懈ｭ｢縺吶ｋ蜑阪↓縺薙％縺ｫ譚･縺ｦ縺励∪縺蝣ｴ蜷医′縺ゅｊ
+ // 縺昴ｮ髫帙↓NullReferenceException縺檎匱逕溘☆繧
+ // timer縺悟ｮ滄圀縺ｫ蛛懈ｭ｢縺励◆縺薙→繧呈､懷ｺ縺励※縺九ｉ谺｡縺ｮ險ｭ螳壹ｒ縺吶∋縺阪□縺後∝ｮ溯｣縺碁屮縺励＞縺溘ａ縲
+ // 縺薙％縺ｧ蜊倥↓萓句､也ｴ譽縺吶ｋ縺薙→縺ｧ莉｣譖ｿ縺吶ｋ
+ {
+ Trace.TraceInformation( e.ToString() );
+ Trace.TraceInformation("FDK: CSoundTimer.SnapTimers(): 萓句､也匱逕溘＠縺ｾ縺励◆縺後∫ｶ咏ｶ壹＠縺ｾ縺吶" );
+ }
+ }
+ }
+ public long n繧ｵ繧ｦ繝ｳ繝峨ち繧､繝槭ｼ縺ｮ繧ｷ繧ｹ繝繝譎ょ綾ms縺ｸ縺ｮ螟画鋤( long nDInput縺ｮ繧ｿ繧､繝繧ｹ繧ｿ繝ｳ繝 )
+ {
+ return nDInput縺ｮ繧ｿ繧､繝繧ｹ繧ｿ繝ｳ繝 - this.nDInputTimerCounter + this.nSoundTimerCounter; // Timer驕輔＞縺ｫ繧医ｋ譎ょｷｮ繧定｣懈ｭ｣縺吶ｋ
+ }
+
+#if false
+ // 繧ｭ繝ｼ繝懊ｼ繝峨う繝吶Φ繝(keybd_event縺ｮ蠑墓焚縺ｨ蜷梧ｧ倥ｮ繝繝ｼ繧ｿ)
+ [StructLayout( LayoutKind.Sequential )]
+ private struct KEYBDINPUT
+ {
+ public ushort wVk;
+ public ushort wScan;
+ public uint dwFlags;
+ public uint time;
+ public IntPtr dwExtraInfo;
+ };
+ // 蜷遞ｮ繧､繝吶Φ繝(SendInput縺ｮ蠑墓焚繝繝ｼ繧ｿ)
+ [StructLayout( LayoutKind.Sequential )]
+ private struct INPUT
+ {
+ public int type;
+ public KEYBDINPUT ki;
+ };
+ // 繧ｭ繝ｼ謫堺ｽ懊√槭え繧ｹ謫堺ｽ懊ｒ繧ｷ繝溘Η繝ｬ繝ｼ繝(謫ｬ莨ｼ逧縺ｫ謫堺ｽ懊☆繧)
+ [DllImport( "user32.dll" )]
+ private extern static void SendInput(
+ int nInputs, ref INPUT pInputs, int cbsize );
+
+ // 莉ｮ諠ｳ繧ｭ繝ｼ繧ｳ繝ｼ繝峨ｒ繧ｹ繧ｭ繝｣繝ｳ繧ｳ繝ｼ繝峨↓螟画鋤
+ [DllImport( "user32.dll", EntryPoint = "MapVirtualKeyA" )]
+ private extern static int MapVirtualKey(
+ int wCode, int wMapType );
+
+ [DllImport( "user32.dll" )]
+ static extern IntPtr GetMessageExtraInfo();
+
+ private const int INPUT_MOUSE = 0; // 繝槭え繧ｹ繧､繝吶Φ繝
+ private const int INPUT_KEYBOARD = 1; // 繧ｭ繝ｼ繝懊ｼ繝峨う繝吶Φ繝
+ private const int INPUT_HARDWARE = 2; // 繝上ｼ繝峨え繧ｧ繧｢繧､繝吶Φ繝
+ private const int KEYEVENTF_KEYDOWN = 0x0; // 繧ｭ繝ｼ繧呈款縺
+ private const int KEYEVENTF_KEYUP = 0x2; // 繧ｭ繝ｼ繧帝屬縺
+ private const int KEYEVENTF_EXTENDEDKEY = 0x1; // 諡｡蠑ｵ繧ｳ繝ｼ繝
+ private const int KEYEVENTF_SCANCODE = 0x8;
+ private const int KEYEVENTF_UNIOCODE = 0x4;
+ private const int VK_SHIFT = 0x10; // SHIFT繧ｭ繝ｼ
+
+ private void pollingSendInput()
+ {
+// INPUT[] inp = new INPUT[ 2 ];
+ INPUT inp = new INPUT();
+ while ( true )
+ {
+ // (2)繧ｭ繝ｼ繝懊ｼ繝(A)繧呈款縺
+ //inp[0].type = INPUT_KEYBOARD;
+ //inp[ 0 ].ki.wVk = ( ushort ) Key.B;
+ //inp[ 0 ].ki.wScan = ( ushort ) MapVirtualKey( inp[ 0 ].ki.wVk, 0 );
+ //inp[ 0 ].ki.dwFlags = KEYEVENTF_KEYDOWN;
+ //inp[ 0 ].ki.dwExtraInfo = IntPtr.Zero;
+ //inp[ 0 ].ki.time = 0;
+ inp.type = INPUT_KEYBOARD;
+ inp.ki.wVk = ( ushort ) Key.B;
+ inp.ki.wScan = ( ushort ) MapVirtualKey( inp.ki.wVk, 0 );
+ inp.ki.dwFlags = KEYEVENTF_SCANCODE | KEYEVENTF_KEYDOWN;
+ inp.ki.dwExtraInfo = GetMessageExtraInfo();
+ inp.ki.time = 0;
+
+ //// (3)繧ｭ繝ｼ繝懊ｼ繝(A)繧帝屬縺
+ //inp[ 1 ].type = INPUT_KEYBOARD;
+ //inp[ 1 ].ki.wVk = ( short ) Key.B;
+ //inp[ 1 ].ki.wScan = ( short ) MapVirtualKey( inp[ 1 ].ki.wVk, 0 );
+ //inp[ 1 ].ki.dwFlags = KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP;
+ //inp[ 1 ].ki.dwExtraInfo = 0;
+ //inp[ 1 ].ki.time = 0;
+
+ // 繧ｭ繝ｼ繝懊ｼ繝画桃菴懷ｮ溯｡
+ SendInput( 1, ref inp, Marshal.SizeOf( inp ) );
+Debug.WriteLine( "B" );
+ Thread.Sleep( 1000 );
+ }
+ }
+#endif
+ public override void Dispose()
+ {
+ // 迚ｹ縺ｫ縺ｪ縺暦ｼ ISoundDevice 縺ｮ隗｣謾ｾ縺ｯ蜻ｼ縺ｳ蜃ｺ縺怜縺ｧ陦後≧縺薙→縲
+
+ //sendinput繧ｹ繝ｬ繝繝牙炎髯､
+ if ( timer != null )
+ {
+ timer.Change( System.Threading.Timeout.Infinite, System.Threading.Timeout.Infinite );
+ // 縺薙％縺ｧ縲∝ｮ滄圀縺ｫtimer縺悟●豁｢縺励◆縺薙→繧堤｢ｺ隱阪☆繧九さ繝ｼ繝峨ｒ霑ｽ蜉縺吶∋縺阪□縺後√ｄ繧頑婿繧上°繧峨★縲
+ // 莉｣譖ｿ遲悶→縺励※縲ヾnapTimers()荳ｭ縺ｧ縲∽ｾ句､也匱逕溘ｒ遐ｴ譽縺励※縺繧九
+ timer.Dispose();
+ timer = null;
+ }
+ if ( ct != null )
+ {
+ ct.t荳譎ょ●豁｢();
+ ct.Dispose();
+ ct = null;
+ }
+ }
+
+ internal ISoundDevice Device = null; // debug縺ｮ縺溘ａ縲∽ｸ譎ら噪縺ｫprotected繧恥ublic縺ｫ縺吶ｋ縲ょｾ後〒蜈縺ｫ謌ｻ縺励※縺翫￥縺薙→縲
+ //protected Thread thSendInput = null;
+ //protected Thread thSnapTimers = null;
+ private CTimer ctDInputTimer = null;
+ private long nDInputTimerCounter = 0;
+ private long nSoundTimerCounter = 0;
+ Timer timer = null;
+
+ private CTimer ct = null; // TESTCODE
+ }
+}
diff --git a/FDK19/繧ｳ繝ｼ繝/03.繧ｵ繧ｦ繝ｳ繝/Cmp3.cs b/FDK19/繧ｳ繝ｼ繝/03.繧ｵ繧ｦ繝ｳ繝/Cmp3.cs
new file mode 100644
index 00000000..761122be
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/03.繧ｵ繧ｦ繝ｳ繝/Cmp3.cs
@@ -0,0 +1,62 @@
+ｻｿusing System;
+using System.Collections.Generic;
+using System.Text;
+using System.Runtime.InteropServices;
+using System.IO;
+using System.Diagnostics;
+using System.Threading;
+
+
+namespace FDK
+{
+ public unsafe class Cmp3 : SoundDecoder
+ {
+// static byte[] FOURCC = Encoding.ASCII.GetBytes( "SggO" ); // OggS 縺ｮ little endian
+
+
+ #region [ SoundDecoder.dll 繧､繝ｳ繝昴ｼ繝茨ｼmpr 髢｢騾｣ｼ云
+ //-----------------
+ [DllImport( "SoundDecoder.dll" )]
+ private static extern void mp3Close( int nHandle );
+ [DllImport( "SoundDecoder.dll" )]
+ private static extern int mp3Decode( int nHandle, IntPtr pDest, uint szDestSize, int bLoop );
+ [DllImport( "SoundDecoder.dll" )]
+ private static extern int mp3GetFormat( int nHandle, ref CWin32.WAVEFORMATEX wfx );
+ [DllImport( "SoundDecoder.dll" )]
+ private static extern uint mp3GetTotalPCMSize( int nHandle );
+ [DllImport( "SoundDecoder.dll" )]
+ private static extern int mp3Open( string fileName );
+ [DllImport( "SoundDecoder.dll" )]
+ private static extern int mp3Seek( int nHandle, uint dwPosition );
+ //-----------------
+ #endregion
+
+
+ public override int Open( string filename )
+ {
+ return mp3Open( filename );
+ }
+ public override int GetFormat( int nHandle, ref CWin32.WAVEFORMATEX wfx )
+ {
+ return mp3GetFormat( nHandle, ref wfx );
+ }
+ public override uint GetTotalPCMSize( int nHandle )
+ {
+ return mp3GetTotalPCMSize( nHandle );
+ }
+ public override int Seek( int nHandle, uint dwPosition )
+ {
+ return mp3Seek( nHandle, dwPosition );
+ }
+ public override int Decode( int nHandle, IntPtr pDest, uint szDestSize, int bLoop )
+ {
+ return mp3Decode( nHandle, pDest, szDestSize, bLoop );
+ }
+
+ public override void Close( int nHandle )
+ {
+ mp3Close( nHandle );
+ }
+
+ }
+}
diff --git a/FDK19/繧ｳ繝ｼ繝/03.繧ｵ繧ｦ繝ｳ繝/Cogg.cs b/FDK19/繧ｳ繝ｼ繝/03.繧ｵ繧ｦ繝ｳ繝/Cogg.cs
new file mode 100644
index 00000000..c99b9ebe
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/03.繧ｵ繧ｦ繝ｳ繝/Cogg.cs
@@ -0,0 +1,62 @@
+ｻｿusing System;
+using System.Collections.Generic;
+using System.Text;
+using System.Runtime.InteropServices;
+using System.IO;
+using System.Diagnostics;
+using System.Threading;
+
+
+namespace FDK
+{
+ public unsafe class Cogg : SoundDecoder
+ {
+ static byte[] FOURCC = Encoding.ASCII.GetBytes( "SggO" ); // OggS 縺ｮ little endian
+
+
+ #region [ SoundDecoder.dll 繧､繝ｳ繝昴ｼ繝茨ｼogg 髢｢騾｣ｼ云
+ //-----------------
+ [DllImport( "SoundDecoder.dll" )]
+ private static extern void oggClose( int nHandle );
+ [DllImport( "SoundDecoder.dll" )]
+ private static extern int oggDecode( int nHandle, IntPtr pDest, uint szDestSize, int bLoop );
+ [DllImport( "SoundDecoder.dll" )]
+ private static extern int oggGetFormat( int nHandle, ref CWin32.WAVEFORMATEX wfx );
+ [DllImport( "SoundDecoder.dll" )]
+ private static extern uint oggGetTotalPCMSize( int nHandle );
+ [DllImport( "SoundDecoder.dll" )]
+ private static extern int oggOpen( string fileName );
+ [DllImport( "SoundDecoder.dll" )]
+ private static extern int oggSeek( int nHandle, uint dwPosition );
+ //-----------------
+ #endregion
+
+
+ public override int Open( string filename )
+ {
+ return oggOpen( filename );
+ }
+ public override int GetFormat( int nHandle, ref CWin32.WAVEFORMATEX wfx )
+ {
+ return oggGetFormat( nHandle, ref wfx );
+ }
+ public override uint GetTotalPCMSize( int nHandle )
+ {
+ return oggGetTotalPCMSize( nHandle );
+ }
+ public override int Seek( int nHandle, uint dwPosition )
+ {
+ return oggSeek( nHandle, dwPosition );
+ }
+ public override int Decode( int nHandle, IntPtr pDest, uint szDestSize, int bLoop )
+ {
+ return oggDecode( nHandle, pDest, szDestSize, bLoop );
+ }
+
+ public override void Close( int nHandle )
+ {
+ oggClose( nHandle );
+ }
+
+ }
+}
diff --git a/FDK19/繧ｳ繝ｼ繝/03.繧ｵ繧ｦ繝ｳ繝/Cxa.cs b/FDK19/繧ｳ繝ｼ繝/03.繧ｵ繧ｦ繝ｳ繝/Cxa.cs
new file mode 100644
index 00000000..ee239fe0
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/03.繧ｵ繧ｦ繝ｳ繝/Cxa.cs
@@ -0,0 +1,380 @@
+ｻｿusing System;
+using System.Collections.Generic;
+using System.Text;
+using System.Runtime.InteropServices;
+using System.IO;
+using System.Diagnostics;
+using System.Threading;
+
+
+namespace FDK
+{
+ public unsafe class Cxa : SoundDecoder //, IDisposable
+ {
+ static byte[] FOURCC = Encoding.ASCII.GetBytes( "1DWK" ); // KWD1 縺ｮ little endian
+
+ #region [ XA逕ｨ讒矩菴薙ｮ螳｣險 ]
+ [StructLayout(LayoutKind.Sequential)]
+ public struct XASTREAMHEADER {
+ public byte* pSrc;
+ public uint nSrcLen;
+ public uint nSrcUsed;
+ public byte* pDst;
+ public uint nDstLen;
+ public uint nDstUsed;
+ }
+
+ [StructLayout( LayoutKind.Sequential )]
+ public struct XAHEADER
+ {
+ public uint id;
+ public uint nDataLen;
+ public uint nSamples;
+ public ushort nSamplesPerSec;
+ public byte nBits;
+ public byte nChannels;
+ public uint nLoopPtr;
+ [MarshalAs(UnmanagedType.ByValArray, SizeConst = 2)]
+ public short[] befL;
+ [MarshalAs(UnmanagedType.ByValArray, SizeConst = 2)]
+ public short[] befR;
+ [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
+ public byte[] pad;
+ }
+ #endregion
+
+ #region [ xadec.dll縺ｨ縺ｮ繝ｪ繝ｳ繧ｯ ]
+ [DllImport( "xadec.dll", EntryPoint = "xaDecodeOpen", CallingConvention = CallingConvention.Cdecl )]
+ public extern static IntPtr xaDecodeOpen( ref XAHEADER pxah, out FDK.CWin32.WAVEFORMATEX pwfx );
+ [DllImport( "xadec.dll", EntryPoint = "xaDecodeClose", CallingConvention = CallingConvention.Cdecl )]
+ public extern static bool xaDecodeClose( IntPtr hxas );
+ [DllImport( "xadec.dll", EntryPoint = "xaDecodeSize", CallingConvention = CallingConvention.Cdecl )]
+ public extern static bool xaDecodeSize( IntPtr hxas, uint slen, out uint pdlen );
+ [DllImport( "xadec.dll", EntryPoint = "xaDecodeConvert", CallingConvention = CallingConvention.Cdecl )]
+ public extern static bool xaDecodeConvert( IntPtr hxas, ref XASTREAMHEADER psh );
+ #endregion
+
+ public XAHEADER xaheader;
+ public XASTREAMHEADER xastreamheader;
+ public CWin32.WAVEFORMATEX waveformatex;
+
+ private string filename;
+ private byte[] srcBuf = null;
+ private int nHandle = -1;
+
+ public override int Open( string filename )
+ {
+ this.filename = filename;
+
+ #region [ XA繝倥ャ繝縺ｨ縲々A繝繝ｼ繧ｿ縺ｮ隱ｭ縺ｿ蜃ｺ縺 ]
+ xaheader = new XAHEADER();
+ using ( FileStream fs = new FileStream( filename, FileMode.Open, FileAccess.Read, FileShare.ReadWrite ) ) // FileShare 繧剃ｻ倥¢縺ｨ縺九↑縺縺ｨ縲，lose() 蠕後ｂ繝ｭ繝繧ｯ縺後°縺九ｋ??
+ {
+ using ( BinaryReader br = new BinaryReader( fs ) )
+ {
+ xaheader.id = br.ReadUInt32();
+ xaheader.nDataLen = br.ReadUInt32();
+ xaheader.nSamples = br.ReadUInt32();
+ xaheader.nSamplesPerSec = br.ReadUInt16();
+ xaheader.nBits = br.ReadByte();
+ xaheader.nChannels = br.ReadByte();
+ xaheader.nLoopPtr = br.ReadUInt32();
+
+ xaheader.befL = new short[ 2 ];
+ xaheader.befR = new short[ 2 ];
+ xaheader.pad = new byte[ 4 ];
+
+ xaheader.befL[ 0 ] = br.ReadInt16();
+ xaheader.befL[ 1 ] = br.ReadInt16();
+ xaheader.befR[ 0 ] = br.ReadInt16();
+ xaheader.befR[ 1 ] = br.ReadInt16();
+ xaheader.pad = br.ReadBytes( 4 );
+
+ srcBuf = new byte[ xaheader.nDataLen ];
+ srcBuf = br.ReadBytes( (int) xaheader.nDataLen );
+ }
+ }
+ //string xaid = Encoding.ASCII.GetString( xah.id );
+ #region [ 繝繝舌ャ繧ｰ陦ｨ遉ｺ ]
+ //Debug.WriteLine( "**XAHEADER**" );
+ //Debug.WriteLine( "id= " + xaheader.id.ToString( "X8" ) );
+ //Debug.WriteLine( "nDataLen= " + xaheader.nDataLen.ToString( "X8" ) );
+ //Debug.WriteLine( "nSamples= " + xaheader.nSamples.ToString( "X8" ) );
+ //Debug.WriteLine( "nSamplesPerSec= " + xaheader.nSamplesPerSec.ToString( "X4" ) );
+ //Debug.WriteLine( "nBits= " + xaheader.nBits.ToString( "X2" ) );
+ //Debug.WriteLine( "nChannels= " + xaheader.nChannels.ToString( "X2" ) );
+ //Debug.WriteLine( "nLoopPtr= " + xaheader.nLoopPtr.ToString( "X8" ) );
+ //Debug.WriteLine( "befL[0]= " + xaheader.befL[ 0 ].ToString( "X4" ) );
+ //Debug.WriteLine( "befL[1]= " + xaheader.befL[ 1 ].ToString( "X4" ) );
+ //Debug.WriteLine( "befR[0]= " + xaheader.befR[ 0 ].ToString( "X4" ) );
+ //Debug.WriteLine( "befR[1]= " + xaheader.befR[ 1 ].ToString( "X4" ) );
+ #endregion
+ #endregion
+
+ IntPtr hxas;
+
+ #region [ WAVEFORMEX諠蝣ｱ縺ｮ蜿門ｾ ]
+ waveformatex = new CWin32.WAVEFORMATEX();
+ hxas = xaDecodeOpen( ref xaheader, out waveformatex );
+ if ( hxas == null )
+ {
+ Trace.TraceError( "Error: xa: Open(): xaDecodeOpen(): " + Path.GetFileName( filename ) );
+ return -1;
+ }
+
+ #region [ 繝繝舌ャ繧ｰ陦ｨ遉ｺ ]
+ //Debug.WriteLine( "**WAVEFORMATEX**" );
+ //Debug.WriteLine( "wFormatTag= " + waveformatex.wFormatTag.ToString( "X4" ) );
+ //Debug.WriteLine( "nChannels = " + waveformatex.nChannels.ToString( "X4" ) );
+ //Debug.WriteLine( "nSamplesPerSec= " + waveformatex.nSamplesPerSec.ToString( "X8" ) );
+ //Debug.WriteLine( "nAvgBytesPerSec= " + waveformatex.nAvgBytesPerSec.ToString( "X8" ) );
+ //Debug.WriteLine( "nBlockAlign= " + waveformatex.nBlockAlign.ToString( "X4" ) );
+ //Debug.WriteLine( "wBitsPerSample= " + waveformatex.wBitsPerSample.ToString( "X4" ) );
+ //Debug.WriteLine( "cbSize= " + waveformatex.cbSize.ToString( "X4" ) );
+ #endregion
+ #endregion
+
+ this.nHandle = (int) hxas;
+ return (int) hxas;
+ }
+ public override int GetFormat( int nHandle, ref CWin32.WAVEFORMATEX wfx )
+ {
+ #region [ WAVEFORMATEX讒矩菴薙ｮ謇句虚繧ｳ繝斐ｼ ]
+ wfx.nAvgBytesPerSec = waveformatex.nAvgBytesPerSec;
+ wfx.wBitsPerSample = waveformatex.wBitsPerSample;
+ wfx.nBlockAlign = waveformatex.nBlockAlign;
+ wfx.nChannels = waveformatex.nChannels;
+ wfx.wFormatTag = waveformatex.wFormatTag;
+ wfx.nSamplesPerSec = waveformatex.nSamplesPerSec;
+
+ return 0;
+ #endregion
+ }
+ public override uint GetTotalPCMSize( int nHandle )
+ {
+ #region [ 繝繝ｼ繧ｿ髟ｷ縺ｮ蜿門ｾ ]
+ uint dlen;
+ xaDecodeSize( (IntPtr) nHandle, xaheader.nDataLen, out dlen );
+ #region [ 繝繝舌ャ繧ｰ陦ｨ遉ｺ ]
+ //Debug.WriteLine( "**INTERNAL VALUE**" );
+ //Debug.WriteLine( "dlen= " + dlen );
+ #endregion
+ #endregion
+
+ return dlen;
+ }
+ public override int Seek( int nHandle, uint dwPosition )
+ {
+ return 0;
+ }
+ public override int Decode( int nHandle, IntPtr pDest, uint szDestSize, int bLoop )
+ {
+ #region [ xa繝繝ｼ繧ｿ縺ｮ繝繧ｳ繝ｼ繝 ]
+ xastreamheader = new XASTREAMHEADER();
+ unsafe
+ {
+ fixed ( byte* pXaBuf = srcBuf )
+ {
+ byte* pWavBuf = (byte*) pDest;
+
+ xastreamheader.pSrc = pXaBuf;
+ xastreamheader.nSrcLen = xaheader.nDataLen;
+ xastreamheader.nSrcUsed = 0;
+ xastreamheader.pDst = pWavBuf;
+ xastreamheader.nDstLen = szDestSize;
+ xastreamheader.nDstUsed = 0;
+ if ( !xaDecodeConvert( (IntPtr) nHandle, ref xastreamheader ) )
+ {
+ Trace.TraceError( "Error: xaDecodeConvert(): " + Path.GetFileName( filename ) );
+ return -1;
+ }
+ }
+ }
+ #region [ 繝繝舌ャ繧ｰ陦ｨ遉ｺ ]
+ //Debug.WriteLine( "**XASTREAMHEADER**" );
+ //Debug.WriteLine( "nSrcLen= " + xastreamheader.nSrcLen );
+ //Debug.WriteLine( "nSrcUsed= " + xastreamheader.nSrcUsed );
+ //Debug.WriteLine( "nDstLen= " + xastreamheader.nDstLen );
+ //Debug.WriteLine( "nDstUsed= " + xastreamheader.nDstUsed );
+ #endregion
+ #endregion
+
+ return 0;
+ }
+ public override void Close( int nHandle )
+ {
+ #region [ xa繝輔ぃ繧､繝ｫ縺ｮ繧ｯ繝ｭ繝ｼ繧ｺ ]
+ if ( !xaDecodeClose( (IntPtr) nHandle ) )
+ {
+ Trace.TraceError( "Error: xaDecodeClose(): " + Path.GetFileName( filename ) );
+ }
+ srcBuf = null;
+ #endregion
+ }
+
+
+
+ //#region [ IDisposable 螳溯｣ ]
+ ////-----------------
+ //private bool bDispose螳御ｺ貂医∩ = false;
+ //public void Dispose()
+ //{
+ // if ( !this.bDispose螳御ｺ貂医∩ )
+ // {
+ // if ( srcBuf != null )
+ // {
+ // srcBuf = null;
+ // }
+ // if ( dstBuf != null )
+ // {
+ // dstBuf = null;
+ // }
+
+ // if ( this.nHandle >= 0 )
+ // {
+ // this.Close( this.nHandle );
+ // this.nHandle = -1;
+ // }
+ // this.bDispose螳御ｺ貂医∩ = true;
+ // }
+ //}
+ ////-----------------
+ //#endregion
+
+#if false
+ ///
+ /// xa繝輔ぃ繧､繝ｫ繧定ｪｭ縺ｿ霎ｼ繧薙〒縲『av縺ｫdecode縺吶ｋ
+ ///
+ /// xa繝輔ぃ繧､繝ｫ蜷
+ /// wav繝輔ぃ繧､繝ｫ縺梧ｼ邏阪＆繧後ｋ繝舌ャ繝輔ぃ
+ ///
+ public bool Decode( string filename, out byte[] wavBuf )
+ {
+ // Debug.WriteLine( "xa: Decode: " + Path.GetFileName( filename ) );
+
+ #region [ XA繝倥ャ繝縺ｨ縲々A繝繝ｼ繧ｿ縺ｮ隱ｭ縺ｿ蜃ｺ縺 ]
+ xaheader = new XAHEADER();
+ byte[] xaBuf;
+ using ( FileStream fs = new FileStream( filename, FileMode.Open, FileAccess.Read, FileShare.ReadWrite ) ) // FileShare 繧剃ｻ倥¢縺ｨ縺九↑縺縺ｨ縲，lose() 蠕後ｂ繝ｭ繝繧ｯ縺後°縺九ｋ??
+ {
+ using ( BinaryReader br = new BinaryReader( fs ) )
+ {
+ xaheader.id = br.ReadUInt32();
+ xaheader.nDataLen = br.ReadUInt32();
+ xaheader.nSamples = br.ReadUInt32();
+ xaheader.nSamplesPerSec = br.ReadUInt16();
+ xaheader.nBits = br.ReadByte();
+ xaheader.nChannels = br.ReadByte();
+ xaheader.nLoopPtr = br.ReadUInt32();
+
+ xaheader.befL = new short[ 2 ];
+ xaheader.befR = new short[ 2 ];
+ xaheader.pad = new byte[ 4 ];
+
+ xaheader.befL[ 0 ] = br.ReadInt16();
+ xaheader.befL[ 1 ] = br.ReadInt16();
+ xaheader.befR[ 0 ] = br.ReadInt16();
+ xaheader.befR[ 1 ] = br.ReadInt16();
+ xaheader.pad = br.ReadBytes( 4 );
+
+ xaBuf = new byte[ xaheader.nDataLen ];
+ xaBuf = br.ReadBytes( (int) xaheader.nDataLen );
+ }
+ }
+ //string xaid = Encoding.ASCII.GetString( xah.id );
+ #region [ 繝繝舌ャ繧ｰ陦ｨ遉ｺ ]
+ //Debug.WriteLine( "**XAHEADER**" );
+ //Debug.WriteLine( "id= " + xaheader.id.ToString( "X8" ) );
+ //Debug.WriteLine( "nDataLen= " + xaheader.nDataLen.ToString( "X8" ) );
+ //Debug.WriteLine( "nSamples= " + xaheader.nSamples.ToString( "X8" ) );
+ //Debug.WriteLine( "nSamplesPerSec= " + xaheader.nSamplesPerSec.ToString( "X4" ) );
+ //Debug.WriteLine( "nBits= " + xaheader.nBits.ToString( "X2" ) );
+ //Debug.WriteLine( "nChannels= " + xaheader.nChannels.ToString( "X2" ) );
+ //Debug.WriteLine( "nLoopPtr= " + xaheader.nLoopPtr.ToString( "X8" ) );
+ //Debug.WriteLine( "befL[0]= " + xaheader.befL[ 0 ].ToString( "X4" ) );
+ //Debug.WriteLine( "befL[1]= " + xaheader.befL[ 1 ].ToString( "X4" ) );
+ //Debug.WriteLine( "befR[0]= " + xaheader.befR[ 0 ].ToString( "X4" ) );
+ //Debug.WriteLine( "befR[1]= " + xaheader.befR[ 1 ].ToString( "X4" ) );
+ #endregion
+ #endregion
+
+ object lockobj = new object();
+ lock ( lockobj ) // 繧ｹ繝ｬ繝繝峨そ繝ｼ繝輔§繧縺ｪ縺縺九ｂ遏･繧後↑縺縺ｮ縺ｧ縲∝ｿｵ縺ｮ縺溘ａ
+ {
+ #region [ WAVEFORMEX諠蝣ｱ縺ｮ蜿門ｾ ]
+ waveformatex = new CWin32.WAVEFORMATEX();
+ IntPtr hxas = xaDecodeOpen( ref xaheader, out waveformatex );
+ if ( hxas == null )
+ {
+ Trace.TraceError( "Error: xaDecodeOpen(): " + Path.GetFileName( filename ) );
+ wavBuf = null;
+ return false;
+ }
+
+ #region [ 繝繝舌ャ繧ｰ陦ｨ遉ｺ ]
+ //Debug.WriteLine( "**WAVEFORMATEX**" );
+ //Debug.WriteLine( "wFormatTag= " + waveformatex.wFormatTag.ToString( "X4" ) );
+ //Debug.WriteLine( "nChannels = " + waveformatex.nChannels.ToString( "X4" ) );
+ //Debug.WriteLine( "nSamplesPerSec= " + waveformatex.nSamplesPerSec.ToString( "X8" ) );
+ //Debug.WriteLine( "nAvgBytesPerSec= " + waveformatex.nAvgBytesPerSec.ToString( "X8" ) );
+ //Debug.WriteLine( "nBlockAlign= " + waveformatex.nBlockAlign.ToString( "X4" ) );
+ //Debug.WriteLine( "wBitsPerSample= " + waveformatex.wBitsPerSample.ToString( "X4" ) );
+ //Debug.WriteLine( "cbSize= " + waveformatex.cbSize.ToString( "X4" ) );
+ #endregion
+ #endregion
+
+ #region [ 繝繝ｼ繧ｿ髟ｷ縺ｮ蜿門ｾ ]
+ uint dlen;
+ xaDecodeSize( hxas, xaheader.nDataLen, out dlen );
+ #region [ 繝繝舌ャ繧ｰ陦ｨ遉ｺ ]
+ //Debug.WriteLine( "**INTERNAL VALUE**" );
+ //Debug.WriteLine( "dlen= " + dlen );
+ #endregion
+ #endregion
+
+ #region [ xa繝繝ｼ繧ｿ縺ｮ繝繧ｳ繝ｼ繝 ]
+ wavBuf = new byte[ dlen ];
+ xastreamheader = new XASTREAMHEADER();
+
+ unsafe
+ {
+ fixed ( byte* pXaBuf = xaBuf, pWavBuf = wavBuf )
+ {
+ xastreamheader.pSrc = pXaBuf;
+ xastreamheader.nSrcLen = xaheader.nDataLen;
+ xastreamheader.nSrcUsed = 0;
+ xastreamheader.pDst = pWavBuf;
+ xastreamheader.nDstLen = dlen;
+ xastreamheader.nDstUsed = 0;
+ bool b = xaDecodeConvert( hxas, ref xastreamheader );
+ if ( !b )
+ {
+ Trace.TraceError( "Error: xaDecodeConvert(): " + Path.GetFileName( filename ) );
+ wavBuf = null;
+ return false;
+ }
+ }
+ }
+ #region [ 繝繝舌ャ繧ｰ陦ｨ遉ｺ ]
+ //Debug.WriteLine( "**XASTREAMHEADER**" );
+ //Debug.WriteLine( "nSrcLen= " + xastreamheader.nSrcLen );
+ //Debug.WriteLine( "nSrcUsed= " + xastreamheader.nSrcUsed );
+ //Debug.WriteLine( "nDstLen= " + xastreamheader.nDstLen );
+ //Debug.WriteLine( "nDstUsed= " + xastreamheader.nDstUsed );
+ #endregion
+ #endregion
+
+ #region [ xa繝輔ぃ繧､繝ｫ縺ｮ繧ｯ繝ｭ繝ｼ繧ｺ ]
+ bool bb = xaDecodeClose( hxas );
+ if ( !bb )
+ {
+ Trace.TraceError( "Error: xaDecodeClose(): " + Path.GetFileName( filename ) );
+ }
+ #endregion
+ }
+
+ return true;
+ }
+#endif
+ }
+}
diff --git a/FDK19/繧ｳ繝ｼ繝/03.繧ｵ繧ｦ繝ｳ繝/ESoundDeviceType.cs b/FDK19/繧ｳ繝ｼ繝/03.繧ｵ繧ｦ繝ｳ繝/ESoundDeviceType.cs
new file mode 100644
index 00000000..fe0edf0e
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/03.繧ｵ繧ｦ繝ｳ繝/ESoundDeviceType.cs
@@ -0,0 +1,15 @@
+ｻｿusing System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace FDK
+{
+ public enum ESoundDeviceType
+ {
+ ExclusiveWASAPI,
+ SharedWASAPI,
+ ASIO,
+ DirectSound,
+ Unknown,
+ }
+}
diff --git a/FDK19/繧ｳ繝ｼ繝/03.繧ｵ繧ｦ繝ｳ繝/ESoundGroup.cs b/FDK19/繧ｳ繝ｼ繝/03.繧ｵ繧ｦ繝ｳ繝/ESoundGroup.cs
new file mode 100644
index 00000000..23d91f8d
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/03.繧ｵ繧ｦ繝ｳ繝/ESoundGroup.cs
@@ -0,0 +1,11 @@
+ｻｿnamespace FDK
+{
+ public enum ESoundGroup
+ {
+ SoundEffect = 1,
+ Voice = 2,
+ SongPreview = 3,
+ SongPlayback = 4,
+ Unknown = 0
+ }
+}
diff --git a/FDK19/繧ｳ繝ｼ繝/03.繧ｵ繧ｦ繝ｳ繝/ISoundDevice.cs b/FDK19/繧ｳ繝ｼ繝/03.繧ｵ繧ｦ繝ｳ繝/ISoundDevice.cs
new file mode 100644
index 00000000..b362eb22
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/03.繧ｵ繧ｦ繝ｳ繝/ISoundDevice.cs
@@ -0,0 +1,26 @@
+ｻｿusing System;
+using System.Collections.Generic;
+using System.Text;
+using System.Diagnostics;
+using Un4seen.Bass;
+using Un4seen.BassAsio;
+using Un4seen.BassWasapi;
+using Un4seen.Bass.AddOn.Mix;
+
+namespace FDK
+{
+ internal interface ISoundDevice : IDisposable
+ {
+ ESoundDeviceType e蜃ｺ蜉帙ョ繝舌う繧ｹ { get; }
+ int nMasterVolume { get; set; }
+ long n螳溷ｺ蜉幃≦蟒ｶms { get; }
+ long n螳溘ヰ繝繝輔ぃ繧ｵ繧､繧ｺms { get; }
+ long n邨碁℃譎る俣ms { get; }
+ long n邨碁℃譎る俣繧呈峩譁ｰ縺励◆繧ｷ繧ｹ繝繝譎ょ綾ms { get; }
+ CTimer tm繧ｷ繧ｹ繝繝繧ｿ繧､繝 { get; }
+
+ CSound t繧ｵ繧ｦ繝ｳ繝峨ｒ菴懈舌☆繧( string str繝輔ぃ繧､繝ｫ蜷, ESoundGroup soundGroup );
+ void t繧ｵ繧ｦ繝ｳ繝峨ｒ菴懈舌☆繧( string str繝輔ぃ繧､繝ｫ蜷, CSound sound );
+ void t繧ｵ繧ｦ繝ｳ繝峨ｒ菴懈舌☆繧( byte[] byArrWAV繝輔ぃ繧､繝ｫ繧､繝｡繝ｼ繧ｸ, CSound sound );
+ }
+}
diff --git a/FDK19/繧ｳ繝ｼ繝/03.繧ｵ繧ｦ繝ｳ繝/LoudnessMetadata.cs b/FDK19/繧ｳ繝ｼ繝/03.繧ｵ繧ｦ繝ｳ繝/LoudnessMetadata.cs
new file mode 100644
index 00000000..8c0f6ee9
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/03.繧ｵ繧ｦ繝ｳ繝/LoudnessMetadata.cs
@@ -0,0 +1,22 @@
+ｻｿusing System;
+
+namespace FDK
+{
+ ///
+ /// The LoudnessMetadata structure is used to carry, and assist with
+ /// calculations related to, integrated loudness and true peak
+ /// loudness.
+ ///
+ [Serializable]
+ public struct LoudnessMetadata
+ {
+ public readonly Lufs Integrated;
+ public readonly Lufs? TruePeak;
+
+ public LoudnessMetadata(Lufs integrated, Lufs? truePeak)
+ {
+ Integrated = integrated;
+ TruePeak = truePeak;
+ }
+ }
+}
\ No newline at end of file
diff --git a/FDK19/繧ｳ繝ｼ繝/03.繧ｵ繧ｦ繝ｳ繝/LoudnessMetadataScanner.cs b/FDK19/繧ｳ繝ｼ繝/03.繧ｵ繧ｦ繝ｳ繝/LoudnessMetadataScanner.cs
new file mode 100644
index 00000000..f3d26467
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/03.繧ｵ繧ｦ繝ｳ繝/LoudnessMetadataScanner.cs
@@ -0,0 +1,357 @@
+ｻｿusing System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Xml.XPath;
+
+namespace FDK
+{
+ ///
+ /// The LoudnessMetadataScanner plays two roles:
+ /// 1. Scanning of song audio files using BS1770GAIN (http://bs1770gain.sourceforge.net/)
+ /// to determine their perceived loudness. Running on a background thread while not
+ /// in song gameplay, songs without existing loudness metadata files (e.g. *.bs1770gain.xml)
+ /// have their perceived loudness determined and saved into an associated metadata file
+ /// without modifying the original audio file. This scanning process begins running
+ /// with scanning jobs ordered based on the order in which songs are enumerated when
+ /// the application starts, but shifts to prioritize songs which are browsed and previewed
+ /// while on the song select screen.
+ /// 2. Loading of loudness metadata from the BS1770GAIN metadata file alongside each audio file.
+ /// This occurs when parsing .tja files, when song preview begins, and when song playback
+ /// begins. When no file is available on disk, a scanning job is passed to the background
+ /// scanning thread for processing. The loaded metadata is then passed into the
+ /// SongGainController for combination with a configured target loudness, resulting in a
+ /// gain value assigned to the sound object just before playback begins.
+ ///
+ public static class LoudnessMetadataScanner
+ {
+ private const string Bs1770GainExeFileName = "bs1770gain.exe";
+
+ private static readonly Stack Jobs = new Stack();
+ private static readonly object LockObject = new object();
+ private static readonly Queue RecentFileScanDurations = new Queue();
+
+ private static Thread ScanningThread;
+ private static Semaphore Semaphore;
+
+ public static void StartBackgroundScanning()
+ {
+ var tracePrefix = $"{nameof(LoudnessMetadataScanner)}.{nameof(StartBackgroundScanning)}";
+
+ if (!IsBs1770GainAvailable())
+ {
+ Trace.TraceInformation($"{tracePrefix}: BS1770GAIN is not available. A background scanning thread will not be started.");
+ return;
+ }
+
+ Trace.TraceInformation($"{tracePrefix}: BS1770GAIN is available. Starting background scanning thread...");
+
+ lock (LockObject)
+ {
+ Semaphore = new Semaphore(Jobs.Count, int.MaxValue);
+ ScanningThread = new Thread(Scan)
+ {
+ IsBackground = true,
+ Name = "LoudnessMetadataScanner background scanning thread.",
+ Priority = ThreadPriority.Lowest
+ };
+ ScanningThread.Start();
+ }
+
+ Trace.TraceInformation($"{tracePrefix}: Background scanning thread started.");
+ }
+
+ public static void StopBackgroundScanning(bool joinImmediately)
+ {
+ var scanningThread = ScanningThread;
+
+ if (scanningThread == null)
+ {
+ return;
+ }
+
+ var tracePrefix = $"{nameof(LoudnessMetadataScanner)}.{nameof(StopBackgroundScanning)}";
+
+ Trace.TraceInformation($"{tracePrefix}: Stopping background scanning thread...");
+
+ lock (LockObject)
+ {
+ ScanningThread = null;
+ Semaphore.Release();
+ Semaphore = null;
+ }
+
+ if (joinImmediately)
+ {
+ scanningThread.Join();
+ }
+
+ Trace.TraceInformation($"{tracePrefix}: Background scanning thread stopped.");
+ }
+
+ public static LoudnessMetadata? LoadForAudioPath(string absoluteBgmPath)
+ {
+ try
+ {
+ var loudnessMetadataPath = GetLoudnessMetadataPath(absoluteBgmPath);
+
+ if (File.Exists(loudnessMetadataPath))
+ {
+ return LoadFromMetadataPath(loudnessMetadataPath);
+ }
+
+ SubmitForBackgroundScanning(absoluteBgmPath);
+ }
+ catch (Exception e)
+ {
+ var tracePrefix = $"{nameof(LoudnessMetadataScanner)}.{nameof(LoadForAudioPath)}";
+ Trace.TraceError($"{tracePrefix}: Encountered an exception while attempting to load {absoluteBgmPath}");
+ Trace.TraceError(e.ToString());
+ }
+
+ return null;
+ }
+
+ private static string GetLoudnessMetadataPath(string absoluteBgmPath)
+ {
+ return Path.Combine(
+ Path.GetDirectoryName(absoluteBgmPath),
+ Path.GetFileNameWithoutExtension(absoluteBgmPath) + ".bs1770gain.xml");
+ }
+
+ private static LoudnessMetadata? LoadFromMetadataPath(string loudnessMetadataPath)
+ {
+ XPathDocument xPathDocument;
+ try
+ {
+ xPathDocument = new XPathDocument(loudnessMetadataPath);
+ }
+ catch (IOException)
+ {
+ var tracePrefix = $"{nameof(LoudnessMetadataScanner)}.{nameof(LoadFromMetadataPath)}";
+ Trace.TraceWarning($"{tracePrefix}: Encountered IOException while attempting to read {loudnessMetadataPath}. This can occur when attempting to load while scanning the same file. Returning null...");
+ return null;
+ }
+
+ var trackNavigator = xPathDocument.CreateNavigator()
+ .SelectSingleNode(@"//bs1770gain/track[@ToTal=""1"" and @Number=""1""]");
+
+ var integratedLufsNode = trackNavigator?.SelectSingleNode(@"integrated/@lufs");
+ var truePeakTpfsNode = trackNavigator?.SelectSingleNode(@"true-peak/@tpfs");
+
+ if (trackNavigator == null || integratedLufsNode == null || truePeakTpfsNode == null)
+ {
+ var tracePrefix = $"{nameof(LoudnessMetadataScanner)}.{nameof(LoadFromMetadataPath)}";
+ Trace.TraceWarning($"{tracePrefix}: Encountered incorrect xml element structure while parsing {loudnessMetadataPath}. Returning null...");
+ return null;
+ }
+
+ var integrated = integratedLufsNode.ValueAsDouble;
+ var truePeak = truePeakTpfsNode.ValueAsDouble;
+
+ if (integrated <= -70.0 || truePeak >= 12.04)
+ {
+ var tracePrefix = $"{nameof(LoudnessMetadataScanner)}.{nameof(LoadFromMetadataPath)}";
+ Trace.TraceWarning($"{tracePrefix}: Encountered evidence of extreme clipping while parsing {loudnessMetadataPath}. Returning null...");
+ return null;
+ }
+
+ return new LoudnessMetadata(new Lufs(integrated), new Lufs(truePeak));
+ }
+
+ private static void SubmitForBackgroundScanning(string absoluteBgmPath)
+ {
+ lock (LockObject)
+ {
+ // Quite often, the loading process will cause the same job to be submitted many times.
+ // As such, we'll do a quick check as when this happens an equivalent job will often
+ // already be at the top of the stack and we need not add it again.
+ //
+ // Note that we will not scan the whole stack as that is an O(n) operation on the main
+ // thread, whereas redundant file existence checks on the background thread are not harmful.
+ //
+ // We also do not want to scan the whole stack, for example to skip pushing a new item onto it,
+ // because we want to re-submit jobs as the user interacts with their data, usually by
+ // scrolling through songs and previewing them. Their current interests should drive
+ // scanning priorities, and it is for this reason that a stack is used instead of a queue.
+ var semaphore = Semaphore;
+ if (semaphore != null && (Jobs.Count == 0 || Jobs.Peek() != absoluteBgmPath))
+ {
+ Jobs.Push(absoluteBgmPath);
+ semaphore.Release();
+ }
+ }
+ }
+
+ private static void Scan()
+ {
+ try
+ {
+ while (true)
+ {
+ RaiseScanningStateChanged(false);
+
+ Semaphore?.WaitOne();
+
+ if (ScanningThread == null)
+ {
+ return;
+ }
+
+ RaiseScanningStateChanged(true);
+
+ int jobCount;
+ string absoluteBgmPath;
+ lock (LockObject)
+ {
+ jobCount = Jobs.Count;
+ absoluteBgmPath = Jobs.Pop();
+ }
+
+ var tracePrefix = $"{nameof(LoudnessMetadataScanner)}.{nameof(Scan)}";
+
+ try
+ {
+ if (!File.Exists(absoluteBgmPath))
+ {
+ Trace.TraceWarning($"{tracePrefix}: Scanning jobs outstanding: {jobCount - 1}. Missing audio file. Skipping {absoluteBgmPath}...");
+ continue;
+ }
+
+ var loudnessMetadataPath = GetLoudnessMetadataPath(absoluteBgmPath);
+
+ if (File.Exists(loudnessMetadataPath))
+ {
+ Trace.TraceWarning($"{tracePrefix}: Scanning jobs outstanding: {jobCount - 1}. Pre-existing metadata. Skipping {absoluteBgmPath}...");
+ continue;
+ }
+
+ Trace.TraceInformation($"{tracePrefix}: Scanning jobs outstanding: {jobCount}. Scanning {absoluteBgmPath}...");
+ var stopwatch = Stopwatch.StartNew();
+
+ File.Delete(loudnessMetadataPath);
+ var arguments = $"-it --xml -f \"{Path.GetFileName(loudnessMetadataPath)}\" \"{Path.GetFileName(absoluteBgmPath)}\"";
+ Execute(Path.GetDirectoryName(absoluteBgmPath), Bs1770GainExeFileName, arguments, true);
+
+ var seconds = stopwatch.Elapsed.TotalSeconds;
+ RecentFileScanDurations.Enqueue(seconds);
+ while (RecentFileScanDurations.Count > 20)
+ {
+ RecentFileScanDurations.Dequeue();
+ }
+ var averageSeconds = RecentFileScanDurations.Average();
+ Trace.TraceInformation($"{tracePrefix}: Scanned in {seconds}s. Estimated remaining: {(int)(averageSeconds * (jobCount - 1))}s.");
+ }
+ catch (Exception e)
+ {
+ Trace.TraceError($"{tracePrefix}: Encountered an exception while attempting to scan {absoluteBgmPath}");
+ Trace.TraceError(e.ToString());
+ }
+ }
+ }
+ catch (Exception e)
+ {
+ var tracePrefix = $"{nameof(LoudnessMetadataScanner)}.{nameof(Scan)}";
+ Trace.TraceError($"{tracePrefix}: caught an exception at the level of the thread method. The background scanning thread will now terminate.");
+ Trace.TraceError(e.ToString());
+ }
+ }
+
+ private static bool IsBs1770GainAvailable()
+ {
+ try
+ {
+ Execute(null, Bs1770GainExeFileName, "-h");
+ return true;
+ }
+ catch (Win32Exception)
+ {
+ return false;
+ }
+ catch (Exception e)
+ {
+ var tracePrefix = $"{nameof(LoudnessMetadataScanner)}.{nameof(IsBs1770GainAvailable)}";
+ Trace.TraceError($"{tracePrefix}: Encountered an exception. Returning false...");
+ Trace.TraceError(e.ToString());
+
+ return false;
+ }
+ }
+
+ private static string Execute(
+ string workingDirectory, string fileName, string arguments, bool shouldFailOnStdErrDataReceived = false)
+ {
+ var processStartInfo = new ProcessStartInfo(fileName, arguments)
+ {
+ CreateNoWindow = true,
+ RedirectStandardError = true,
+ RedirectStandardOutput = true,
+ UseShellExecute = false,
+ WorkingDirectory = workingDirectory ?? ""
+ };
+
+ var stdoutWriter = new StringWriter();
+ var stderrWriter = new StringWriter();
+ using (var process = Process.Start(processStartInfo))
+ {
+ process.OutputDataReceived += (s, e) =>
+ {
+ if (e.Data != null)
+ {
+ stdoutWriter.Write(e.Data);
+ stdoutWriter.Write(Environment.NewLine);
+ }
+ };
+
+ var errorDataReceived = false;
+ process.ErrorDataReceived += (s, e) =>
+ {
+ if (e.Data != null)
+ {
+ errorDataReceived = true;
+ stderrWriter.Write(e.Data);
+ stderrWriter.Write(Environment.NewLine);
+ }
+ };
+
+ process.BeginOutputReadLine();
+ process.BeginErrorReadLine();
+ process.WaitForExit();
+
+ if ((shouldFailOnStdErrDataReceived && errorDataReceived) || process.ExitCode != 0)
+ {
+ var stderr = stderrWriter.ToString();
+ if (string.IsNullOrEmpty(stderr))
+ {
+ stderr = stdoutWriter.ToString();
+ }
+
+ throw new Exception(
+ $"Execution of {processStartInfo.FileName} with arguments {processStartInfo.Arguments} failed with exit code {process.ExitCode}: {stderr}");
+ }
+
+ return stdoutWriter.ToString();
+ }
+ }
+
+ private static void RaiseScanningStateChanged(bool isActivelyScanning)
+ {
+ ScanningStateChanged?.Invoke(null, new ScanningStateChangedEventArgs(isActivelyScanning));
+ }
+
+ public class ScanningStateChangedEventArgs : EventArgs
+ {
+ public ScanningStateChangedEventArgs(bool isActivelyScanning)
+ {
+ IsActivelyScanning = isActivelyScanning;
+ }
+
+ public bool IsActivelyScanning { get; private set; }
+ }
+
+ public static event EventHandler ScanningStateChanged;
+ }
+}
\ No newline at end of file
diff --git a/FDK19/繧ｳ繝ｼ繝/03.繧ｵ繧ｦ繝ｳ繝/Lufs.cs b/FDK19/繧ｳ繝ｼ繝/03.繧ｵ繧ｦ繝ｳ繝/Lufs.cs
new file mode 100644
index 00000000..aad1efd5
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/03.繧ｵ繧ｦ繝ｳ繝/Lufs.cs
@@ -0,0 +1,47 @@
+ｻｿusing System;
+
+namespace FDK
+{
+ ///
+ /// The Lufs structure is used to carry, and assist with calculations related to,
+ /// Loudness Units relative to Full Scale. LUFS are measured in absolute scale
+ /// and whole values represent one decibel.
+ ///
+ [Serializable]
+ public struct Lufs
+ {
+ private readonly double _value;
+
+ public Lufs(double value)
+ {
+ _value = value;
+ }
+
+ public double ToDouble() => _value;
+
+ public Lufs Min(Lufs lufs)
+ {
+ return new Lufs(Math.Min(_value, lufs._value));
+ }
+
+ public Lufs Negate()
+ {
+ return new Lufs(-_value);
+ }
+
+ public override string ToString()
+ {
+ return _value.ToString();
+ }
+
+ public static Lufs operator- (Lufs left, Lufs right)
+ {
+ return new Lufs(left._value - right._value);
+ }
+
+ public static Lufs operator+ (Lufs left, Lufs right)
+ {
+ return new Lufs(left._value + right._value);
+ }
+ }
+}
diff --git a/FDK19/繧ｳ繝ｼ繝/03.繧ｵ繧ｦ繝ｳ繝/SongGainController.cs b/FDK19/繧ｳ繝ｼ繝/03.繧ｵ繧ｦ繝ｳ繝/SongGainController.cs
new file mode 100644
index 00000000..7020e323
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/03.繧ｵ繧ｦ繝ｳ繝/SongGainController.cs
@@ -0,0 +1,32 @@
+ｻｿnamespace FDK
+{
+ ///
+ /// SongGainController provides a central place through which song preview
+ /// and song playback attempt to apply BS1770GAIN-based loudness metadata
+ /// or .tja SONGVOL as the Gain of a song sound.
+ ///
+ /// By doing so through SongGainController instead of directly against the
+ /// song (preview) CSound object, SongGainController can override the Gain
+ /// value based on configuration or other information.
+ ///
+ public sealed class SongGainController
+ {
+ public bool ApplyLoudnessMetadata { private get; set; }
+ public Lufs TargetLoudness { private get; set; }
+ public bool ApplySongVol { private get; set; }
+
+ public void Set(int songVol, LoudnessMetadata? songLoudnessMetadata, CSound sound)
+ {
+ if (ApplyLoudnessMetadata && songLoudnessMetadata.HasValue)
+ {
+ var gain = TargetLoudness - songLoudnessMetadata.Value.Integrated;
+
+ sound.SetGain(gain, songLoudnessMetadata.Value.TruePeak);
+ }
+ else
+ {
+ sound.SetGain(ApplySongVol ? songVol : CSound.DefaultSongVol);
+ }
+ }
+ }
+}
diff --git a/FDK19/繧ｳ繝ｼ繝/03.繧ｵ繧ｦ繝ｳ繝/SoundDecoder.cs b/FDK19/繧ｳ繝ｼ繝/03.繧ｵ繧ｦ繝ｳ繝/SoundDecoder.cs
new file mode 100644
index 00000000..94d77ad1
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/03.繧ｵ繧ｦ繝ｳ繝/SoundDecoder.cs
@@ -0,0 +1,20 @@
+ｻｿusing System;
+using System.Collections.Generic;
+using System.Text;
+using System.Diagnostics;
+
+namespace FDK
+{
+ ///
+ /// xa,ogg繝繧ｳ繝ｼ繝臥畑縺ｮ蝓ｺ蠎輔け繝ｩ繧ｹ
+ ///
+ public abstract class SoundDecoder //: IDisposable
+ {
+ public abstract int Open( string filename );
+ public abstract int GetFormat( int nHandle, ref CWin32.WAVEFORMATEX wfx );
+ public abstract uint GetTotalPCMSize( int nHandle );
+ public abstract int Seek( int nHandle, uint dwPosition );
+ public abstract int Decode( int nHandle, IntPtr pDest, uint szDestSize, int bLoop );
+ public abstract void Close( int nHandle );
+ }
+}
diff --git a/FDK19/繧ｳ繝ｼ繝/03.繧ｵ繧ｦ繝ｳ繝/SoundGroupLevelController.cs b/FDK19/繧ｳ繝ｼ繝/03.繧ｵ繧ｦ繝ｳ繝/SoundGroupLevelController.cs
new file mode 100644
index 00000000..1b3e9d6c
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/03.繧ｵ繧ｦ繝ｳ繝/SoundGroupLevelController.cs
@@ -0,0 +1,132 @@
+ｻｿusing System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using FDK.ExtensionMethods;
+
+namespace FDK
+{
+ ///
+ /// SoundGroupLevelController holds the current sound level value for each
+ /// of the unique sound groups, along with an increment by which they can
+ /// easily be adjusted.
+ ///
+ /// Configuration changes to the sound group levels are provided to the
+ /// controller via binding code which allows CConfigIni and
+ /// SoundGroupLevelController to be unaware of one another.
+ /// See ConfigIniToSoundGroupLevelControllerBinder for more details.
+ ///
+ /// Dynamic adjustment of sound group levels during song selection and song
+ /// playback are managed via a small dependency taken by the respective
+ /// stage classes. See KeyboardSoundGroupLevelControlHandler and its usages
+ /// for more details.
+ ///
+ /// As new sound objects are created, including when reloading sounds due
+ /// to a changer in audio output device, SoundGroupLevelController ensures
+ /// that they are provided with the current level for their associated
+ /// sound group by subscribing to notifications regarding changes to a
+ /// collection of sound objects provided during construction. This
+ /// observable collection comes from the sound manager, but without either
+ /// it or this class being directly aware of one another.
+ ///
+ /// As sound group levels are changed, SoundGroupLevelController updates
+ /// all existing sound objects group levels by iterating that same
+ /// observable collection.
+ ///
+ public sealed class SoundGroupLevelController
+ {
+ private readonly Dictionary _levelBySoundGroup = new Dictionary
+ {
+ [ESoundGroup.SoundEffect] = CSound.MaximumGroupLevel,
+ [ESoundGroup.Voice] = CSound.MaximumGroupLevel,
+ [ESoundGroup.SongPreview] = CSound.MaximumGroupLevel,
+ [ESoundGroup.SongPlayback] = CSound.MaximumGroupLevel,
+ [ESoundGroup.Unknown] = CSound.MaximumGroupLevel
+ };
+
+ private readonly ObservableCollection _sounds;
+
+ private int _keyboardSoundLevelIncrement;
+
+ public SoundGroupLevelController(ObservableCollection sounds)
+ {
+ _sounds = sounds;
+
+ _sounds.CollectionChanged += SoundsOnCollectionChanged;
+ }
+
+ public void SetLevel(ESoundGroup soundGroup, int level)
+ {
+ var clampedLevel = level.Clamp(CSound.MinimumGroupLevel, CSound.MaximumGroupLevel);
+
+ if (_levelBySoundGroup[soundGroup] == clampedLevel)
+ {
+ return;
+ }
+
+ _levelBySoundGroup[soundGroup] = clampedLevel;
+
+ foreach (var sound in _sounds)
+ {
+ if (sound.SoundGroup == soundGroup)
+ {
+ SetLevel(sound);
+ }
+ }
+
+ RaiseLevelChanged(soundGroup, clampedLevel);
+ }
+
+ public void SetKeyboardSoundLevelIncrement(int keyboardSoundLevelIncrement)
+ {
+ _keyboardSoundLevelIncrement = keyboardSoundLevelIncrement;
+ }
+
+ public void AdjustLevel(ESoundGroup soundGroup, bool isAdjustmentPositive)
+ {
+ var adjustmentIncrement = isAdjustmentPositive
+ ? _keyboardSoundLevelIncrement
+ : -_keyboardSoundLevelIncrement;
+
+ SetLevel(soundGroup, _levelBySoundGroup[soundGroup] + adjustmentIncrement);
+ }
+
+ private void SetLevel(CSound sound)
+ {
+ sound.GroupLevel = _levelBySoundGroup[sound.SoundGroup];
+ }
+
+ private void SoundsOnCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
+ {
+ switch (e.Action)
+ {
+ case NotifyCollectionChangedAction.Add:
+ case NotifyCollectionChangedAction.Replace:
+ foreach (CSound sound in e.NewItems)
+ {
+ SetLevel(sound);
+ }
+ break;
+ }
+ }
+
+ private void RaiseLevelChanged(ESoundGroup soundGroup, int level)
+ {
+ LevelChanged?.Invoke(this, new LevelChangedEventArgs(soundGroup, level));
+ }
+
+ public class LevelChangedEventArgs : EventArgs
+ {
+ public LevelChangedEventArgs(ESoundGroup soundGroup, int level)
+ {
+ SoundGroup = soundGroup;
+ Level = level;
+ }
+
+ public ESoundGroup SoundGroup { get; private set; }
+ public int Level { get; private set; }
+ }
+
+ public event EventHandler LevelChanged;
+ }
+}
diff --git a/FDK19/繧ｳ繝ｼ繝/04.繧ｰ繝ｩ繝輔ぅ繝繧ｯ/BitmapUtil.cs b/FDK19/繧ｳ繝ｼ繝/04.繧ｰ繝ｩ繝輔ぅ繝繧ｯ/BitmapUtil.cs
new file mode 100644
index 00000000..83061321
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/04.繧ｰ繝ｩ繝輔ぅ繝繧ｯ/BitmapUtil.cs
@@ -0,0 +1,74 @@
+ｻｿusing System;
+using System.Collections.Generic;
+using System.Text;
+using System.Runtime.InteropServices;
+using System.Drawing;
+using System.IO;
+
+namespace FDK
+{
+ public static class BitmapUtil
+ {
+ // 螳壽焚
+
+ public const uint DIB_PAL_COLORS = 1;
+ public const uint DIB_RGB_COLORS = 0;
+
+
+ // 讒矩菴
+
+ [StructLayout( LayoutKind.Sequential, Pack = 1 )]
+ public struct BITMAPFILEHEADER
+ {
+ public ushort bfType;
+ public uint bfSize;
+ public ushort bfReserved1;
+ public ushort bfReserved2;
+ public uint bfOffBits;
+ }
+
+ [StructLayout( LayoutKind.Sequential, Pack = 1 )]
+ public struct BITMAPINFOHEADER
+ {
+ public const int BI_RGB = 0;
+ public uint biSize讒矩菴薙ｮ繧ｵ繧､繧ｺ;
+ public int biWidth繝薙ャ繝医槭ャ繝励ｮ蟷dot;
+ public int biHeight繝薙ャ繝医槭ャ繝励ｮ鬮倥＆dot;
+ public ushort biPlanes髱｢縺ｮ謨ｰ;
+ public ushort biBitCount;
+ public uint biCompression蝨ｧ邵ｮ蠖｢蠑;
+ public uint biSizeImage逕ｻ蜒上う繝｡繝ｼ繧ｸ縺ｮ繧ｵ繧､繧ｺ;
+ public int biXPelsPerMete豌ｴ蟷ｳ譁ｹ蜷代ｮ隗｣蜒丞ｺｦ;
+ public int biYPelsPerMeter蝙ら峩譁ｹ蜷代ｮ隗｣蜒丞ｺｦ;
+ public uint biClrUsed濶ｲ繝繝ｼ繝悶Ν縺ｮ繧､繝ｳ繝繝繧ｯ繧ｹ謨ｰ;
+ public uint biClrImportant陦ｨ遉ｺ縺ｫ蠢隕√↑濶ｲ繧､繝ｳ繝繝繧ｯ繧ｹ縺ｮ謨ｰ;
+ }
+
+
+ // 繝｡繧ｽ繝繝
+
+ public static unsafe Bitmap ToBitmap( IntPtr pBITMAPINFOHEADER )
+ {
+ BITMAPFILEHEADER bitmapfileheader;
+ BITMAPINFOHEADER* bitmapinfoheaderPtr = (BITMAPINFOHEADER*) pBITMAPINFOHEADER;
+ bitmapfileheader.bfType = 0x4d42;
+ bitmapfileheader.bfOffBits = (uint) ( sizeof( BITMAPFILEHEADER ) + sizeof( BITMAPINFOHEADER ) );
+ bitmapfileheader.bfSize = bitmapfileheader.bfOffBits + bitmapinfoheaderPtr->biSizeImage逕ｻ蜒上う繝｡繝ｼ繧ｸ縺ｮ繧ｵ繧､繧ｺ;
+ MemoryStream output = new MemoryStream();
+ BinaryWriter writer = new BinaryWriter( output );
+ byte[] destination = new byte[ sizeof( BITMAPFILEHEADER ) ];
+ Marshal.Copy( (IntPtr) ( &bitmapfileheader ), destination, 0, destination.Length );
+ writer.Write( destination );
+ destination = new byte[ sizeof( BITMAPINFOHEADER ) ];
+ Marshal.Copy( pBITMAPINFOHEADER, destination, 0, destination.Length );
+ writer.Write( destination );
+ destination = new byte[ bitmapinfoheaderPtr->biSizeImage逕ｻ蜒上う繝｡繝ｼ繧ｸ縺ｮ繧ｵ繧､繧ｺ ];
+ bitmapinfoheaderPtr++;
+ Marshal.Copy( (IntPtr) bitmapinfoheaderPtr, destination, 0, destination.Length );
+ writer.Write( destination );
+ writer.Flush();
+ writer.BaseStream.Position = 0L;
+ return new Bitmap( writer.BaseStream );
+ }
+ }
+}
diff --git a/FDK19/繧ｳ繝ｼ繝/04.繧ｰ繝ｩ繝輔ぅ繝繧ｯ/CAero.cs b/FDK19/繧ｳ繝ｼ繝/04.繧ｰ繝ｩ繝輔ぅ繝繧ｯ/CAero.cs
new file mode 100644
index 00000000..98765b2e
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/04.繧ｰ繝ｩ繝輔ぅ繝繧ｯ/CAero.cs
@@ -0,0 +1,78 @@
+ｻｿusing System;
+using System.Collections.Generic;
+using System.Text;
+using System.Runtime.InteropServices;
+using System.Drawing;
+using SlimDX;
+
+namespace FDK
+{
+ //http://spazzarama.wordpress.com/2009/09/30/enable-or-disable-dwm-composition-aero/
+ ///
+ /// To control Aerograph in Vista and Windows7. Don't use this class in XP.
+ ///
+ public static class DWM
+ {
+ const uint DWM_EC_DISABLECOMPOSITION = 0;
+ const uint DWM_EC_ENABLECOMPOSITION = 1;
+
+ [DllImport( "dwmapi.dll", EntryPoint = "DwmEnableComposition" )]
+ extern static uint DwmEnableComposition( uint compositionAction );
+ [DllImport( "dwmapi.dll", EntryPoint = "DwmEnableComposition" )]
+ public extern static bool DwmIsCompositionEnabled(out bool pfEnabled);
+ [DllImport( "dwmapi.dll", EntryPoint = "DwmFlush" )]
+ extern static int DwmFlush();
+// [DllImport( "dwmapi.dll", EntryPoint = "DwmEnableMMCSS" )]
+// extern static int DwmEnableMMCSS( bool fEnableMMCSS );
+ [DllImport( "dwmapi.dll", EntryPoint = "DwmFlush" )]
+ extern static int DwmEnableMMCSS( bool fEnableMMCSS );
+
+ public static int IsCompositionEnabled(out bool enabled)
+ {
+#if TEST_Direct3DEx
+ return DwmIsCompositionEnabled( out enabled );
+#else
+ enabled = false;
+ return 0;
+#endif
+ }
+ public static int Flush()
+ {
+#if TEST_Direct3DEx
+ return DwmFlush();
+#else
+ return 0; // 0(S_OK)縺ｪ繧画仙粥
+#endif
+ }
+
+ ///
+ /// Enable/Disable DWM composition (aka Aero)
+ ///
+ /// True to enable composition, false to disable composition.
+ /// True if the operation was successful.
+ public static bool EnableComposition( bool bIsAeroEnabled )
+ {
+// DwmEnableMMCSS( true );
+#if TEST_Direct3D9Ex
+ try
+ {
+ if ( bIsAeroEnabled )
+ {
+ DwmEnableComposition( DWM_EC_ENABLECOMPOSITION );
+ }
+ else
+ {
+ DwmEnableComposition( DWM_EC_DISABLECOMPOSITION );
+ }
+ return true;
+ }
+ catch ( DllNotFoundException )
+ {
+ return false;
+ }
+#else
+ return true;
+#endif
+ }
+ }
+}
diff --git a/FDK19/繧ｳ繝ｼ繝/04.繧ｰ繝ｩ繝輔ぅ繝繧ｯ/CAvi.cs b/FDK19/繧ｳ繝ｼ繝/04.繧ｰ繝ｩ繝輔ぅ繝繧ｯ/CAvi.cs
new file mode 100644
index 00000000..9e8244f4
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/04.繧ｰ繝ｩ繝輔ぅ繝繧ｯ/CAvi.cs
@@ -0,0 +1,306 @@
+ｻｿusing System;
+using System.Collections.Generic;
+using System.Text;
+using System.Runtime.InteropServices;
+using System.Drawing;
+using SlimDX;
+
+namespace FDK
+{
+ public class CAvi : IDisposable
+ {
+ // 繝励Ο繝代ユ繧｣
+
+ public uint dw繧ｹ繧ｱ繝ｼ繝ｫ
+ {
+ get;
+ set;
+ }
+ public uint dw繝ｬ繝ｼ繝
+ {
+ get;
+ set;
+ }
+ public uint n繝輔Ξ繝ｼ繝鬮倥＆
+ {
+ get;
+ set;
+ }
+ public uint n繝輔Ξ繝ｼ繝蟷
+ {
+ get;
+ set;
+ }
+
+
+ // 繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ
+
+ public CAvi( string filename )
+ {
+ if ( AVIFileOpen( out this.aviFile, filename, OpenFileFlags.OF_READ, IntPtr.Zero ) != 0 )
+ {
+ this.Release();
+ throw new Exception( "AVIFileOpen failed." );
+ }
+ if ( AVIFileGetStream( this.aviFile, out this.aviStream, streamtypeVIDEO, 0 ) != 0 )
+ {
+ this.Release();
+ throw new Exception( "AVIFileGetStream failed." );
+ }
+ var info = new AVISTREAMINFO();
+ AVIStreamInfo( this.aviStream, ref info, Marshal.SizeOf( info ) );
+ this.dw繝ｬ繝ｼ繝 = info.dwRate;
+ this.dw繧ｹ繧ｱ繝ｼ繝ｫ = info.dwScale;
+ this.n繝輔Ξ繝ｼ繝蟷 = info.rcFrame.right - info.rcFrame.left;
+ this.n繝輔Ξ繝ｼ繝鬮倥＆ = info.rcFrame.bottom - info.rcFrame.top;
+ try
+ {
+ this.frame = AVIStreamGetFrameOpen( this.aviStream, 0 );
+ }
+ catch
+ {
+ this.Release();
+ throw new Exception( "AVIStreamGetFrameOpen failed." );
+ }
+ }
+
+
+ // 繝｡繧ｽ繝繝
+
+ public static void t蛻晄悄蛹()
+ {
+ AVIFileInit();
+ }
+ public static void t邨ゆｺ()
+ {
+ AVIFileExit();
+ }
+
+ public Bitmap GetFrame( int no )
+ {
+ if( this.aviStream == IntPtr.Zero )
+ throw new InvalidOperationException();
+
+ return BitmapUtil.ToBitmap( AVIStreamGetFrame( this.frame, no ) );
+ }
+ public int GetFrameNoFromTime( int time )
+ {
+ return (int) ( time * ( ( (double) this.dw繝ｬ繝ｼ繝 ) / ( 1000.0 * this.dw繧ｹ繧ｱ繝ｼ繝ｫ ) ) );
+ }
+ public IntPtr GetFramePtr( int no )
+ {
+ if( this.aviStream == IntPtr.Zero )
+ throw new InvalidOperationException();
+
+ return AVIStreamGetFrame( this.frame, no );
+ }
+ public int GetMaxFrameCount()
+ {
+ if( this.aviStream == IntPtr.Zero )
+ throw new InvalidOperationException();
+
+ return AVIStreamLength( this.aviStream );
+ }
+
+ public unsafe void tBitmap24ToGraphicsStreamR5G6B5( BitmapUtil.BITMAPINFOHEADER* pBITMAPINFOHEADER, DataStream gs, int nWidth, int nHeight )
+ {
+ int nBmpWidth = pBITMAPINFOHEADER->biWidth繝薙ャ繝医槭ャ繝励ｮ蟷dot;
+ int nBmpHeight = pBITMAPINFOHEADER->biHeight繝薙ャ繝医槭ャ繝励ｮ鬮倥＆dot;
+ int nBmpLineByte = ( nBmpWidth * 3 ) + ( ( 4 - ( ( nBmpWidth * 3 ) % 4 ) ) % 4 );
+
+ ushort* pTexture = (ushort*) gs.DataPointer.ToPointer();
+ byte* pBitmap = (byte*) ( pBITMAPINFOHEADER + 1 );
+
+ for( int i = 0; i < nBmpHeight; i++ )
+ {
+ if( i >= nHeight )
+ break;
+
+ for( int j = 0; j < nBmpWidth; j++ )
+ {
+ if( j >= nWidth )
+ break;
+
+ ushort B = (ushort) ( ( *( ( pBitmap + ( ( ( nBmpHeight - i ) - 1 ) * nBmpLineByte ) ) + ( j * 3 ) + 0 ) >> 3 ) & 0x1f );
+ ushort G = (ushort) ( ( *( ( pBitmap + ( ( ( nBmpHeight - i ) - 1 ) * nBmpLineByte ) ) + ( j * 3 ) + 1 ) >> 2 ) & 0x3f );
+ ushort R = (ushort) ( ( *( ( pBitmap + ( ( ( nBmpHeight - i ) - 1 ) * nBmpLineByte ) ) + ( j * 3 ) + 2 ) >> 3 ) & 0x1f );
+ *( pTexture + ( i * nWidth ) + j ) = (ushort) ( ( R << 11 ) | ( G << 5 ) | B );
+ }
+ }
+ }
+ public unsafe void tBitmap24ToGraphicsStreamX8R8G8B8( BitmapUtil.BITMAPINFOHEADER* pBITMAPINFOHEADER, DataStream ds, int nWidth, int nHeight )
+ {
+ int nBmpWidth = pBITMAPINFOHEADER->biWidth繝薙ャ繝医槭ャ繝励ｮ蟷dot;
+ int nBmpHeight = pBITMAPINFOHEADER->biHeight繝薙ャ繝医槭ャ繝励ｮ鬮倥＆dot;
+ int nBmpLineByte = ( nBmpWidth * 3 ) + ( ( 4 - ( ( nBmpWidth * 3 ) % 4 ) ) % 4 );
+
+ uint* pTexture = (uint*) ds.DataPointer.ToPointer();
+ byte* pBitmap = (byte*) ( pBITMAPINFOHEADER + 1 );
+
+ for( int i = 0; i < nBmpHeight; i++ )
+ {
+ if( i >= nHeight )
+ break;
+
+ for( int j = 0; j < nBmpWidth; j++ )
+ {
+ if( j >= nWidth )
+ break;
+
+ uint B = *( ( pBitmap + ( ( ( nBmpHeight - i ) - 1 ) * nBmpLineByte ) ) + ( j * 3 ) + 0 );
+ uint G = *( ( pBitmap + ( ( ( nBmpHeight - i ) - 1 ) * nBmpLineByte ) ) + ( j * 3 ) + 1 );
+ uint R = *( ( pBitmap + ( ( ( nBmpHeight - i ) - 1 ) * nBmpLineByte ) ) + ( j * 3 ) + 2 );
+ *( pTexture + ( i * nWidth ) + j ) = ( R << 16 ) | ( G << 8 ) | B;
+ }
+ }
+ }
+
+ #region [ Dispose-Finalize 繝代ち繝ｼ繝ｳ螳溯｣ ]
+ //-----------------
+ public void Dispose()
+ {
+ this.Dispose( true );
+ GC.SuppressFinalize( this ); // 2011.8.19 from: 蠢倥ｌ縺ｦ縺溘
+ }
+ protected void Dispose( bool disposeManagedObjects )
+ {
+ if( this.bDispose螳御ｺ貂医∩ )
+ return;
+
+ if( disposeManagedObjects )
+ {
+ // (A) Managed 繝ｪ繧ｽ繝ｼ繧ｹ縺ｮ隗｣謾ｾ
+ }
+
+ // (B) Unamanaged 繝ｪ繧ｽ繝ｼ繧ｹ縺ｮ隗｣謾ｾ
+
+ if( this.frame != IntPtr.Zero )
+ AVIStreamGetFrameClose( this.frame );
+
+ this.Release();
+ this.bDispose螳御ｺ貂医∩ = true;
+ }
+ ~CAvi()
+ {
+ this.Dispose( false );
+ }
+ //-----------------
+ #endregion
+
+
+ // 縺昴ｮ莉
+
+ #region [ Win32 AVI髢｢騾｣髢｢謨ｰ繧､繝ｳ繝昴ｼ繝 ]
+ //-----------------
+ internal enum OpenFileFlags : uint
+ {
+ OF_CANCEL = 0x800,
+ OF_CREATE = 0x1000,
+ OF_DELETE = 0x200,
+ OF_EXIST = 0x4000,
+ OF_PARSE = 0x100,
+ OF_PROMPT = 0x2000,
+ OF_READ = 0,
+ OF_READWRITE = 2,
+ OF_REOPEN = 0x8000,
+ OF_SHARE_COMPAT = 0,
+ OF_SHARE_DENY_NONE = 0x40,
+ OF_SHARE_DENY_READ = 0x30,
+ OF_SHARE_DENY_WRITE = 0x20,
+ OF_SHARE_EXCLUSIVE = 0x10,
+ OF_VERIFY = 0x400,
+ OF_WRITE = 1
+ }
+
+ [StructLayout( LayoutKind.Sequential, Pack = 1 )]
+ internal struct AVISTREAMINFO
+ {
+ public uint fccType;
+ public uint fccHandler;
+ public uint dwFlags;
+ public uint dwCaps;
+ public ushort wPriority;
+ public ushort wLanguage;
+ public uint dwScale;
+ public uint dwRate;
+ public uint dwStart;
+ public uint dwLength;
+ public uint dwInitialFrames;
+ public uint dwSuggestedBufferSize;
+ public uint dwQuality;
+ public uint dwSampleSize;
+ public CAvi.RECT rcFrame;
+ public uint dwEditCount;
+ public uint dwFormatChangeCount;
+ [MarshalAs( UnmanagedType.ByValArray, SizeConst = 0x40 )]
+ public ushort[] szName;
+ }
+
+ [StructLayout( LayoutKind.Sequential, Pack = 1 )]
+ internal struct RECT
+ {
+ public uint left;
+ public uint top;
+ public uint right;
+ public uint bottom;
+ }
+
+ [DllImport( "AVIFIL32" )]
+ private static extern void AVIFileExit();
+ [DllImport( "AVIFIL32" )]
+ private static extern uint AVIFileGetStream( IntPtr pfile, out IntPtr ppavi, uint fccType, int lParam );
+ [DllImport( "AVIFIL32" )]
+ private static extern void AVIFileInit();
+ [DllImport( "AVIFIL32" )]
+ private static extern uint AVIFileOpen( out IntPtr ppfile, string szFile, OpenFileFlags mode, IntPtr pclsidHandler );
+ [DllImport( "AVIFIL32" )]
+ private static extern int AVIFileRelease( IntPtr pfile );
+ [DllImport( "AVIFIL32" )]
+ private static extern IntPtr AVIStreamGetFrame( IntPtr pgf, int lPos );
+ [DllImport( "AVIFIL32" )]
+ private static extern uint AVIStreamGetFrameClose( IntPtr pget );
+ [DllImport( "AVIFIL32" )]
+ private static extern IntPtr AVIStreamGetFrameOpen( IntPtr pavi, int lpbiWanted );
+ [DllImport( "AVIFIL32" )]
+ private static extern int AVIStreamInfo( IntPtr pavi, ref AVISTREAMINFO psi, int lSize );
+ [DllImport( "AVIFIL32" )]
+ private static extern int AVIStreamLength( IntPtr pavi );
+ [DllImport( "AVIFIL32" )]
+ private static extern int AVIStreamRelease( IntPtr pavi );
+ //-----------------
+ #endregion
+
+ #region [ private ]
+ //-----------------
+ private IntPtr aviFile = IntPtr.Zero;
+ private const string AVIFILE32 = "AVIFIL32";
+ private const int AVIGETFRAMEF_BESTDISPLAYFMT = 1;
+ private IntPtr aviStream = IntPtr.Zero;
+ private bool bDispose螳御ｺ貂医∩;
+ private IntPtr frame = IntPtr.Zero;
+ private static readonly uint streamtypeAUDIO = mmioFOURCC( 'a', 'u', 'd', 's' );
+ private static readonly uint streamtypeMIDI = mmioFOURCC( 'm', 'i', 'd', 's' );
+ private static readonly uint streamtypeTEXT = mmioFOURCC( 't', 'x', 't', 's' );
+ private static readonly uint streamtypeVIDEO = mmioFOURCC( 'v', 'i', 'd', 's' );
+
+ private static uint mmioFOURCC( char c0, char c1, char c2, char c3 )
+ {
+ return ( (uint) c3 << 0x18 ) | ( (uint) c2 << 0x10 ) | ( (uint) c1 << 0x08 ) | (uint) c0;
+ }
+ private void Release()
+ {
+ if( this.aviStream != IntPtr.Zero )
+ {
+ AVIStreamRelease( this.aviStream );
+ this.aviStream = IntPtr.Zero;
+ }
+ if( this.aviFile != IntPtr.Zero )
+ {
+ AVIFileRelease( this.aviFile );
+ this.aviFile = IntPtr.Zero;
+ }
+ }
+ //-----------------
+ #endregion
+ }
+}
diff --git a/FDK19/繧ｳ繝ｼ繝/04.繧ｰ繝ｩ繝輔ぅ繝繧ｯ/CTaskBar.cs b/FDK19/繧ｳ繝ｼ繝/04.繧ｰ繝ｩ繝輔ぅ繝繧ｯ/CTaskBar.cs
new file mode 100644
index 00000000..05d6732a
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/04.繧ｰ繝ｩ繝輔ぅ繝繧ｯ/CTaskBar.cs
@@ -0,0 +1,145 @@
+ｻｿusing System;
+using System.Collections.Generic;
+using System.Text;
+using System.Reflection;
+using System.Windows.Forms;
+using System.Runtime.InteropServices;
+
+namespace FDK
+{
+ // referenced from http://dalmore.blog7.fc2.com/blog-entry-34.html
+
+ public static class CTaskBar
+ {
+ public static void ShowTaskBar( bool bShowTaskBar )
+ {
+ Int32 hWnd1 = FindWindow( "Shell_TrayWnd", null );
+ if( hWnd1 != 0 )
+ { //繧ｿ繧ｹ繧ｯ繝舌ｼ縺ｮ陦ｨ遉ｺ
+ if ( bShowTaskBar )
+ {
+ ShowWindow( hWnd1, TASKBAR_SHOW ); //// 繧ｿ繧ｹ繧ｯ繝舌ｼ繧貞ｸｸ縺ｫ陦ｨ遉ｺ
+ }
+ else
+ {
+ ShowWindow( hWnd1, TASKBAR_HIDE );
+ }
+ APPBARDATA pData = new APPBARDATA();
+ pData.cbSize = Marshal.SizeOf( pData );
+ pData.hWnd = (IntPtr)hWnd1;
+ pData.lParam = (int)ABMsg.ABM_NEW; //REMOVE縺ｫ縺吶ｋ縺ｨ繧ｪ繝ｼ繝医ワ繧､繝峨↓縺ｪ繧
+ //繧ｿ繧ｹ繧ｯ繝舌ｼ縺ｫ繝｡繝繧ｻ繝ｼ繧ｸ騾∽ｿ｡
+ SHAppBarMessage( ABMsg.ABM_SETSTATE, ref pData );
+ }
+
+ Int32 hWnd2 = FindWindow( "Button", "繧ｹ繧ｿ繝ｼ繝" );
+ if ( hWnd2 != 0 )
+ { //繧ｿ繧ｹ繧ｯ繝舌ｼ縺ｮ陦ｨ遉ｺ
+ if ( bShowTaskBar )
+ {
+ ShowWindow( hWnd2, TASKBAR_SHOW ); //// 繧ｿ繧ｹ繧ｯ繝舌ｼ繧貞ｸｸ縺ｫ陦ｨ遉ｺ
+ }
+ else
+ {
+ ShowWindow( hWnd2, TASKBAR_HIDE );
+ }
+ APPBARDATA pData = new APPBARDATA();
+ pData.cbSize = Marshal.SizeOf( pData );
+ pData.hWnd = (IntPtr) hWnd2;
+ pData.lParam = (int) ABMsg.ABM_NEW; //REMOVE縺ｫ縺吶ｋ縺ｨ繧ｪ繝ｼ繝医ワ繧､繝峨↓縺ｪ繧
+ //繧ｿ繧ｹ繧ｯ繝舌ｼ縺ｫ繝｡繝繧ｻ繝ｼ繧ｸ騾∽ｿ｡
+ SHAppBarMessage( ABMsg.ABM_SETSTATE, ref pData );
+ }
+ }
+
+ ///
+ /// ABMsg 騾√ｋAppBar繝｡繝繧ｻ繝ｼ繧ｸ縺ｮ隴伜挨蟄撰ｼ井ｻ･荳九ｮ縺縺壹ｌ縺1縺､ｼ
+ /// _ABM_ACTIVATE---AppBar縺後い繧ｯ繝繧｣繝悶↓縺ｪ縺｣縺滉ｺ九ｒ繧ｷ繧ｹ繝繝縺ｫ騾夂衍
+ /// _ABM_GETAUTOHIDEBAR---繧ｹ繧ｯ繝ｪ繝ｼ繝ｳ縺ｮ迚ｹ螳壹ｮ遶ｯ縺ｫ髢｢騾｣莉倥¢繧峨ｌ縺ｦ縺繧九が繝ｼ繝医ワ繧､繝陰ppBar縺ｮ繝上Φ繝峨Ν繧定ｿ斐☆
+ /// _ABM_GETSTATE---繧ｿ繧ｹ繧ｯ繝舌ｼ縺後が繝ｼ繝医ワ繧､繝峨°蟶ｸ縺ｫ譛蜑埼擇縺ｮ縺ｩ縺｡繧峨ｮ蟶ｸ諷九↓縺ゅｋ縺九ｒ霑斐☆
+ /// _ABM_GETTASKBARPOS---繧ｿ繧ｹ繧ｯ繝舌ｼ縺ｮ菴ｿ逕ｨ鬆伜沺繧定ｿ斐☆
+ /// _ABM_NEW---譁ｰ縺励＞AppBar繧堤匳骭ｲ縺励√す繧ｹ繝繝縺碁夂衍縺ｫ菴ｿ逕ｨ縺吶ｋ繝｡繝繧ｻ繝ｼ繧ｸID繧呈欠螳壹☆繧
+ /// _ABM_QUERYPOS---AppBar縺ｮ縺溘ａ縺ｮ繧ｵ繧､繧ｺ縺ｨ繧ｹ繧ｯ繝ｪ繝ｼ繝ｳ菴咲ｽｮ繧定ｦ∵ｱゅ☆繧
+ /// _ABM_REMOVE---AppBar縺ｮ逋ｻ骭ｲ繧貞炎髯､縺吶ｋ
+ /// _ABM_SETAUTOHIDEBAR---繧ｹ繧ｯ繝ｪ繝ｼ繝ｳ縺ｮ遶ｯ縺ｫ繧ｪ繝ｼ繝医ワ繧､繝陰ppBar繧堤匳骭ｲ縺ｾ縺溘ｯ蜑企勁縺吶ｋ
+ /// _ABM_SETPOS---AppBar縺ｮ繧ｵ繧､繧ｺ縺ｨ繧ｹ繧ｯ繝ｪ繝ｼ繝ｳ蠎ｧ讓吶ｒ險ｭ螳壹☆繧
+ /// _ABM_WINDOWPOSCHANGED---AppBar縺ｮ菴咲ｽｮ縺悟､画峩縺輔ｌ縺溘％縺ｨ繧偵す繧ｹ繝繝縺ｫ騾夂衍縺吶ｋ
+ /// pDataｼ TAppBarData讒矩菴難ｼ亥推繝輔ぅ繝ｼ繝ｫ繝峨ｯdwMessage縺ｫ萓晏ｭ倥☆繧具ｼ
+ ///
+ private enum ABMsg : int
+ {
+ ABM_NEW = 0,
+ ABM_REMOVE = 1,
+ ABM_QUERYPOS = 2,
+ ABM_SETPOS = 3,
+ ABM_GETSTATE = 4,
+ ABM_GETTASKBARPOS = 5,
+ ABM_ACTIVATE = 6,
+ ABM_GETAUTOHIDEBAR = 7,
+ ABM_SETAUTOHIDEBAR = 8,
+ ABM_WINDOWPOSCHANGED = 9,
+ ABM_SETSTATE = 10
+ }
+
+ ///
+ /// APPBARDATA SHAppBarMessage髢｢謨ｰ縺ｫ縺ｦ菴ｿ逕ｨ縺輔ｌ繧帰ppBar縺ｫ髢｢縺吶ｋ讒矩菴薙
+ /// cbSize.....SizeOf(TAppBarData)
+ /// hWnd.....AppBar縺ｮ繝上Φ繝峨Ν
+ /// uCallbackMessage.....莉ｻ諢上ｮ繝｡繝繧ｻ繝ｼ繧ｸIDｼhWnd縺ｮAppBar縺ｫ繝｡繝繧ｻ繝ｼ繧ｸ繧帝夂衍縺吶ｋ髫幢ｼABM_NEW繝｡繝繧ｻ繝ｼ繧ｸ繧帝√ｋ髫幢ｼ峨↓菴ｿ逕ｨｼ
+ /// uEdge.....繧ｹ繧ｯ繝ｪ繝ｼ繝ｳ縺ｮ遶ｯ繧呈欠螳壹☆繧九ヵ繝ｩ繧ｰｼABM_GETAUTOHIDEBAR縲、BM_QUERYPOS縲、BM_SETAUTOHIDEBAR縲、BM_SETPOS繝｡繝繧ｻ繝ｼ繧ｸ繧帝√ｋ髫帙↓菴ｿ逕ｨ縺励∽ｻ･荳九ｮ縺縺壹ｌ縺1縺､ｼ
+ /// _ABE_BOTTOM---荳九し繧､繝
+ /// _ABE_LEFT--- 蟾ｦ繧ｵ繧､繝
+ /// _ABE_RIGHT---蜿ｳ繧ｵ繧､繝
+ /// _ABE_TOP---荳翫し繧､繝
+ /// rc.....AppBar繧繧ｿ繧ｹ繧ｯ繝舌ｼ縺ｮ繧ｹ繧ｯ繝ｪ繝ｼ繝ｳ蠎ｧ讓吶〒縺ｮ陦ｨ遉ｺ鬆伜沺ｼABM_GETTASKBARPOS縲、BM_QUERYPOS縲、BM_SETPOS繝｡繝繧ｻ繝ｼ繧ｸ繧帝√ｋ髫帙↓菴ｿ逕ｨ縺吶ｋｼ
+ /// lParam.....繝｡繝繧ｻ繝ｼ繧ｸ萓晏ｭ倥ｮ繝代Λ繝｡繝ｼ繧ｿｼABM_SETAUTOHIDEBAR繝｡繝繧ｻ繝ｼ繧ｸ縺ｨ蜈ｱ縺ｫ菴ｿ逕ｨ縺輔ｌ繧具ｼ
+ ///
+ [StructLayout( LayoutKind.Sequential )]
+ private struct APPBARDATA
+ {
+ public int cbSize;
+ public IntPtr hWnd;
+ public uint uCallbackMessage;
+ public ABEdge uEdge;
+ public RECT rc;
+ public int lParam;
+ }
+ ///
+ /// ABEdge
+ ///
+ private enum ABEdge : int
+ {
+ ABE_LEFT = 0,
+ ABE_TOP = 1,
+ ABE_RIGHT = 2,
+ ABE_BOTTOM = 3
+ }
+ ///
+ /// RECT
+ ///
+ [StructLayout( LayoutKind.Sequential )]
+ private struct RECT
+ {
+ public int left;
+ public int top;
+ public int right;
+ public int bottom;
+ }
+ ///
+ /// SHAppBarMessage
+ ///
+ ///
+ ///
+ ///
+ [DllImport( "shell32.dll", CallingConvention = CallingConvention.StdCall )]
+ private static extern int SHAppBarMessage( ABMsg dwMessage, ref APPBARDATA pData );
+
+ [DllImport("user32.dll", EntryPoint = "ShowWindow")]
+ private static extern int ShowWindow(Int32 hWnd, int nCmdShow);
+ private const int TASKBAR_HIDE = 0;
+ private const int TASKBAR_SHOW = 5;
+
+ [DllImport( "user32.dll", EntryPoint = "FindWindow" )]
+ private static extern Int32 FindWindow( String lpClassName, String lpWindowName );
+ }
+}
diff --git a/FDK19/繧ｳ繝ｼ繝/04.繧ｰ繝ｩ繝輔ぅ繝繧ｯ/CTexture.cs b/FDK19/繧ｳ繝ｼ繝/04.繧ｰ繝ｩ繝輔ぅ繝繧ｯ/CTexture.cs
new file mode 100644
index 00000000..7975124a
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/04.繧ｰ繝ｩ繝輔ぅ繝繧ｯ/CTexture.cs
@@ -0,0 +1,1240 @@
+ｻｿusing System;
+using System.Collections.Generic;
+using System.Text;
+using System.Drawing;
+using System.Drawing.Imaging;
+using System.IO;
+using System.Diagnostics;
+using SlimDX;
+using SlimDX.Direct3D9;
+
+using Device = SampleFramework.DeviceCache;
+
+namespace FDK
+{
+ public class CTexture : IDisposable
+ {
+ // 繝励Ο繝代ユ繧｣
+ public bool b蜉邂怜粋謌
+ {
+ get;
+ set;
+ }
+ public bool b荵礼ｮ怜粋謌
+ {
+ get;
+ set;
+ }
+ public bool b貂帷ｮ怜粋謌
+ {
+ get;
+ set;
+ }
+ public bool b繧ｹ繧ｯ繝ｪ繝ｼ繝ｳ蜷域
+ {
+ get;
+ set;
+ }
+ public float fZ霆ｸ荳ｭ蠢蝗櫁ｻ｢
+ {
+ get;
+ set;
+ }
+ public int Opacity
+ {
+ get
+ {
+ return this._opacity;
+ }
+ set
+ {
+ if (value < 0)
+ {
+ this._opacity = 0;
+ }
+ else if (value > 0xff)
+ {
+ this._opacity = 0xff;
+ }
+ else
+ {
+ this._opacity = value;
+ }
+ }
+ }
+ public Size sz繝繧ｯ繧ｹ繝√Ε繧ｵ繧､繧ｺ
+ {
+ get;
+ private set;
+ }
+ public Size sz逕ｻ蜒上し繧､繧ｺ
+ {
+ get;
+ protected set;
+ }
+ public Texture texture
+ {
+ get;
+ private set;
+ }
+ public Format Format
+ {
+ get;
+ protected set;
+ }
+ public Vector3 vc諡｡螟ｧ邵ｮ蟆丞咲紫;
+
+ // 逕ｻ髱｢縺悟､峨ｏ繧九◆縺ｳ莉･荳九ｮ繝励Ο繝代ユ繧｣繧定ｨｭ螳壹＠豐ｻ縺吶％縺ｨ縲
+
+ public static Size sz隲也炊逕ｻ髱｢ = Size.Empty;
+ public static Size sz迚ｩ逅逕ｻ髱｢ = Size.Empty;
+ public static Rectangle rc迚ｩ逅逕ｻ髱｢謠冗判鬆伜沺 = Rectangle.Empty;
+ ///
+ /// 隲也炊逕ｻ髱｢繧1縺ｨ縺吶ｋ蝣ｴ蜷医ｮ迚ｩ逅逕ｻ髱｢縺ｮ蛟咲紫縲
+ /// 隲也炊蛟､ﾃ礼判髱｢豈皮紫ｼ晉黄逅蛟､縲
+ ///
+ public static float f逕ｻ髱｢豈皮紫 = 1.0f;
+
+ // 繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ
+
+ public CTexture()
+ {
+ this.sz逕ｻ蜒上し繧､繧ｺ = new Size(0, 0);
+ this.sz繝繧ｯ繧ｹ繝√Ε繧ｵ繧､繧ｺ = new Size(0, 0);
+ this._opacity = 0xff;
+ this.texture = null;
+ this.cvPositionColoredVertexies = null;
+ this.b蜉邂怜粋謌 = false;
+ this.fZ霆ｸ荳ｭ蠢蝗櫁ｻ｢ = 0f;
+ this.vc諡｡螟ｧ邵ｮ蟆丞咲紫 = new Vector3(1f, 1f, 1f);
+ // this._txData = null;
+ }
+
+ ///
+ /// 謖螳壹＆繧後◆繝薙ャ繝医槭ャ繝励が繝悶ず繧ｧ繧ｯ繝医°繧 Managed 繝繧ｯ繧ｹ繝√Ε繧剃ｽ懈舌☆繧九
+ /// 繝繧ｯ繧ｹ繝√Ε縺ｮ繧ｵ繧､繧ｺ縺ｯ縲。ITMAP逕ｻ蜒上ｮ繧ｵ繧､繧ｺ莉･荳翫√°縺､縲．3D9繝繝舌う繧ｹ縺ｧ逕滓仙庄閭ｽ縺ｪ譛蟆上ｮ繧ｵ繧､繧ｺ縺ｫ閾ｪ蜍慕噪縺ｫ隱ｿ遽縺輔ｌ繧九
+ /// 縺昴ｮ髫帙√ユ繧ｯ繧ｹ繝√Ε縺ｮ隱ｿ遽蠕後ｮ繧ｵ繧､繧ｺ縺ｫ縺ゅｏ縺帙◆逕ｻ蜒上ｮ諡｡螟ｧ邵ｮ蟆上ｯ陦後ｏ縺ｪ縺縲
+ /// 縺昴ｮ莉悶√Α繝繝励槭ャ繝玲焚縺ｯ 1縲ゞsage 縺ｯ None縲￣ool 縺ｯ Managed縲√う繝｡繝ｼ繧ｸ繝輔ぅ繝ｫ繧ｿ縺ｯ Point縲√Α繝繝励槭ャ繝励ヵ繧｣繝ｫ繧ｿ縺ｯ
+ /// None縲√き繝ｩ繝ｼ繧ｭ繝ｼ縺ｯ 0xFFFFFFFFｼ亥ｮ悟ｨ縺ｪ繧矩ｻ偵ｒ騾城℃ｼ峨↓縺ｪ繧九
+ ///
+ /// Direct3D9 繝繝舌う繧ｹ縲
+ /// 菴懈仙縺ｮ繝薙ャ繝医槭ャ繝励
+ /// 繝繧ｯ繧ｹ繝√Ε縺ｮ繝輔か繝ｼ繝槭ャ繝医
+ /// 繝繧ｯ繧ｹ繝√Ε縺ｮ菴懈舌↓螟ｱ謨励＠縺ｾ縺励◆縲
+ public CTexture(Device device, Bitmap bitmap, Format format)
+ : this()
+ {
+ try
+ {
+ this.Format = format;
+ this.sz逕ｻ蜒上し繧､繧ｺ = new Size(bitmap.Width, bitmap.Height);
+ this.sz繝繧ｯ繧ｹ繝√Ε繧ｵ繧､繧ｺ = this.t謖螳壹＆繧後◆繧ｵ繧､繧ｺ繧定ｶ縺医↑縺譛驕ｩ縺ｪ繝繧ｯ繧ｹ繝√Ε繧ｵ繧､繧ｺ繧定ｿ斐☆(device, this.sz逕ｻ蜒上し繧､繧ｺ);
+ this.rc蜈ｨ逕ｻ蜒 = new Rectangle(0, 0, this.sz逕ｻ蜒上し繧､繧ｺ.Width, this.sz逕ｻ蜒上し繧､繧ｺ.Height);
+
+ using (var stream = new MemoryStream())
+ {
+ bitmap.Save(stream, ImageFormat.Bmp);
+ stream.Seek(0L, SeekOrigin.Begin);
+ int colorKey = unchecked((int)0xFF000000);
+ this.texture = Texture.FromStream(device.UnderlyingDevice, stream, this.sz繝繧ｯ繧ｹ繝√Ε繧ｵ繧､繧ｺ.Width, this.sz繝繧ｯ繧ｹ繝√Ε繧ｵ繧､繧ｺ.Height, 1, Usage.None, format, poolvar, Filter.Point, Filter.None, colorKey);
+ }
+ }
+ catch (Exception e)
+ {
+ this.Dispose();
+ throw new CTextureCreateFailedException("繝薙ャ繝医槭ャ繝励°繧峨ｮ繝繧ｯ繧ｹ繝√Ε縺ｮ逕滓舌↓螟ｱ謨励＠縺ｾ縺励◆縲", e);
+ }
+ }
+
+ ///
+ /// 遨ｺ縺ｮ Managed 繝繧ｯ繧ｹ繝√Ε繧剃ｽ懈舌☆繧九
+ /// 繝繧ｯ繧ｹ繝√Ε縺ｮ繧ｵ繧､繧ｺ縺ｯ縲∵欠螳壹＆繧後◆蟶梧悍繧ｵ繧､繧ｺ莉･荳翫√°縺､縲．3D9繝繝舌う繧ｹ縺ｧ逕滓仙庄閭ｽ縺ｪ譛蟆上ｮ繧ｵ繧､繧ｺ縺ｫ閾ｪ蜍慕噪縺ｫ隱ｿ遽縺輔ｌ繧九
+ /// 縺昴ｮ髫帙√ユ繧ｯ繧ｹ繝√Ε縺ｮ隱ｿ遽蠕後ｮ繧ｵ繧､繧ｺ縺ｫ縺ゅｏ縺帙◆逕ｻ蜒上ｮ諡｡螟ｧ邵ｮ蟆上ｯ陦後ｏ縺ｪ縺縲
+ /// 繝繧ｯ繧ｹ繝√Ε縺ｮ繝繧ｯ繧ｻ繝ｫ繝繝ｼ繧ｿ縺ｯ譛ｪ蛻晄悄蛹悶ゑｼ医♀縺昴ｉ縺上ざ繝溘ョ繝ｼ繧ｿ縺悟･縺｣縺溘∪縺ｾ縲ゑｼ
+ /// 縺昴ｮ莉悶√Α繝繝励槭ャ繝玲焚縺ｯ 1縲ゞsage 縺ｯ None縲√う繝｡繝ｼ繧ｸ繝輔ぅ繝ｫ繧ｿ縺ｯ Point縲√Α繝繝励槭ャ繝励ヵ繧｣繝ｫ繧ｿ縺ｯ None縲
+ /// 繧ｫ繝ｩ繝ｼ繧ｭ繝ｼ縺ｯ 0x00000000ｼ磯城℃縺励↑縺ｼ峨↓縺ｪ繧九
+ ///
+ /// Direct3D9 繝繝舌う繧ｹ縲
+ /// 繝繧ｯ繧ｹ繝√Ε縺ｮ蟷ｼ亥ｸ梧悍蛟､ｼ峨
+ /// 繝繧ｯ繧ｹ繝√Ε縺ｮ鬮倥＆ｼ亥ｸ梧悍蛟､ｼ峨
+ /// 繝繧ｯ繧ｹ繝√Ε縺ｮ繝輔か繝ｼ繝槭ャ繝医
+ /// 繝繧ｯ繧ｹ繝√Ε縺ｮ菴懈舌↓螟ｱ謨励＠縺ｾ縺励◆縲
+ public CTexture(Device device, int n蟷, int n鬮倥＆, Format format)
+ : this(device, n蟷, n鬮倥＆, format, Pool.Managed)
+ {
+ }
+
+ ///
+ /// 謖螳壹＆繧後◆逕ｻ蜒上ヵ繧｡繧､繝ｫ縺九ｉ Managed 繝繧ｯ繧ｹ繝√Ε繧剃ｽ懈舌☆繧九
+ /// 蛻ｩ逕ｨ蜿ｯ閭ｽ縺ｪ逕ｻ蜒丞ｽ｢蠑上ｯ縲。MP, JPG, PNG, TGA, DDS, PPM, DIB, HDR, PFM 縺ｮ縺縺壹ｌ縺九
+ ///
+ /// Direct3D9 繝繝舌う繧ｹ縲
+ /// 逕ｻ蜒上ヵ繧｡繧､繝ｫ蜷阪
+ /// 繝繧ｯ繧ｹ繝√Ε縺ｮ繝輔か繝ｼ繝槭ャ繝医
+ /// 逕ｻ蜒上ｮ鮟抵ｼ0xFFFFFFFFｼ峨ｒ騾城℃縺輔○繧九↑繧 true縲
+ /// 繝繧ｯ繧ｹ繝√Ε縺ｮ菴懈舌↓螟ｱ謨励＠縺ｾ縺励◆縲
+ public CTexture(Device device, string str繝輔ぃ繧､繝ｫ蜷, Format format, bool b鮟偵ｒ騾城℃縺吶ｋ)
+ : this(device, str繝輔ぃ繧､繝ｫ蜷, format, b鮟偵ｒ騾城℃縺吶ｋ, Pool.Managed)
+ {
+ }
+ public CTexture(Device device, byte[] txData, Format format, bool b鮟偵ｒ騾城℃縺吶ｋ)
+ : this(device, txData, format, b鮟偵ｒ騾城℃縺吶ｋ, Pool.Managed)
+ {
+ }
+ public CTexture(Device device, Bitmap bitmap, Format format, bool b鮟偵ｒ騾城℃縺吶ｋ)
+ : this(device, bitmap, format, b鮟偵ｒ騾城℃縺吶ｋ, Pool.Managed)
+ {
+ }
+
+ ///
+ /// 遨ｺ縺ｮ繝繧ｯ繧ｹ繝√Ε繧剃ｽ懈舌☆繧九
+ /// 繝繧ｯ繧ｹ繝√Ε縺ｮ繧ｵ繧､繧ｺ縺ｯ縲∵欠螳壹＆繧後◆蟶梧悍繧ｵ繧､繧ｺ莉･荳翫√°縺､縲．3D9繝繝舌う繧ｹ縺ｧ逕滓仙庄閭ｽ縺ｪ譛蟆上ｮ繧ｵ繧､繧ｺ縺ｫ閾ｪ蜍慕噪縺ｫ隱ｿ遽縺輔ｌ繧九
+ /// 縺昴ｮ髫帙√ユ繧ｯ繧ｹ繝√Ε縺ｮ隱ｿ遽蠕後ｮ繧ｵ繧､繧ｺ縺ｫ縺ゅｏ縺帙◆逕ｻ蜒上ｮ諡｡螟ｧ邵ｮ蟆上ｯ陦後ｏ縺ｪ縺縲
+ /// 繝繧ｯ繧ｹ繝√Ε縺ｮ繝繧ｯ繧ｻ繝ｫ繝繝ｼ繧ｿ縺ｯ譛ｪ蛻晄悄蛹悶ゑｼ医♀縺昴ｉ縺上ざ繝溘ョ繝ｼ繧ｿ縺悟･縺｣縺溘∪縺ｾ縲ゑｼ
+ /// 縺昴ｮ莉悶√Α繝繝励槭ャ繝玲焚縺ｯ 1縲ゞsage 縺ｯ None縲√う繝｡繝ｼ繧ｸ繝輔ぅ繝ｫ繧ｿ縺ｯ Point縲√Α繝繝励槭ャ繝励ヵ繧｣繝ｫ繧ｿ縺ｯ None縲
+ /// 繧ｫ繝ｩ繝ｼ繧ｭ繝ｼ縺ｯ 0x00000000ｼ磯城℃縺励↑縺ｼ峨↓縺ｪ繧九
+ ///
+ /// Direct3D9 繝繝舌う繧ｹ縲
+ /// 繝繧ｯ繧ｹ繝√Ε縺ｮ蟷ｼ亥ｸ梧悍蛟､ｼ峨
+ /// 繝繧ｯ繧ｹ繝√Ε縺ｮ鬮倥＆ｼ亥ｸ梧悍蛟､ｼ峨
+ /// 繝繧ｯ繧ｹ繝√Ε縺ｮ繝輔か繝ｼ繝槭ャ繝医
+ /// 繝繧ｯ繧ｹ繝√Ε縺ｮ邂｡逅譁ｹ豕輔
+ /// 繝繧ｯ繧ｹ繝√Ε縺ｮ菴懈舌↓螟ｱ謨励＠縺ｾ縺励◆縲
+ public CTexture(Device device, int n蟷, int n鬮倥＆, Format format, Pool pool)
+ : this(device, n蟷, n鬮倥＆, format, pool, Usage.None)
+ {
+ }
+
+ public CTexture(Device device, int n蟷, int n鬮倥＆, Format format, Pool pool, Usage usage)
+ : this()
+ {
+ try
+ {
+ this.Format = format;
+ this.sz逕ｻ蜒上し繧､繧ｺ = new Size(n蟷, n鬮倥＆);
+ this.sz繝繧ｯ繧ｹ繝√Ε繧ｵ繧､繧ｺ = this.t謖螳壹＆繧後◆繧ｵ繧､繧ｺ繧定ｶ縺医↑縺譛驕ｩ縺ｪ繝繧ｯ繧ｹ繝√Ε繧ｵ繧､繧ｺ繧定ｿ斐☆(device, this.sz逕ｻ蜒上し繧､繧ｺ);
+ this.rc蜈ｨ逕ｻ蜒 = new Rectangle(0, 0, this.sz逕ｻ蜒上し繧､繧ｺ.Width, this.sz逕ｻ蜒上し繧､繧ｺ.Height);
+
+ using (var bitmap = new Bitmap(1, 1))
+ {
+ using (var graphics = Graphics.FromImage(bitmap))
+ {
+ graphics.FillRectangle(Brushes.Black, 0, 0, 1, 1);
+ }
+ using (var stream = new MemoryStream())
+ {
+ bitmap.Save(stream, ImageFormat.Bmp);
+ stream.Seek(0L, SeekOrigin.Begin);
+#if TEST_Direct3D9Ex
+ pool = poolvar;
+#endif
+ // 荳ｭ縺ｧ譖ｴ縺ｫ繝｡繝｢繝ｪ隱ｭ縺ｿ霎ｼ縺ｿ縺礼峩縺励※縺縺ｦ辟｡鬧縺ｪ縺ｮ縺ｧ縲ヾtream繧剃ｽｿ縺縺ｮ縺ｯ豁｢繧√◆縺縺ｨ縺薙ｍ
+ this.texture = Texture.FromStream(device.UnderlyingDevice, stream, n蟷, n鬮倥＆, 1, usage, format, pool, Filter.Point, Filter.None, 0);
+ }
+ }
+ }
+ catch
+ {
+ this.Dispose();
+ throw new CTextureCreateFailedException(string.Format("繝繧ｯ繧ｹ繝√Ε縺ｮ逕滓舌↓螟ｱ謨励＠縺ｾ縺励◆縲\n({0}x{1}, {2})", n蟷, n鬮倥＆, format));
+ }
+ }
+
+ ///
+ /// 逕ｻ蜒上ヵ繧｡繧､繝ｫ縺九ｉ繝繧ｯ繧ｹ繝√Ε繧堤函謌舌☆繧九
+ /// 蛻ｩ逕ｨ蜿ｯ閭ｽ縺ｪ逕ｻ蜒丞ｽ｢蠑上ｯ縲。MP, JPG, PNG, TGA, DDS, PPM, DIB, HDR, PFM 縺ｮ縺縺壹ｌ縺九
+ /// 繝繧ｯ繧ｹ繝√Ε縺ｮ繧ｵ繧､繧ｺ縺ｯ縲∫判蜒上ｮ繧ｵ繧､繧ｺ莉･荳翫√°縺､縲．3D9繝繝舌う繧ｹ縺ｧ逕滓仙庄閭ｽ縺ｪ譛蟆上ｮ繧ｵ繧､繧ｺ縺ｫ閾ｪ蜍慕噪縺ｫ隱ｿ遽縺輔ｌ繧九
+ /// 縺昴ｮ髫帙√ユ繧ｯ繧ｹ繝√Ε縺ｮ隱ｿ遽蠕後ｮ繧ｵ繧､繧ｺ縺ｫ縺ゅｏ縺帙◆逕ｻ蜒上ｮ諡｡螟ｧ邵ｮ蟆上ｯ陦後ｏ縺ｪ縺縲
+ /// 縺昴ｮ莉悶√Α繝繝励槭ャ繝玲焚縺ｯ 1縲ゞsage 縺ｯ None縲√う繝｡繝ｼ繧ｸ繝輔ぅ繝ｫ繧ｿ縺ｯ Point縲√Α繝繝励槭ャ繝励ヵ繧｣繝ｫ繧ｿ縺ｯ None 縺ｫ縺ｪ繧九
+ ///
+ /// Direct3D9 繝繝舌う繧ｹ縲
+ /// 逕ｻ蜒上ヵ繧｡繧､繝ｫ蜷阪
+ /// 繝繧ｯ繧ｹ繝√Ε縺ｮ繝輔か繝ｼ繝槭ャ繝医
+ /// 逕ｻ蜒上ｮ鮟抵ｼ0xFFFFFFFFｼ峨ｒ騾城℃縺輔○繧九↑繧 true縲
+ /// 繝繧ｯ繧ｹ繝√Ε縺ｮ邂｡逅譁ｹ豕輔
+ /// 繝繧ｯ繧ｹ繝√Ε縺ｮ菴懈舌↓螟ｱ謨励＠縺ｾ縺励◆縲
+ public CTexture(Device device, string str繝輔ぃ繧､繝ｫ蜷, Format format, bool b鮟偵ｒ騾城℃縺吶ｋ, Pool pool)
+ : this()
+ {
+ MakeTexture(device, str繝輔ぃ繧､繝ｫ蜷, format, b鮟偵ｒ騾城℃縺吶ｋ, pool);
+ }
+ public void MakeTexture(Device device, string str繝輔ぃ繧､繝ｫ蜷, Format format, bool b鮟偵ｒ騾城℃縺吶ｋ, Pool pool)
+ {
+ if (!File.Exists(str繝輔ぃ繧､繝ｫ蜷)) // #27122 2012.1.13 from: ImageInformation 縺ｧ縺ｯ FileNotFound 萓句､悶ｯ霑斐▲縺ｦ縺薙↑縺縺ｮ縺ｧ縲√％縺薙〒閾ｪ蛻縺ｧ繝√ぉ繝繧ｯ縺吶ｋ縲ゅｏ縺九ｊ繧縺吶＞繝ｭ繧ｰ縺ｮ縺溘ａ縺ｫ縲
+ throw new FileNotFoundException(string.Format("繝輔ぃ繧､繝ｫ縺悟ｭ伜惠縺励∪縺帙ｓ縲\n[{0}]", str繝輔ぃ繧､繝ｫ蜷));
+
+ Byte[] _txData = File.ReadAllBytes(str繝輔ぃ繧､繝ｫ蜷);
+ MakeTexture(device, _txData, format, b鮟偵ｒ騾城℃縺吶ｋ, pool);
+ }
+
+ public CTexture(Device device, byte[] txData, Format format, bool b鮟偵ｒ騾城℃縺吶ｋ, Pool pool)
+ : this()
+ {
+ MakeTexture(device, txData, format, b鮟偵ｒ騾城℃縺吶ｋ, pool);
+ }
+ public void MakeTexture(Device device, byte[] txData, Format format, bool b鮟偵ｒ騾城℃縺吶ｋ, Pool pool)
+ {
+ try
+ {
+ var information = ImageInformation.FromMemory(txData);
+ this.Format = format;
+ this.sz逕ｻ蜒上し繧､繧ｺ = new Size(information.Width, information.Height);
+ this.rc蜈ｨ逕ｻ蜒 = new Rectangle(0, 0, this.sz逕ｻ蜒上し繧､繧ｺ.Width, this.sz逕ｻ蜒上し繧､繧ｺ.Height);
+ int colorKey = (b鮟偵ｒ騾城℃縺吶ｋ) ? unchecked((int)0xFF000000) : 0;
+ this.sz繝繧ｯ繧ｹ繝√Ε繧ｵ繧､繧ｺ = this.t謖螳壹＆繧後◆繧ｵ繧､繧ｺ繧定ｶ縺医↑縺譛驕ｩ縺ｪ繝繧ｯ繧ｹ繝√Ε繧ｵ繧､繧ｺ繧定ｿ斐☆(device, this.sz逕ｻ蜒上し繧､繧ｺ);
+#if TEST_Direct3D9Ex
+ pool = poolvar;
+#endif
+ // lock ( lockobj )
+ // {
+ //Trace.TraceInformation( "CTexture() start: " );
+ this.texture = Texture.FromMemory(device.UnderlyingDevice, txData, this.sz逕ｻ蜒上し繧､繧ｺ.Width, this.sz逕ｻ蜒上し繧､繧ｺ.Height, 1, Usage.None, format, pool, Filter.Point, Filter.None, colorKey);
+ //Trace.TraceInformation( "CTexture() end: " );
+ // }
+ }
+ catch
+ {
+ this.Dispose();
+ // throw new CTextureCreateFailedException( string.Format( "繝繧ｯ繧ｹ繝√Ε縺ｮ逕滓舌↓螟ｱ謨励＠縺ｾ縺励◆縲\n{0}", str繝輔ぃ繧､繝ｫ蜷 ) );
+ throw new CTextureCreateFailedException(string.Format("繝繧ｯ繧ｹ繝√Ε縺ｮ逕滓舌↓螟ｱ謨励＠縺ｾ縺励◆縲\n"));
+ }
+ }
+
+ public CTexture(Device device, Bitmap bitmap, Format format, bool b鮟偵ｒ騾城℃縺吶ｋ, Pool pool)
+ : this()
+ {
+ MakeTexture(device, bitmap, format, b鮟偵ｒ騾城℃縺吶ｋ, pool);
+ }
+ public void MakeTexture(Device device, Bitmap bitmap, Format format, bool b鮟偵ｒ騾城℃縺吶ｋ, Pool pool)
+ {
+ try
+ {
+ this.Format = format;
+ this.sz逕ｻ蜒上し繧､繧ｺ = new Size(bitmap.Width, bitmap.Height);
+ this.rc蜈ｨ逕ｻ蜒 = new Rectangle(0, 0, this.sz逕ｻ蜒上し繧､繧ｺ.Width, this.sz逕ｻ蜒上し繧､繧ｺ.Height);
+ int colorKey = (b鮟偵ｒ騾城℃縺吶ｋ) ? unchecked((int)0xFF000000) : 0;
+ this.sz繝繧ｯ繧ｹ繝√Ε繧ｵ繧､繧ｺ = this.t謖螳壹＆繧後◆繧ｵ繧､繧ｺ繧定ｶ縺医↑縺譛驕ｩ縺ｪ繝繧ｯ繧ｹ繝√Ε繧ｵ繧､繧ｺ繧定ｿ斐☆(device, this.sz逕ｻ蜒上し繧､繧ｺ);
+#if TEST_Direct3D9Ex
+ pool = poolvar;
+#endif
+ //Trace.TraceInformation( "CTExture() start: " );
+ unsafe // Bitmap縺ｮ蜀驛ｨ繝繝ｼ繧ｿ(a8r8g8b8)繧定ｪ蜑阪〒繧ｴ繝ｪ繧ｴ繝ｪ繧ｳ繝斐ｼ縺吶ｋ
+ {
+ int tw =
+#if TEST_Direct3D9Ex
+ 288; // 32縺ｮ蛟肴焚縺ｫ縺吶ｋ(繧ｰ繝ｩ繝輔↓繧医▲縺ｦ縺ｯ2縺ｮ縺ｹ縺堺ｹ励↓縺励↑縺縺ｨ繝繝｡縺九ｂ)
+#else
+ this.sz逕ｻ蜒上し繧､繧ｺ.Width;
+#endif
+#if TEST_Direct3D9Ex
+ this.texture = new Texture( device, tw, this.sz逕ｻ蜒上し繧､繧ｺ.Height, 1, Usage.Dynamic, format, Pool.Default );
+#else
+ this.texture = new Texture(device.UnderlyingDevice, this.sz逕ｻ蜒上し繧､繧ｺ.Width, this.sz逕ｻ蜒上し繧､繧ｺ.Height, 1, Usage.None, format, pool);
+#endif
+ BitmapData srcBufData = bitmap.LockBits(new Rectangle(0, 0, this.sz逕ｻ蜒上し繧､繧ｺ.Width, this.sz逕ｻ蜒上し繧､繧ｺ.Height), ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb);
+ DataRectangle destDataRectangle = texture.LockRectangle(0, LockFlags.Discard); // None
+#if TEST_Direct3D9Ex
+ byte[] filldata = null;
+ if ( tw > this.sz逕ｻ蜒上し繧､繧ｺ.Width )
+ {
+ filldata = new byte[ (tw - this.sz逕ｻ蜒上し繧､繧ｺ.Width) * 4 ];
+ }
+ for ( int y = 0; y < this.sz逕ｻ蜒上し繧､繧ｺ.Height; y++ )
+ {
+ IntPtr src_scan0 = (IntPtr) ( (Int64) srcBufData.Scan0 + y * srcBufData.Stride );
+ destDataRectangle.Data.WriteRange( src_scan0, this.sz逕ｻ蜒上し繧､繧ｺ.Width * 4 );
+ if ( tw > this.sz逕ｻ蜒上し繧､繧ｺ.Width )
+ {
+ destDataRectangle.Data.WriteRange( filldata );
+ }
+ }
+#else
+ IntPtr src_scan0 = (IntPtr)((Int64)srcBufData.Scan0);
+ destDataRectangle.Data.WriteRange(src_scan0, this.sz逕ｻ蜒上し繧､繧ｺ.Width * 4 * this.sz逕ｻ蜒上し繧､繧ｺ.Height);
+#endif
+ texture.UnlockRectangle(0);
+ bitmap.UnlockBits(srcBufData);
+ }
+ //Trace.TraceInformation( "CTExture() End: " );
+ }
+ catch
+ {
+ this.Dispose();
+ // throw new CTextureCreateFailedException( string.Format( "繝繧ｯ繧ｹ繝√Ε縺ｮ逕滓舌↓螟ｱ謨励＠縺ｾ縺励◆縲\n{0}", str繝輔ぃ繧､繝ｫ蜷 ) );
+ throw new CTextureCreateFailedException(string.Format("繝繧ｯ繧ｹ繝√Ε縺ｮ逕滓舌↓螟ｱ謨励＠縺ｾ縺励◆縲\n"));
+ }
+ }
+ // 繝｡繧ｽ繝繝
+
+ // 2016.11.10 kairera0467 諡｡蠑ｵ
+ // Rectangle繧剃ｽｿ縺蝣ｴ蜷医∝ｺｧ讓呵ｪｿ謨ｴ縺ｮ縺溘ａ縺ｫ繝繧ｯ繧ｹ繝√Ε繧ｵ繧､繧ｺ縺ｮ蛟､繧偵◎縺ｮ縺ｾ縺ｾ菴ｿ縺縺ｨ縺ｾ縺壹＞縺薙→縺ｫ縺ｪ繧九◆繧√ヽectragle縺九ｉ蟷繧貞叙蠕励＠縺ｦ隱ｿ謨ｴ繧偵☆繧九
+ public void t2D荳ｭ蠢蝓ｺ貅匁緒逕ｻ(Device device, int x, int y)
+ {
+ this.t2D謠冗判(device, x - (this.sz繝繧ｯ繧ｹ繝√Ε繧ｵ繧､繧ｺ.Width / 2), y - (this.sz繝繧ｯ繧ｹ繝√Ε繧ｵ繧､繧ｺ.Height / 2), 1f, this.rc蜈ｨ逕ｻ蜒);
+ }
+ public void t2D荳ｭ蠢蝓ｺ貅匁緒逕ｻ(Device device, int x, int y, Rectangle rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺)
+ {
+ this.t2D謠冗判(device, x - (rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺.Width / 2), y - (rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺.Height / 2), 1f, rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺);
+ }
+ public void t2D荳ｭ蠢蝓ｺ貅匁緒逕ｻ(Device device, float x, float y)
+ {
+ this.t2D謠冗判(device, (int)x - (this.sz繝繧ｯ繧ｹ繝√Ε繧ｵ繧､繧ｺ.Width / 2), (int)y - (this.sz繝繧ｯ繧ｹ繝√Ε繧ｵ繧､繧ｺ.Height / 2), 1f, this.rc蜈ｨ逕ｻ蜒);
+ }
+ public void t2D荳ｭ蠢蝓ｺ貅匁緒逕ｻ(Device device, float x, float y, Rectangle rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺)
+ {
+ this.t2D謠冗判(device, (int)x - (rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺.Width / 2), (int)y - (rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺.Height / 2), 1.0f, rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺);
+ }
+ public void t2D荳ｭ蠢蝓ｺ貅匁緒逕ｻ(Device device, float x, float y, float depth, Rectangle rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺)
+ {
+ this.t2D謠冗判(device, (int)x - (rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺.Width / 2), (int)y - (rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺.Height / 2), depth, rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺);
+ }
+
+ // 荳九ｒ蝓ｺ貅悶↓縺励※謠冗判縺吶ｋ(諡｡螟ｧ邇閠諷ｮ)繝｡繧ｽ繝繝峨ｒ霑ｽ蜉縲 (AioiLight)
+ public void t2D諡｡螟ｧ邇閠諷ｮ荳句渕貅匁緒逕ｻ(Device device, int x, int y)
+ {
+ this.t2D謠冗判(device, x, y - (sz繝繧ｯ繧ｹ繝√Ε繧ｵ繧､繧ｺ.Height * this.vc諡｡螟ｧ邵ｮ蟆丞咲紫.Y), 1f, this.rc蜈ｨ逕ｻ蜒);
+ }
+ public void t2D諡｡螟ｧ邇閠諷ｮ荳句渕貅匁緒逕ｻ(Device device, int x, int y, Rectangle rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺)
+ {
+ this.t2D謠冗判(device, x, y - (rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺.Height * this.vc諡｡螟ｧ邵ｮ蟆丞咲紫.Y), 1f, rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺);
+ }
+ public void t2D諡｡螟ｧ邇閠諷ｮ荳倶ｸｭ蠢蝓ｺ貅匁緒逕ｻ(Device device, int x, int y)
+ {
+ this.t2D謠冗判(device, x - (this.sz繝繧ｯ繧ｹ繝√Ε繧ｵ繧､繧ｺ.Width / 2 * this.vc諡｡螟ｧ邵ｮ蟆丞咲紫.X), y - (sz繝繧ｯ繧ｹ繝√Ε繧ｵ繧､繧ｺ.Height * this.vc諡｡螟ｧ邵ｮ蟆丞咲紫.Y), 1f, this.rc蜈ｨ逕ｻ蜒);
+ }
+ public void t2D諡｡螟ｧ邇閠諷ｮ荳倶ｸｭ蠢蝓ｺ貅匁緒逕ｻ(Device device, float x, float y)
+ {
+ this.t2D諡｡螟ｧ邇閠諷ｮ荳倶ｸｭ蠢蝓ｺ貅匁緒逕ｻ(device, (int)x, (int)y);
+ }
+
+ public void t2D諡｡螟ｧ邇閠諷ｮ荳倶ｸｭ蠢蝓ｺ貅匁緒逕ｻ(Device device, int x, int y, Rectangle rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺)
+ {
+ this.t2D謠冗判(device, x - ((rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺.Width / 2)), y - (rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺.Height * this.vc諡｡螟ｧ邵ｮ蟆丞咲紫.Y), 1f, rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺);
+ }
+ public void t2D諡｡螟ｧ邇閠諷ｮ荳倶ｸｭ蠢蝓ｺ貅匁緒逕ｻ(Device device, float x, float y, Rectangle rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺)
+ {
+ this.t2D諡｡螟ｧ邇閠諷ｮ荳倶ｸｭ蠢蝓ｺ貅匁緒逕ｻ(device, (int)x, (int)y, rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺);
+ }
+ public void t2D荳倶ｸｭ螟ｮ蝓ｺ貅匁緒逕ｻ(Device device, int x, int y)
+ {
+ this.t2D謠冗判(device, x - (this.sz繝繧ｯ繧ｹ繝√Ε繧ｵ繧､繧ｺ.Width / 2), y - (sz繝繧ｯ繧ｹ繝√Ε繧ｵ繧､繧ｺ.Height), this.rc蜈ｨ逕ｻ蜒);
+ }
+ public void t2D荳倶ｸｭ螟ｮ蝓ｺ貅匁緒逕ｻ(Device device, int x, int y, Rectangle rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺)
+ {
+ this.t2D謠冗判(device, x - (rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺.Width / 2), y - (rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺.Height), rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺);
+ //this.t2D謠冗判(devicek x, y, rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺;
+ }
+
+
+ public void t2D諡｡螟ｧ邇閠諷ｮ荳ｭ螟ｮ蝓ｺ貅匁緒逕ｻ(Device device, int x, int y)
+ {
+ this.t2D謠冗判(device, x - (this.sz繝繧ｯ繧ｹ繝√Ε繧ｵ繧､繧ｺ.Width / 2 * this.vc諡｡螟ｧ邵ｮ蟆丞咲紫.X), y - (sz繝繧ｯ繧ｹ繝√Ε繧ｵ繧､繧ｺ.Height / 2 * this.vc諡｡螟ｧ邵ｮ蟆丞咲紫.Y), 1f, this.rc蜈ｨ逕ｻ蜒);
+ }
+ public void t2D諡｡螟ｧ邇閠諷ｮ荳ｭ螟ｮ蝓ｺ貅匁緒逕ｻ(Device device, int x, int y, RectangleF rc)
+ {
+ this.t2D謠冗判(device, x - (rc.Width / 2 * this.vc諡｡螟ｧ邵ｮ蟆丞咲紫.X), y - (rc.Height / 2 * this.vc諡｡螟ｧ邵ｮ蟆丞咲紫.Y), 1f, rc);
+ }
+ public void t2D諡｡螟ｧ邇閠諷ｮ荳贋ｸｭ螟ｮ蝓ｺ貅匁緒逕ｻ(Device device, int x, int y, RectangleF rc)
+ {
+ this.t2D謠冗判(device, x - (rc.Width / 2 * this.vc諡｡螟ｧ邵ｮ蟆丞咲紫.X), y, 1f, rc);
+ }
+ public void t2D諡｡螟ｧ邇閠諷ｮ荳贋ｸｭ螟ｮ蝓ｺ貅匁緒逕ｻ(Device device, int x, int y)
+ {
+ this.t2D謠冗判(device, x - (rc蜈ｨ逕ｻ蜒.Width / 2 * this.vc諡｡螟ｧ邵ｮ蟆丞咲紫.X), y, 1f, rc蜈ｨ逕ｻ蜒);
+ }
+ public void t2D諡｡螟ｧ邇閠諷ｮ荳ｭ螟ｮ蝓ｺ貅匁緒逕ｻ(Device device, float x, float y)
+ {
+ this.t2D謠冗判(device, x - (this.sz繝繧ｯ繧ｹ繝√Ε繧ｵ繧､繧ｺ.Width / 2 * this.vc諡｡螟ｧ邵ｮ蟆丞咲紫.X), y - (sz繝繧ｯ繧ｹ繝√Ε繧ｵ繧､繧ｺ.Height / 2 * this.vc諡｡螟ｧ邵ｮ蟆丞咲紫.Y), 1f, this.rc蜈ｨ逕ｻ蜒);
+ }
+ public void t2D諡｡螟ｧ邇閠諷ｮ荳ｭ螟ｮ蝓ｺ貅匁緒逕ｻ(Device device, float x, float y, RectangleF rc)
+ {
+ this.t2D謠冗判(device, x - (rc.Width / 2 * this.vc諡｡螟ｧ邵ｮ蟆丞咲紫.X), y - (rc.Height / 2 * this.vc諡｡螟ｧ邵ｮ蟆丞咲紫.Y), 1f, rc);
+ }
+ public void t2D諡｡螟ｧ邇閠諷ｮ謠冗判(Device device, RefPnt refpnt, float x, float y)
+ {
+ this.t2D諡｡螟ｧ邇閠諷ｮ謠冗判(device, refpnt, x, y, rc蜈ｨ逕ｻ蜒);
+ }
+ public void t2D諡｡螟ｧ邇閠諷ｮ謠冗判(Device device, RefPnt refpnt, float x, float y, Rectangle rect)
+ {
+ this.t2D諡｡螟ｧ邇閠諷ｮ謠冗判(device, refpnt, x, y, 1f, rect);
+ }
+ public void t2D諡｡螟ｧ邇閠諷ｮ謠冗判(Device device, RefPnt refpnt, float x, float y, float depth, Rectangle rect)
+ {
+ switch (refpnt)
+ {
+ case RefPnt.UpLeft:
+ this.t2D謠冗判(device, x, y, depth, rect);
+ break;
+ case RefPnt.Up:
+ this.t2D謠冗判(device, x - (rect.Width / 2 * this.vc諡｡螟ｧ邵ｮ蟆丞咲紫.X), y, depth, rect);
+ break;
+ case RefPnt.UpRight:
+ this.t2D謠冗判(device, x - rect.Width * this.vc諡｡螟ｧ邵ｮ蟆丞咲紫.X, y, depth, rect);
+ break;
+ case RefPnt.Left:
+ this.t2D謠冗判(device, x, y - (rect.Height / 2 * this.vc諡｡螟ｧ邵ｮ蟆丞咲紫.Y), depth, rect);
+ break;
+ case RefPnt.Center:
+ this.t2D謠冗判(device, x - (rect.Width / 2 * this.vc諡｡螟ｧ邵ｮ蟆丞咲紫.X), y - (rect.Height / 2 * this.vc諡｡螟ｧ邵ｮ蟆丞咲紫.Y), depth, rect);
+ break;
+ case RefPnt.Right:
+ this.t2D謠冗判(device, x - rect.Width * this.vc諡｡螟ｧ邵ｮ蟆丞咲紫.X, y - (rect.Height / 2 * this.vc諡｡螟ｧ邵ｮ蟆丞咲紫.Y), depth, rect);
+ break;
+ case RefPnt.DownLeft:
+ this.t2D謠冗判(device, x, y - rect.Height * this.vc諡｡螟ｧ邵ｮ蟆丞咲紫.Y, depth, rect);
+ break;
+ case RefPnt.Down:
+ this.t2D謠冗判(device, x - (rect.Width / 2 * this.vc諡｡螟ｧ邵ｮ蟆丞咲紫.X), y - rect.Height * this.vc諡｡螟ｧ邵ｮ蟆丞咲紫.Y, depth, rect);
+ break;
+ case RefPnt.DownRight:
+ this.t2D謠冗判(device, x - rect.Width * this.vc諡｡螟ｧ邵ｮ蟆丞咲紫.X, y - rect.Height * this.vc諡｡螟ｧ邵ｮ蟆丞咲紫.Y, depth, rect);
+ break;
+ default:
+ break;
+ }
+
+ }
+
+ public enum RefPnt
+ {
+ UpLeft,
+ Up,
+ UpRight,
+ Left,
+ Center,
+ Right,
+ DownLeft,
+ Down,
+ DownRight,
+ }
+
+ ///
+ /// 繝繧ｯ繧ｹ繝√Ε繧 2D 逕ｻ蜒上→隕九↑縺励※謠冗判縺吶ｋ縲
+ ///
+ /// Direct3D9 繝繝舌う繧ｹ縲
+ /// 謠冗判菴咲ｽｮｼ医ユ繧ｯ繧ｹ繝√Ε縺ｮ蟾ｦ荳贋ｽ咲ｽｮ縺ｮ X 蠎ｧ讓兌dot]ｼ峨
+ /// 謠冗判菴咲ｽｮｼ医ユ繧ｯ繧ｹ繝√Ε縺ｮ蟾ｦ荳贋ｽ咲ｽｮ縺ｮ Y 蠎ｧ讓兌dot]ｼ峨
+ public void t2D謠冗判(Device device, int x, int y)
+ {
+ this.t2D謠冗判(device, x, y, 1f, this.rc蜈ｨ逕ｻ蜒);
+ }
+ public void t2D謠冗判(Device device, int x, int y, RectangleF rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺)
+ {
+ this.t2D謠冗判(device, x, y, 1f, rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺);
+ }
+ public void t2D謠冗判(Device device, float x, float y)
+ {
+ this.t2D謠冗判(device, (int)x, (int)y, 1f, this.rc蜈ｨ逕ｻ蜒);
+ }
+ public void t2D謠冗判(Device device, float x, float y, RectangleF rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺)
+ {
+ this.t2D謠冗判(device, (int)x, (int)y, 1f, rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺);
+ }
+ public void t2D謠冗判(Device device, float x, float y, float depth, RectangleF rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺)
+ {
+ if (this.texture == null)
+ return;
+
+ this.t繝ｬ繝ｳ繝繝ｪ繝ｳ繧ｰ繧ｹ繝繝ｼ繝医ｮ險ｭ螳(device);
+
+ if (this.fZ霆ｸ荳ｭ蠢蝗櫁ｻ｢ == 0f)
+ {
+ #region [ (A) 蝗櫁ｻ｢縺ｪ縺 ]
+ //-----------------
+ float f陬懈ｭ｣蛟､X = -0.5f; // -0.5 縺ｯ蠎ｧ讓吶→繝斐け繧ｻ繝ｫ縺ｮ隱､蟾ｮ繧貞精蜿弱☆繧九◆繧√ｮ蠎ｧ讓呵｣懈ｭ｣蛟､縲(MSDN蜿らｧ)
+ float f陬懈ｭ｣蛟､Y = -0.5f; //
+ float w = rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺.Width;
+ float h = rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺.Height;
+ float f蟾ｦU蛟､ = ((float)rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺.Left) / ((float)this.sz繝繧ｯ繧ｹ繝√Ε繧ｵ繧､繧ｺ.Width);
+ float f蜿ｳU蛟､ = ((float)rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺.Right) / ((float)this.sz繝繧ｯ繧ｹ繝√Ε繧ｵ繧､繧ｺ.Width);
+ float f荳碍蛟､ = ((float)rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺.Top) / ((float)this.sz繝繧ｯ繧ｹ繝√Ε繧ｵ繧､繧ｺ.Height);
+ float f荳儀蛟､ = ((float)rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺.Bottom) / ((float)this.sz繝繧ｯ繧ｹ繝√Ε繧ｵ繧､繧ｺ.Height);
+ this.color4.Alpha = ((float)this._opacity) / 255f;
+ int color = this.color4.ToArgb();
+
+ if (this.cvTransformedColoredVertexies == null)
+ this.cvTransformedColoredVertexies = new TransformedColoredTexturedVertex[4];
+
+ // #27122 2012.1.13 from: 莉･荳九√槭ロ繝ｼ繧ｸ繝峨が繝悶ず繧ｧ繧ｯ繝茨ｼ茨ｼ昴ぎ繝吶ｼ繧ｸｼ峨ｮ驥冗肇繧呈椛縺医ｋ縺溘ａ縲］ew 縺ｯ菴ｿ繧上★縲√Γ繝ｳ繝舌↓蛟､繧抵ｼ代▽縺壹▽逶ｴ謗･荳頑嶌縺阪☆繧九
+
+ this.cvTransformedColoredVertexies[0].Position.X = x + f陬懈ｭ｣蛟､X;
+ this.cvTransformedColoredVertexies[0].Position.Y = y + f陬懈ｭ｣蛟､Y;
+ this.cvTransformedColoredVertexies[0].Position.Z = depth;
+ this.cvTransformedColoredVertexies[0].Position.W = 1.0f;
+ this.cvTransformedColoredVertexies[0].Color = color;
+ this.cvTransformedColoredVertexies[0].TextureCoordinates.X = f蟾ｦU蛟､;
+ this.cvTransformedColoredVertexies[0].TextureCoordinates.Y = f荳碍蛟､;
+
+ this.cvTransformedColoredVertexies[1].Position.X = (x + (w * this.vc諡｡螟ｧ邵ｮ蟆丞咲紫.X)) + f陬懈ｭ｣蛟､X;
+ this.cvTransformedColoredVertexies[1].Position.Y = y + f陬懈ｭ｣蛟､Y;
+ this.cvTransformedColoredVertexies[1].Position.Z = depth;
+ this.cvTransformedColoredVertexies[1].Position.W = 1.0f;
+ this.cvTransformedColoredVertexies[1].Color = color;
+ this.cvTransformedColoredVertexies[1].TextureCoordinates.X = f蜿ｳU蛟､;
+ this.cvTransformedColoredVertexies[1].TextureCoordinates.Y = f荳碍蛟､;
+
+ this.cvTransformedColoredVertexies[2].Position.X = x + f陬懈ｭ｣蛟､X;
+ this.cvTransformedColoredVertexies[2].Position.Y = (y + (h * this.vc諡｡螟ｧ邵ｮ蟆丞咲紫.Y)) + f陬懈ｭ｣蛟､Y;
+ this.cvTransformedColoredVertexies[2].Position.Z = depth;
+ this.cvTransformedColoredVertexies[2].Position.W = 1.0f;
+ this.cvTransformedColoredVertexies[2].Color = color;
+ this.cvTransformedColoredVertexies[2].TextureCoordinates.X = f蟾ｦU蛟､;
+ this.cvTransformedColoredVertexies[2].TextureCoordinates.Y = f荳儀蛟､;
+
+ this.cvTransformedColoredVertexies[3].Position.X = (x + (w * this.vc諡｡螟ｧ邵ｮ蟆丞咲紫.X)) + f陬懈ｭ｣蛟､X;
+ this.cvTransformedColoredVertexies[3].Position.Y = (y + (h * this.vc諡｡螟ｧ邵ｮ蟆丞咲紫.Y)) + f陬懈ｭ｣蛟､Y;
+ this.cvTransformedColoredVertexies[3].Position.Z = depth;
+ this.cvTransformedColoredVertexies[3].Position.W = 1.0f;
+ this.cvTransformedColoredVertexies[3].Color = color;
+ this.cvTransformedColoredVertexies[3].TextureCoordinates.X = f蜿ｳU蛟､;
+ this.cvTransformedColoredVertexies[3].TextureCoordinates.Y = f荳儀蛟､;
+
+ device.SetTexture(0, this.texture);
+ device.VertexFormat = TransformedColoredTexturedVertex.Format;
+ device.DrawUserPrimitives(PrimitiveType.TriangleStrip, 0, 2, in this.cvTransformedColoredVertexies);
+ //-----------------
+ #endregion
+ }
+ else
+ {
+ #region [ (B) 蝗櫁ｻ｢縺ゅｊ ]
+ //-----------------
+ float f陬懈ｭ｣蛟､X = ((rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺.Width % 2) == 0) ? -0.5f : 0f; // -0.5 縺ｯ蠎ｧ讓吶→繝斐け繧ｻ繝ｫ縺ｮ隱､蟾ｮ繧貞精蜿弱☆繧九◆繧√ｮ蠎ｧ讓呵｣懈ｭ｣蛟､縲(MSDN蜿らｧ)
+ float f陬懈ｭ｣蛟､Y = ((rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺.Height % 2) == 0) ? -0.5f : 0f; // 3Dｼ亥屓霆｢縺吶ｋｼ峨↑繧芽｣懈ｭ｣縺ｯ縺繧峨↑縺縲
+ float f荳ｭ螟ｮX = ((float)rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺.Width) / 2f;
+ float f荳ｭ螟ｮY = ((float)rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺.Height) / 2f;
+ float f蟾ｦU蛟､ = ((float)rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺.Left) / ((float)this.sz繝繧ｯ繧ｹ繝√Ε繧ｵ繧､繧ｺ.Width);
+ float f蜿ｳU蛟､ = ((float)rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺.Right) / ((float)this.sz繝繧ｯ繧ｹ繝√Ε繧ｵ繧､繧ｺ.Width);
+ float f荳碍蛟､ = ((float)rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺.Top) / ((float)this.sz繝繧ｯ繧ｹ繝√Ε繧ｵ繧､繧ｺ.Height);
+ float f荳儀蛟､ = ((float)rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺.Bottom) / ((float)this.sz繝繧ｯ繧ｹ繝√Ε繧ｵ繧､繧ｺ.Height);
+ this.color4.Alpha = ((float)this._opacity) / 255f;
+ int color = this.color4.ToArgb();
+
+ if (this.cvPositionColoredVertexies == null)
+ this.cvPositionColoredVertexies = new PositionColoredTexturedVertex[4];
+
+ // #27122 2012.1.13 from: 莉･荳九√槭ロ繝ｼ繧ｸ繝峨が繝悶ず繧ｧ繧ｯ繝茨ｼ茨ｼ昴ぎ繝吶ｼ繧ｸｼ峨ｮ驥冗肇繧呈椛縺医ｋ縺溘ａ縲］ew 縺ｯ菴ｿ繧上★縲√Γ繝ｳ繝舌↓蛟､繧抵ｼ代▽縺壹▽逶ｴ謗･荳頑嶌縺阪☆繧九
+
+ this.cvPositionColoredVertexies[0].Position.X = -f荳ｭ螟ｮX + f陬懈ｭ｣蛟､X;
+ this.cvPositionColoredVertexies[0].Position.Y = f荳ｭ螟ｮY + f陬懈ｭ｣蛟､Y;
+ this.cvPositionColoredVertexies[0].Position.Z = depth;
+ this.cvPositionColoredVertexies[0].Color = color;
+ this.cvPositionColoredVertexies[0].TextureCoordinates.X = f蟾ｦU蛟､;
+ this.cvPositionColoredVertexies[0].TextureCoordinates.Y = f荳碍蛟､;
+
+ this.cvPositionColoredVertexies[1].Position.X = f荳ｭ螟ｮX + f陬懈ｭ｣蛟､X;
+ this.cvPositionColoredVertexies[1].Position.Y = f荳ｭ螟ｮY + f陬懈ｭ｣蛟､Y;
+ this.cvPositionColoredVertexies[1].Position.Z = depth;
+ this.cvPositionColoredVertexies[1].Color = color;
+ this.cvPositionColoredVertexies[1].TextureCoordinates.X = f蜿ｳU蛟､;
+ this.cvPositionColoredVertexies[1].TextureCoordinates.Y = f荳碍蛟､;
+
+ this.cvPositionColoredVertexies[2].Position.X = -f荳ｭ螟ｮX + f陬懈ｭ｣蛟､X;
+ this.cvPositionColoredVertexies[2].Position.Y = -f荳ｭ螟ｮY + f陬懈ｭ｣蛟､Y;
+ this.cvPositionColoredVertexies[2].Position.Z = depth;
+ this.cvPositionColoredVertexies[2].Color = color;
+ this.cvPositionColoredVertexies[2].TextureCoordinates.X = f蟾ｦU蛟､;
+ this.cvPositionColoredVertexies[2].TextureCoordinates.Y = f荳儀蛟､;
+
+ this.cvPositionColoredVertexies[3].Position.X = f荳ｭ螟ｮX + f陬懈ｭ｣蛟､X;
+ this.cvPositionColoredVertexies[3].Position.Y = -f荳ｭ螟ｮY + f陬懈ｭ｣蛟､Y;
+ this.cvPositionColoredVertexies[3].Position.Z = depth;
+ this.cvPositionColoredVertexies[3].Color = color;
+ this.cvPositionColoredVertexies[3].TextureCoordinates.X = f蜿ｳU蛟､;
+ this.cvPositionColoredVertexies[3].TextureCoordinates.Y = f荳儀蛟､;
+
+ float n謠冗判鬆伜沺蜀X = x + (rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺.Width / 2.0f);
+ float n謠冗判鬆伜沺蜀Y = y + (rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺.Height / 2.0f);
+ var vc3遘ｻ蜍暮 = new Vector3(n謠冗判鬆伜沺蜀X - (((float)device.Viewport.Width) / 2f), -(n謠冗判鬆伜沺蜀Y - (((float)device.Viewport.Height) / 2f)), 0f);
+
+ var matrix = Matrix.Identity * Matrix.Scaling(this.vc諡｡螟ｧ邵ｮ蟆丞咲紫);
+ matrix *= Matrix.RotationZ(this.fZ霆ｸ荳ｭ蠢蝗櫁ｻ｢);
+ matrix *= Matrix.Translation(vc3遘ｻ蜍暮);
+ device.SetTransform(TransformState.World, matrix);
+
+ device.SetTexture(0, this.texture);
+ device.VertexFormat = PositionColoredTexturedVertex.Format;
+ device.DrawUserPrimitives(PrimitiveType.TriangleStrip, 2, in this.cvPositionColoredVertexies);
+ //-----------------
+ #endregion
+ }
+ }
+ public void t2D謠冗判(Device device, int x, int y, float depth, Rectangle rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺)
+ {
+ if (this.texture == null)
+ return;
+
+ this.t繝ｬ繝ｳ繝繝ｪ繝ｳ繧ｰ繧ｹ繝繝ｼ繝医ｮ險ｭ螳(device);
+
+ if (this.fZ霆ｸ荳ｭ蠢蝗櫁ｻ｢ == 0f)
+ {
+ #region [ (A) 蝗櫁ｻ｢縺ｪ縺 ]
+ //-----------------
+ float f陬懈ｭ｣蛟､X = -0.5f; // -0.5 縺ｯ蠎ｧ讓吶→繝斐け繧ｻ繝ｫ縺ｮ隱､蟾ｮ繧貞精蜿弱☆繧九◆繧√ｮ蠎ｧ讓呵｣懈ｭ｣蛟､縲(MSDN蜿らｧ)
+ float f陬懈ｭ｣蛟､Y = -0.5f; //
+ float w = rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺.Width;
+ float h = rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺.Height;
+ float f蟾ｦU蛟､ = ((float)rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺.Left) / ((float)this.sz繝繧ｯ繧ｹ繝√Ε繧ｵ繧､繧ｺ.Width);
+ float f蜿ｳU蛟､ = ((float)rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺.Right) / ((float)this.sz繝繧ｯ繧ｹ繝√Ε繧ｵ繧､繧ｺ.Width);
+ float f荳碍蛟､ = ((float)rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺.Top) / ((float)this.sz繝繧ｯ繧ｹ繝√Ε繧ｵ繧､繧ｺ.Height);
+ float f荳儀蛟､ = ((float)rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺.Bottom) / ((float)this.sz繝繧ｯ繧ｹ繝√Ε繧ｵ繧､繧ｺ.Height);
+ this.color4.Alpha = ((float)this._opacity) / 255f;
+ int color = this.color4.ToArgb();
+
+ if (this.cvTransformedColoredVertexies == null)
+ this.cvTransformedColoredVertexies = new TransformedColoredTexturedVertex[4];
+
+ // #27122 2012.1.13 from: 莉･荳九√槭ロ繝ｼ繧ｸ繝峨が繝悶ず繧ｧ繧ｯ繝茨ｼ茨ｼ昴ぎ繝吶ｼ繧ｸｼ峨ｮ驥冗肇繧呈椛縺医ｋ縺溘ａ縲］ew 縺ｯ菴ｿ繧上★縲√Γ繝ｳ繝舌↓蛟､繧抵ｼ代▽縺壹▽逶ｴ謗･荳頑嶌縺阪☆繧九
+
+ this.cvTransformedColoredVertexies[0].Position.X = x + f陬懈ｭ｣蛟､X;
+ this.cvTransformedColoredVertexies[0].Position.Y = y + f陬懈ｭ｣蛟､Y;
+ this.cvTransformedColoredVertexies[0].Position.Z = depth;
+ this.cvTransformedColoredVertexies[0].Position.W = 1.0f;
+ this.cvTransformedColoredVertexies[0].Color = color;
+ this.cvTransformedColoredVertexies[0].TextureCoordinates.X = f蟾ｦU蛟､;
+ this.cvTransformedColoredVertexies[0].TextureCoordinates.Y = f荳碍蛟､;
+
+ this.cvTransformedColoredVertexies[1].Position.X = (x + (w * this.vc諡｡螟ｧ邵ｮ蟆丞咲紫.X)) + f陬懈ｭ｣蛟､X;
+ this.cvTransformedColoredVertexies[1].Position.Y = y + f陬懈ｭ｣蛟､Y;
+ this.cvTransformedColoredVertexies[1].Position.Z = depth;
+ this.cvTransformedColoredVertexies[1].Position.W = 1.0f;
+ this.cvTransformedColoredVertexies[1].Color = color;
+ this.cvTransformedColoredVertexies[1].TextureCoordinates.X = f蜿ｳU蛟､;
+ this.cvTransformedColoredVertexies[1].TextureCoordinates.Y = f荳碍蛟､;
+
+ this.cvTransformedColoredVertexies[2].Position.X = x + f陬懈ｭ｣蛟､X;
+ this.cvTransformedColoredVertexies[2].Position.Y = (y + (h * this.vc諡｡螟ｧ邵ｮ蟆丞咲紫.Y)) + f陬懈ｭ｣蛟､Y;
+ this.cvTransformedColoredVertexies[2].Position.Z = depth;
+ this.cvTransformedColoredVertexies[2].Position.W = 1.0f;
+ this.cvTransformedColoredVertexies[2].Color = color;
+ this.cvTransformedColoredVertexies[2].TextureCoordinates.X = f蟾ｦU蛟､;
+ this.cvTransformedColoredVertexies[2].TextureCoordinates.Y = f荳儀蛟､;
+
+ this.cvTransformedColoredVertexies[3].Position.X = (x + (w * this.vc諡｡螟ｧ邵ｮ蟆丞咲紫.X)) + f陬懈ｭ｣蛟､X;
+ this.cvTransformedColoredVertexies[3].Position.Y = (y + (h * this.vc諡｡螟ｧ邵ｮ蟆丞咲紫.Y)) + f陬懈ｭ｣蛟､Y;
+ this.cvTransformedColoredVertexies[3].Position.Z = depth;
+ this.cvTransformedColoredVertexies[3].Position.W = 1.0f;
+ this.cvTransformedColoredVertexies[3].Color = color;
+ this.cvTransformedColoredVertexies[3].TextureCoordinates.X = f蜿ｳU蛟､;
+ this.cvTransformedColoredVertexies[3].TextureCoordinates.Y = f荳儀蛟､;
+
+ device.SetTexture(0, this.texture);
+ device.VertexFormat = TransformedColoredTexturedVertex.Format;
+ device.DrawUserPrimitives(PrimitiveType.TriangleStrip, 0, 2, in this.cvTransformedColoredVertexies);
+ //-----------------
+ #endregion
+ }
+ else
+ {
+ #region [ (B) 蝗櫁ｻ｢縺ゅｊ ]
+ //-----------------
+ float f陬懈ｭ｣蛟､X = ((rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺.Width % 2) == 0) ? -0.5f : 0f; // -0.5 縺ｯ蠎ｧ讓吶→繝斐け繧ｻ繝ｫ縺ｮ隱､蟾ｮ繧貞精蜿弱☆繧九◆繧√ｮ蠎ｧ讓呵｣懈ｭ｣蛟､縲(MSDN蜿らｧ)
+ float f陬懈ｭ｣蛟､Y = ((rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺.Height % 2) == 0) ? -0.5f : 0f; // 3Dｼ亥屓霆｢縺吶ｋｼ峨↑繧芽｣懈ｭ｣縺ｯ縺繧峨↑縺縲
+ float f荳ｭ螟ｮX = ((float)rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺.Width) / 2f;
+ float f荳ｭ螟ｮY = ((float)rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺.Height) / 2f;
+ float f蟾ｦU蛟､ = ((float)rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺.Left) / ((float)this.sz繝繧ｯ繧ｹ繝√Ε繧ｵ繧､繧ｺ.Width);
+ float f蜿ｳU蛟､ = ((float)rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺.Right) / ((float)this.sz繝繧ｯ繧ｹ繝√Ε繧ｵ繧､繧ｺ.Width);
+ float f荳碍蛟､ = ((float)rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺.Top) / ((float)this.sz繝繧ｯ繧ｹ繝√Ε繧ｵ繧､繧ｺ.Height);
+ float f荳儀蛟､ = ((float)rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺.Bottom) / ((float)this.sz繝繧ｯ繧ｹ繝√Ε繧ｵ繧､繧ｺ.Height);
+ this.color4.Alpha = ((float)this._opacity) / 255f;
+ int color = this.color4.ToArgb();
+
+ if (this.cvPositionColoredVertexies == null)
+ this.cvPositionColoredVertexies = new PositionColoredTexturedVertex[4];
+
+ // #27122 2012.1.13 from: 莉･荳九√槭ロ繝ｼ繧ｸ繝峨が繝悶ず繧ｧ繧ｯ繝茨ｼ茨ｼ昴ぎ繝吶ｼ繧ｸｼ峨ｮ驥冗肇繧呈椛縺医ｋ縺溘ａ縲］ew 縺ｯ菴ｿ繧上★縲√Γ繝ｳ繝舌↓蛟､繧抵ｼ代▽縺壹▽逶ｴ謗･荳頑嶌縺阪☆繧九
+
+ this.cvPositionColoredVertexies[0].Position.X = -f荳ｭ螟ｮX + f陬懈ｭ｣蛟､X;
+ this.cvPositionColoredVertexies[0].Position.Y = f荳ｭ螟ｮY + f陬懈ｭ｣蛟､Y;
+ this.cvPositionColoredVertexies[0].Position.Z = depth;
+ this.cvPositionColoredVertexies[0].Color = color;
+ this.cvPositionColoredVertexies[0].TextureCoordinates.X = f蟾ｦU蛟､;
+ this.cvPositionColoredVertexies[0].TextureCoordinates.Y = f荳碍蛟､;
+
+ this.cvPositionColoredVertexies[1].Position.X = f荳ｭ螟ｮX + f陬懈ｭ｣蛟､X;
+ this.cvPositionColoredVertexies[1].Position.Y = f荳ｭ螟ｮY + f陬懈ｭ｣蛟､Y;
+ this.cvPositionColoredVertexies[1].Position.Z = depth;
+ this.cvPositionColoredVertexies[1].Color = color;
+ this.cvPositionColoredVertexies[1].TextureCoordinates.X = f蜿ｳU蛟､;
+ this.cvPositionColoredVertexies[1].TextureCoordinates.Y = f荳碍蛟､;
+
+ this.cvPositionColoredVertexies[2].Position.X = -f荳ｭ螟ｮX + f陬懈ｭ｣蛟､X;
+ this.cvPositionColoredVertexies[2].Position.Y = -f荳ｭ螟ｮY + f陬懈ｭ｣蛟､Y;
+ this.cvPositionColoredVertexies[2].Position.Z = depth;
+ this.cvPositionColoredVertexies[2].Color = color;
+ this.cvPositionColoredVertexies[2].TextureCoordinates.X = f蟾ｦU蛟､;
+ this.cvPositionColoredVertexies[2].TextureCoordinates.Y = f荳儀蛟､;
+
+ this.cvPositionColoredVertexies[3].Position.X = f荳ｭ螟ｮX + f陬懈ｭ｣蛟､X;
+ this.cvPositionColoredVertexies[3].Position.Y = -f荳ｭ螟ｮY + f陬懈ｭ｣蛟､Y;
+ this.cvPositionColoredVertexies[3].Position.Z = depth;
+ this.cvPositionColoredVertexies[3].Color = color;
+ this.cvPositionColoredVertexies[3].TextureCoordinates.X = f蜿ｳU蛟､;
+ this.cvPositionColoredVertexies[3].TextureCoordinates.Y = f荳儀蛟､;
+
+ int n謠冗判鬆伜沺蜀X = x + (rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺.Width / 2);
+ int n謠冗判鬆伜沺蜀Y = y + (rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺.Height / 2);
+ var vc3遘ｻ蜍暮 = new Vector3(n謠冗判鬆伜沺蜀X - (((float)device.Viewport.Width) / 2f), -(n謠冗判鬆伜沺蜀Y - (((float)device.Viewport.Height) / 2f)), 0f);
+
+ var matrix = Matrix.Identity * Matrix.Scaling(this.vc諡｡螟ｧ邵ｮ蟆丞咲紫);
+ matrix *= Matrix.RotationZ(this.fZ霆ｸ荳ｭ蠢蝗櫁ｻ｢);
+ matrix *= Matrix.Translation(vc3遘ｻ蜍暮);
+ device.SetTransform(TransformState.World, matrix);
+
+ device.SetTexture(0, this.texture);
+ device.VertexFormat = PositionColoredTexturedVertex.Format;
+ device.DrawUserPrimitives(PrimitiveType.TriangleStrip, 2, in this.cvPositionColoredVertexies);
+ //-----------------
+ #endregion
+ }
+ }
+ public void t2D荳贋ｸ句渚霆｢謠冗判(Device device, int x, int y)
+ {
+ this.t2D荳贋ｸ句渚霆｢謠冗判(device, x, y, 1f, this.rc蜈ｨ逕ｻ蜒);
+ }
+ public void t2D荳贋ｸ句渚霆｢謠冗判(Device device, int x, int y, Rectangle rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺)
+ {
+ this.t2D荳贋ｸ句渚霆｢謠冗判(device, x, y, 1f, rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺);
+ }
+ public void t2D蟾ｦ蜿ｳ蜿崎ｻ｢謠冗判(Device device, int x, int y)
+ {
+ this.t2D蟾ｦ蜿ｳ蜿崎ｻ｢謠冗判(device, x, y, 1f, this.rc蜈ｨ逕ｻ蜒);
+ }
+ public void t2D蟾ｦ蜿ｳ蜿崎ｻ｢謠冗判(Device device, float x, float y)
+ {
+ this.t2D蟾ｦ蜿ｳ蜿崎ｻ｢謠冗判(device, x, y, 1f, this.rc蜈ｨ逕ｻ蜒);
+ }
+ public void t2D蟾ｦ蜿ｳ蜿崎ｻ｢謠冗判(Device device, int x, int y, Rectangle rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺)
+ {
+ this.t2D蟾ｦ蜿ｳ蜿崎ｻ｢謠冗判(device, x, y, 1f, rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺);
+ }
+ public void t2D蟾ｦ蜿ｳ蜿崎ｻ｢謠冗判(Device device, float x, float y, float depth, Rectangle rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺)
+ {
+ if (this.texture == null)
+ throw new InvalidOperationException("繝繧ｯ繧ｹ繝√Ε縺ｯ逕滓舌＆繧後※縺縺ｾ縺帙ｓ縲");
+
+ this.t繝ｬ繝ｳ繝繝ｪ繝ｳ繧ｰ繧ｹ繝繝ｼ繝医ｮ險ｭ螳(device);
+
+ float fx = x * CTexture.f逕ｻ髱｢豈皮紫 + CTexture.rc迚ｩ逅逕ｻ髱｢謠冗判鬆伜沺.X - 0.5f; // -0.5 縺ｯ蠎ｧ讓吶→繝斐け繧ｻ繝ｫ縺ｮ隱､蟾ｮ繧貞精蜿弱☆繧九◆繧√ｮ蠎ｧ讓呵｣懈ｭ｣蛟､縲(MSDN蜿らｧ)
+ float fy = y * CTexture.f逕ｻ髱｢豈皮紫 + CTexture.rc迚ｩ逅逕ｻ髱｢謠冗判鬆伜沺.Y - 0.5f; //
+ float w = rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺.Width * this.vc諡｡螟ｧ邵ｮ蟆丞咲紫.X * CTexture.f逕ｻ髱｢豈皮紫;
+ float h = rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺.Height * this.vc諡｡螟ｧ邵ｮ蟆丞咲紫.Y * CTexture.f逕ｻ髱｢豈皮紫;
+ float f蟾ｦU蛟､ = ((float)rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺.Left) / ((float)this.sz繝繧ｯ繧ｹ繝√Ε繧ｵ繧､繧ｺ.Width);
+ float f蜿ｳU蛟､ = ((float)rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺.Right) / ((float)this.sz繝繧ｯ繧ｹ繝√Ε繧ｵ繧､繧ｺ.Width);
+ float f荳碍蛟､ = ((float)rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺.Top) / ((float)this.sz繝繧ｯ繧ｹ繝√Ε繧ｵ繧､繧ｺ.Height);
+ float f荳儀蛟､ = ((float)rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺.Bottom) / ((float)this.sz繝繧ｯ繧ｹ繝√Ε繧ｵ繧､繧ｺ.Height);
+ this.color4.Alpha = ((float)this._opacity) / 255f;
+ int color = this.color4.ToArgb();
+
+
+ if (this.cvTransformedColoredVertexies == null)
+ this.cvTransformedColoredVertexies = new TransformedColoredTexturedVertex[4];
+
+ // 莉･荳九√槭ロ繝ｼ繧ｸ繝峨が繝悶ず繧ｧ繧ｯ繝医ｮ驥冗肇繧呈椛縺医ｋ縺溘ａ new 縺ｯ菴ｿ繧上↑縺縲
+
+ this.cvTransformedColoredVertexies[0].TextureCoordinates.X = f蜿ｳU蛟､; // 蟾ｦ荳 竊 蟾ｦ荳
+ this.cvTransformedColoredVertexies[0].TextureCoordinates.Y = f荳碍蛟､;
+ this.cvTransformedColoredVertexies[0].Position.X = fx;
+ this.cvTransformedColoredVertexies[0].Position.Y = fy;
+ this.cvTransformedColoredVertexies[0].Position.Z = depth;
+ this.cvTransformedColoredVertexies[0].Position.W = 1.0f;
+ this.cvTransformedColoredVertexies[0].Color = color;
+
+ this.cvTransformedColoredVertexies[1].TextureCoordinates.X = f蟾ｦU蛟､; // 蜿ｳ荳 竊 蜿ｳ荳
+ this.cvTransformedColoredVertexies[1].TextureCoordinates.Y = f荳碍蛟､;
+ this.cvTransformedColoredVertexies[1].Position.X = fx + w;
+ this.cvTransformedColoredVertexies[1].Position.Y = fy;
+ this.cvTransformedColoredVertexies[1].Position.Z = depth;
+ this.cvTransformedColoredVertexies[1].Position.W = 1.0f;
+ this.cvTransformedColoredVertexies[1].Color = color;
+
+ this.cvTransformedColoredVertexies[2].TextureCoordinates.X = f蜿ｳU蛟､; // 蟾ｦ荳 竊 蟾ｦ荳
+ this.cvTransformedColoredVertexies[2].TextureCoordinates.Y = f荳儀蛟､;
+ this.cvTransformedColoredVertexies[2].Position.X = fx;
+ this.cvTransformedColoredVertexies[2].Position.Y = fy + h;
+ this.cvTransformedColoredVertexies[2].Position.Z = depth;
+ this.cvTransformedColoredVertexies[2].Position.W = 1.0f;
+ this.cvTransformedColoredVertexies[2].Color = color;
+
+ this.cvTransformedColoredVertexies[3].TextureCoordinates.X = f蟾ｦU蛟､; // 蜿ｳ荳 竊 蜿ｳ荳
+ this.cvTransformedColoredVertexies[3].TextureCoordinates.Y = f荳儀蛟､;
+ this.cvTransformedColoredVertexies[3].Position.X = fx + w;
+ this.cvTransformedColoredVertexies[3].Position.Y = fy + h;
+ this.cvTransformedColoredVertexies[3].Position.Z = depth;
+ this.cvTransformedColoredVertexies[3].Position.W = 1.0f;
+ this.cvTransformedColoredVertexies[3].Color = color;
+
+ device.SetTexture(0, this.texture);
+ device.VertexFormat = TransformedColoredTexturedVertex.Format;
+ device.DrawUserPrimitives(PrimitiveType.TriangleStrip, 2, this.cvTransformedColoredVertexies);
+ }
+ public void t2D荳贋ｸ句渚霆｢謠冗判(Device device, int x, int y, float depth, Rectangle rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺)
+ {
+ if (this.texture == null)
+ throw new InvalidOperationException("繝繧ｯ繧ｹ繝√Ε縺ｯ逕滓舌＆繧後※縺縺ｾ縺帙ｓ縲");
+
+ this.t繝ｬ繝ｳ繝繝ｪ繝ｳ繧ｰ繧ｹ繝繝ｼ繝医ｮ險ｭ螳(device);
+
+ float fx = x * CTexture.f逕ｻ髱｢豈皮紫 + CTexture.rc迚ｩ逅逕ｻ髱｢謠冗判鬆伜沺.X - 0.5f; // -0.5 縺ｯ蠎ｧ讓吶→繝斐け繧ｻ繝ｫ縺ｮ隱､蟾ｮ繧貞精蜿弱☆繧九◆繧√ｮ蠎ｧ讓呵｣懈ｭ｣蛟､縲(MSDN蜿らｧ)
+ float fy = y * CTexture.f逕ｻ髱｢豈皮紫 + CTexture.rc迚ｩ逅逕ｻ髱｢謠冗判鬆伜沺.Y - 0.5f; //
+ float w = rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺.Width * this.vc諡｡螟ｧ邵ｮ蟆丞咲紫.X * CTexture.f逕ｻ髱｢豈皮紫;
+ float h = rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺.Height * this.vc諡｡螟ｧ邵ｮ蟆丞咲紫.Y * CTexture.f逕ｻ髱｢豈皮紫;
+ float f蟾ｦU蛟､ = ((float)rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺.Left) / ((float)this.sz繝繧ｯ繧ｹ繝√Ε繧ｵ繧､繧ｺ.Width);
+ float f蜿ｳU蛟､ = ((float)rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺.Right) / ((float)this.sz繝繧ｯ繧ｹ繝√Ε繧ｵ繧､繧ｺ.Width);
+ float f荳碍蛟､ = ((float)rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺.Top) / ((float)this.sz繝繧ｯ繧ｹ繝√Ε繧ｵ繧､繧ｺ.Height);
+ float f荳儀蛟､ = ((float)rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺.Bottom) / ((float)this.sz繝繧ｯ繧ｹ繝√Ε繧ｵ繧､繧ｺ.Height);
+ this.color4.Alpha = ((float)this._opacity) / 255f;
+ int color = this.color4.ToArgb();
+
+ if (this.cvTransformedColoredVertexies == null)
+ this.cvTransformedColoredVertexies = new TransformedColoredTexturedVertex[4];
+
+ // 莉･荳九√槭ロ繝ｼ繧ｸ繝峨が繝悶ず繧ｧ繧ｯ繝医ｮ驥冗肇繧呈椛縺医ｋ縺溘ａ new 縺ｯ菴ｿ繧上↑縺縲
+
+ this.cvTransformedColoredVertexies[0].TextureCoordinates.X = f蟾ｦU蛟､; // 蟾ｦ荳 竊 蟾ｦ荳
+ this.cvTransformedColoredVertexies[0].TextureCoordinates.Y = f荳儀蛟､;
+ this.cvTransformedColoredVertexies[0].Position.X = fx;
+ this.cvTransformedColoredVertexies[0].Position.Y = fy;
+ this.cvTransformedColoredVertexies[0].Position.Z = depth;
+ this.cvTransformedColoredVertexies[0].Position.W = 1.0f;
+ this.cvTransformedColoredVertexies[0].Color = color;
+
+ this.cvTransformedColoredVertexies[1].TextureCoordinates.X = f蜿ｳU蛟､; // 蜿ｳ荳 竊 蜿ｳ荳
+ this.cvTransformedColoredVertexies[1].TextureCoordinates.Y = f荳儀蛟､;
+ this.cvTransformedColoredVertexies[1].Position.X = fx + w;
+ this.cvTransformedColoredVertexies[1].Position.Y = fy;
+ this.cvTransformedColoredVertexies[1].Position.Z = depth;
+ this.cvTransformedColoredVertexies[1].Position.W = 1.0f;
+ this.cvTransformedColoredVertexies[1].Color = color;
+
+ this.cvTransformedColoredVertexies[2].TextureCoordinates.X = f蟾ｦU蛟､; // 蟾ｦ荳 竊 蟾ｦ荳
+ this.cvTransformedColoredVertexies[2].TextureCoordinates.Y = f荳碍蛟､;
+ this.cvTransformedColoredVertexies[2].Position.X = fx;
+ this.cvTransformedColoredVertexies[2].Position.Y = fy + h;
+ this.cvTransformedColoredVertexies[2].Position.Z = depth;
+ this.cvTransformedColoredVertexies[2].Position.W = 1.0f;
+ this.cvTransformedColoredVertexies[2].Color = color;
+
+ this.cvTransformedColoredVertexies[3].TextureCoordinates.X = f蜿ｳU蛟､; // 蜿ｳ荳 竊 蜿ｳ荳
+ this.cvTransformedColoredVertexies[3].TextureCoordinates.Y = f荳碍蛟､;
+ this.cvTransformedColoredVertexies[3].Position.X = fx + w;
+ this.cvTransformedColoredVertexies[3].Position.Y = fy + h;
+ this.cvTransformedColoredVertexies[3].Position.Z = depth;
+ this.cvTransformedColoredVertexies[3].Position.W = 1.0f;
+ this.cvTransformedColoredVertexies[3].Color = color;
+
+ device.SetTexture(0, this.texture);
+ device.VertexFormat = TransformedColoredTexturedVertex.Format;
+ device.DrawUserPrimitives(PrimitiveType.TriangleStrip, 2, in this.cvTransformedColoredVertexies);
+ }
+ public void t2D荳贋ｸ句渚霆｢謠冗判(Device device, Point pt)
+ {
+ this.t2D荳贋ｸ句渚霆｢謠冗判(device, pt.X, pt.Y, 1f, this.rc蜈ｨ逕ｻ蜒);
+ }
+ public void t2D荳贋ｸ句渚霆｢謠冗判(Device device, Point pt, Rectangle rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺)
+ {
+ this.t2D荳贋ｸ句渚霆｢謠冗判(device, pt.X, pt.Y, 1f, rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺);
+ }
+ public void t2D荳贋ｸ句渚霆｢謠冗判(Device device, Point pt, float depth, Rectangle rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺)
+ {
+ this.t2D荳贋ｸ句渚霆｢謠冗判(device, pt.X, pt.Y, depth, rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺);
+ }
+
+ public static Vector3 t隲也炊逕ｻ髱｢蠎ｧ讓吶ｒ繝ｯ繝ｼ繝ｫ繝牙ｺｧ讓吶∈螟画鋤縺吶ｋ(int x, int y)
+ {
+ return CTexture.t隲也炊逕ｻ髱｢蠎ｧ讓吶ｒ繝ｯ繝ｼ繝ｫ繝牙ｺｧ讓吶∈螟画鋤縺吶ｋ(new Vector3((float)x, (float)y, 0f));
+ }
+ public static Vector3 t隲也炊逕ｻ髱｢蠎ｧ讓吶ｒ繝ｯ繝ｼ繝ｫ繝牙ｺｧ讓吶∈螟画鋤縺吶ｋ(float x, float y)
+ {
+ return CTexture.t隲也炊逕ｻ髱｢蠎ｧ讓吶ｒ繝ｯ繝ｼ繝ｫ繝牙ｺｧ讓吶∈螟画鋤縺吶ｋ(new Vector3(x, y, 0f));
+ }
+ public static Vector3 t隲也炊逕ｻ髱｢蠎ｧ讓吶ｒ繝ｯ繝ｼ繝ｫ繝牙ｺｧ讓吶∈螟画鋤縺吶ｋ(Point pt隲也炊逕ｻ髱｢蠎ｧ讓)
+ {
+ return CTexture.t隲也炊逕ｻ髱｢蠎ｧ讓吶ｒ繝ｯ繝ｼ繝ｫ繝牙ｺｧ讓吶∈螟画鋤縺吶ｋ(new Vector3(pt隲也炊逕ｻ髱｢蠎ｧ讓.X, pt隲也炊逕ｻ髱｢蠎ｧ讓.Y, 0.0f));
+ }
+ public static Vector3 t隲也炊逕ｻ髱｢蠎ｧ讓吶ｒ繝ｯ繝ｼ繝ｫ繝牙ｺｧ讓吶∈螟画鋤縺吶ｋ(Vector2 v2隲也炊逕ｻ髱｢蠎ｧ讓)
+ {
+ return CTexture.t隲也炊逕ｻ髱｢蠎ｧ讓吶ｒ繝ｯ繝ｼ繝ｫ繝牙ｺｧ讓吶∈螟画鋤縺吶ｋ(new Vector3(v2隲也炊逕ｻ髱｢蠎ｧ讓, 0f));
+ }
+ public static Vector3 t隲也炊逕ｻ髱｢蠎ｧ讓吶ｒ繝ｯ繝ｼ繝ｫ繝牙ｺｧ讓吶∈螟画鋤縺吶ｋ(Vector3 v3隲也炊逕ｻ髱｢蠎ｧ讓)
+ {
+ return new Vector3(
+ (v3隲也炊逕ｻ髱｢蠎ｧ讓.X - (CTexture.sz隲也炊逕ｻ髱｢.Width / 2.0f)) * CTexture.f逕ｻ髱｢豈皮紫,
+ (-(v3隲也炊逕ｻ髱｢蠎ｧ讓.Y - (CTexture.sz隲也炊逕ｻ髱｢.Height / 2.0f)) * CTexture.f逕ｻ髱｢豈皮紫),
+ v3隲也炊逕ｻ髱｢蠎ｧ讓.Z);
+ }
+
+ ///
+ /// 繝繧ｯ繧ｹ繝√Ε繧 3D 逕ｻ蜒上→隕九↑縺励※謠冗判縺吶ｋ縲
+ ///
+ public void t3D謠冗判(Device device, Matrix mat)
+ {
+ this.t3D謠冗判(device, mat, this.rc蜈ｨ逕ｻ蜒);
+ }
+ public void t3D謠冗判(Device device, Matrix mat, Rectangle rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺)
+ {
+ if (this.texture == null)
+ return;
+
+ float x = ((float)rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺.Width) / 2f;
+ float y = ((float)rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺.Height) / 2f;
+ float z = 0.0f;
+ float f蟾ｦU蛟､ = ((float)rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺.Left) / ((float)this.sz繝繧ｯ繧ｹ繝√Ε繧ｵ繧､繧ｺ.Width);
+ float f蜿ｳU蛟､ = ((float)rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺.Right) / ((float)this.sz繝繧ｯ繧ｹ繝√Ε繧ｵ繧､繧ｺ.Width);
+ float f荳碍蛟､ = ((float)rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺.Top) / ((float)this.sz繝繧ｯ繧ｹ繝√Ε繧ｵ繧､繧ｺ.Height);
+ float f荳儀蛟､ = ((float)rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺.Bottom) / ((float)this.sz繝繧ｯ繧ｹ繝√Ε繧ｵ繧､繧ｺ.Height);
+ this.color4.Alpha = ((float)this._opacity) / 255f;
+ int color = this.color4.ToArgb();
+
+ if (this.cvPositionColoredVertexies == null)
+ this.cvPositionColoredVertexies = new PositionColoredTexturedVertex[4];
+
+ // #27122 2012.1.13 from: 莉･荳九√槭ロ繝ｼ繧ｸ繝峨が繝悶ず繧ｧ繧ｯ繝茨ｼ茨ｼ昴ぎ繝吶ｼ繧ｸｼ峨ｮ驥冗肇繧呈椛縺医ｋ縺溘ａ縲］ew 縺ｯ菴ｿ繧上★縲√Γ繝ｳ繝舌↓蛟､繧抵ｼ代▽縺壹▽逶ｴ謗･荳頑嶌縺阪☆繧九
+
+ this.cvPositionColoredVertexies[0].Position.X = -x;
+ this.cvPositionColoredVertexies[0].Position.Y = y;
+ this.cvPositionColoredVertexies[0].Position.Z = z;
+ this.cvPositionColoredVertexies[0].Color = color;
+ this.cvPositionColoredVertexies[0].TextureCoordinates.X = f蟾ｦU蛟､;
+ this.cvPositionColoredVertexies[0].TextureCoordinates.Y = f荳碍蛟､;
+
+ this.cvPositionColoredVertexies[1].Position.X = x;
+ this.cvPositionColoredVertexies[1].Position.Y = y;
+ this.cvPositionColoredVertexies[1].Position.Z = z;
+ this.cvPositionColoredVertexies[1].Color = color;
+ this.cvPositionColoredVertexies[1].TextureCoordinates.X = f蜿ｳU蛟､;
+ this.cvPositionColoredVertexies[1].TextureCoordinates.Y = f荳碍蛟､;
+
+ this.cvPositionColoredVertexies[2].Position.X = -x;
+ this.cvPositionColoredVertexies[2].Position.Y = -y;
+ this.cvPositionColoredVertexies[2].Position.Z = z;
+ this.cvPositionColoredVertexies[2].Color = color;
+ this.cvPositionColoredVertexies[2].TextureCoordinates.X = f蟾ｦU蛟､;
+ this.cvPositionColoredVertexies[2].TextureCoordinates.Y = f荳儀蛟､;
+
+ this.cvPositionColoredVertexies[3].Position.X = x;
+ this.cvPositionColoredVertexies[3].Position.Y = -y;
+ this.cvPositionColoredVertexies[3].Position.Z = z;
+ this.cvPositionColoredVertexies[3].Color = color;
+ this.cvPositionColoredVertexies[3].TextureCoordinates.X = f蜿ｳU蛟､;
+ this.cvPositionColoredVertexies[3].TextureCoordinates.Y = f荳儀蛟､;
+
+ this.t繝ｬ繝ｳ繝繝ｪ繝ｳ繧ｰ繧ｹ繝繝ｼ繝医ｮ險ｭ螳(device);
+
+ device.SetTransform(TransformState.World, mat);
+ device.SetTexture(0, this.texture);
+ device.VertexFormat = PositionColoredTexturedVertex.Format;
+ device.DrawUserPrimitives(PrimitiveType.TriangleStrip, 2, in this.cvPositionColoredVertexies);
+ }
+
+ public void t3D蟾ｦ荳雁渕貅匁緒逕ｻ(Device device, Matrix mat)
+ {
+ this.t3D蟾ｦ荳雁渕貅匁緒逕ｻ(device, mat, this.rc蜈ｨ逕ｻ蜒);
+ }
+ ///
+ /// 笳玖ｦ壽嶌
+ /// SlimDX.Matrix mat = SlimDX.Matrix.Identity;
+ /// mat *= SlimDX.Matrix.Translation( x, y, z );
+ /// 縲稽at =縲阪〒縺ｯ縺ｪ縺上稽at *=縲阪〒縺ゅｋ縺薙→繧貞ｿ倥ｌ縺ｪ縺縺薙→縲
+ ///
+ public void t3D蟾ｦ荳雁渕貅匁緒逕ｻ(Device device, Matrix mat, Rectangle rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺)
+ {
+ //縺ｨ繧翫≠縺医★陬懈ｭ｣蛟､縺ｪ縺ｩ縺ｯ辟｡縺励ゅ↓縺励※繧ゆｽｿ縺讖滉ｼ壼ｰ代↑縺輔◎縺縺縺ｪ繝ｼ
+ if (this.texture == null)
+ return;
+
+ float x = 0.0f;
+ float y = 0.0f;
+ float z = 0.0f;
+ float f蟾ｦU蛟､ = ((float)rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺.Left) / ((float)this.sz繝繧ｯ繧ｹ繝√Ε繧ｵ繧､繧ｺ.Width);
+ float f蜿ｳU蛟､ = ((float)rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺.Right) / ((float)this.sz繝繧ｯ繧ｹ繝√Ε繧ｵ繧､繧ｺ.Width);
+ float f荳碍蛟､ = ((float)rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺.Top) / ((float)this.sz繝繧ｯ繧ｹ繝√Ε繧ｵ繧､繧ｺ.Height);
+ float f荳儀蛟､ = ((float)rc逕ｻ蜒丞縺ｮ謠冗判鬆伜沺.Bottom) / ((float)this.sz繝繧ｯ繧ｹ繝√Ε繧ｵ繧､繧ｺ.Height);
+ this.color4.Alpha = ((float)this._opacity) / 255f;
+ int color = this.color4.ToArgb();
+
+ if (this.cvPositionColoredVertexies == null)
+ this.cvPositionColoredVertexies = new PositionColoredTexturedVertex[4];
+
+ // #27122 2012.1.13 from: 莉･荳九√槭ロ繝ｼ繧ｸ繝峨が繝悶ず繧ｧ繧ｯ繝茨ｼ茨ｼ昴ぎ繝吶ｼ繧ｸｼ峨ｮ驥冗肇繧呈椛縺医ｋ縺溘ａ縲］ew 縺ｯ菴ｿ繧上★縲√Γ繝ｳ繝舌↓蛟､繧抵ｼ代▽縺壹▽逶ｴ謗･荳頑嶌縺阪☆繧九
+
+ this.cvPositionColoredVertexies[0].Position.X = -x;
+ this.cvPositionColoredVertexies[0].Position.Y = y;
+ this.cvPositionColoredVertexies[0].Position.Z = z;
+ this.cvPositionColoredVertexies[0].Color = color;
+ this.cvPositionColoredVertexies[0].TextureCoordinates.X = f蟾ｦU蛟､;
+ this.cvPositionColoredVertexies[0].TextureCoordinates.Y = f荳碍蛟､;
+
+ this.cvPositionColoredVertexies[1].Position.X = x;
+ this.cvPositionColoredVertexies[1].Position.Y = y;
+ this.cvPositionColoredVertexies[1].Position.Z = z;
+ this.cvPositionColoredVertexies[1].Color = color;
+ this.cvPositionColoredVertexies[1].TextureCoordinates.X = f蜿ｳU蛟､;
+ this.cvPositionColoredVertexies[1].TextureCoordinates.Y = f荳碍蛟､;
+
+ this.cvPositionColoredVertexies[2].Position.X = -x;
+ this.cvPositionColoredVertexies[2].Position.Y = -y;
+ this.cvPositionColoredVertexies[2].Position.Z = z;
+ this.cvPositionColoredVertexies[2].Color = color;
+ this.cvPositionColoredVertexies[2].TextureCoordinates.X = f蟾ｦU蛟､;
+ this.cvPositionColoredVertexies[2].TextureCoordinates.Y = f荳儀蛟､;
+
+ this.cvPositionColoredVertexies[3].Position.X = x;
+ this.cvPositionColoredVertexies[3].Position.Y = -y;
+ this.cvPositionColoredVertexies[3].Position.Z = z;
+ this.cvPositionColoredVertexies[3].Color = color;
+ this.cvPositionColoredVertexies[3].TextureCoordinates.X = f蜿ｳU蛟､;
+ this.cvPositionColoredVertexies[3].TextureCoordinates.Y = f荳儀蛟､;
+
+ this.t繝ｬ繝ｳ繝繝ｪ繝ｳ繧ｰ繧ｹ繝繝ｼ繝医ｮ險ｭ螳(device);
+
+ device.SetTransform(TransformState.World, mat);
+ device.SetTexture(0, this.texture);
+ device.VertexFormat = PositionColoredTexturedVertex.Format;
+ device.DrawUserPrimitives(PrimitiveType.TriangleStrip, 2, in this.cvPositionColoredVertexies);
+ }
+
+ #region [ IDisposable 螳溯｣ ]
+ //-----------------
+ public void Dispose()
+ {
+ if (!this.bDispose螳御ｺ貂医∩)
+ {
+ // 繝繧ｯ繧ｹ繝√Ε縺ｮ遐ｴ譽
+ if (this.texture != null)
+ {
+ this.texture.Dispose();
+ this.texture = null;
+ }
+
+ this.bDispose螳御ｺ貂医∩ = true;
+ }
+ }
+ //-----------------
+ #endregion
+
+
+ // 縺昴ｮ莉
+
+ #region [ private ]
+ //-----------------
+ private int _opacity;
+ private bool bDispose螳御ｺ貂医∩;
+ private PositionColoredTexturedVertex[] cvPositionColoredVertexies;
+ protected TransformedColoredTexturedVertex[] cvTransformedColoredVertexies = new TransformedColoredTexturedVertex[]
+ {
+ new TransformedColoredTexturedVertex(),
+ new TransformedColoredTexturedVertex(),
+ new TransformedColoredTexturedVertex(),
+ new TransformedColoredTexturedVertex(),
+ };
+ private const Pool poolvar = // 2011.4.25 yyagi
+#if TEST_Direct3D9Ex
+ Pool.Default;
+#else
+ Pool.Managed;
+#endif
+ // byte[] _txData;
+ static object lockobj = new object();
+
+ ///
+ /// 縺ｩ繧後°荳縺､縺梧怏蜉ｹ縺ｫ縺ｪ繧翫∪縺吶
+ ///
+ /// Direct3D縺ｮ繝繝舌う繧ｹ
+ private void t繝ｬ繝ｳ繝繝ｪ繝ｳ繧ｰ繧ｹ繝繝ｼ繝医ｮ險ｭ螳(Device device)
+ {
+ if (this.b蜉邂怜粋謌)
+ {
+ device.SetRenderState(RenderState.SourceBlend, SlimDX.Direct3D9.Blend.SourceAlpha); // 5
+ device.SetRenderState(RenderState.DestinationBlend, SlimDX.Direct3D9.Blend.One); // 2
+ }
+ else if (this.b荵礼ｮ怜粋謌)
+ {
+ //蜿り:http://sylphylunar.seesaa.net/article/390331341.html
+ //C++縺九ｉ蠑輔▲蠑ｵ縺｣縺ｦ縺阪◆縺ｮ縺ｧ縺｡繧縺｣縺ｨ荳榊ｮ峨
+ device.SetRenderState(RenderState.SourceBlend, SlimDX.Direct3D9.Blend.DestinationColor);
+ device.SetRenderState(RenderState.DestinationBlend, SlimDX.Direct3D9.Blend.Zero);
+ }
+ else if (this.b貂帷ｮ怜粋謌)
+ {
+ //蜿り:http://www3.pf-x.net/~chopper/home2/DirectX/MD20.html
+ device.SetRenderState(RenderState.BlendOperation, SlimDX.Direct3D9.BlendOperation.Subtract);
+ device.SetRenderState(RenderState.SourceBlend, SlimDX.Direct3D9.Blend.One);
+ device.SetRenderState(RenderState.DestinationBlend, SlimDX.Direct3D9.Blend.One);
+ }
+ else if (this.b繧ｹ繧ｯ繝ｪ繝ｼ繝ｳ蜷域)
+ {
+ //蜿り:http://sylphylunar.seesaa.net/article/390331341.html
+ //C++縺九ｉ蠑輔▲蠑ｵ縺｣縺ｦ縺阪◆縺ｮ縺ｧ縺｡繧縺｣縺ｨ荳榊ｮ峨
+ device.SetRenderState(RenderState.SourceBlend, SlimDX.Direct3D9.Blend.InverseDestinationColor);
+ device.SetRenderState(RenderState.DestinationBlend, SlimDX.Direct3D9.Blend.One);
+ }
+ else
+ {
+ device.SetRenderState(RenderState.SourceBlend, SlimDX.Direct3D9.Blend.SourceAlpha); // 5
+ device.SetRenderState(RenderState.DestinationBlend, SlimDX.Direct3D9.Blend.InverseSourceAlpha); // 6
+ }
+ }
+ private Size t謖螳壹＆繧後◆繧ｵ繧､繧ｺ繧定ｶ縺医↑縺譛驕ｩ縺ｪ繝繧ｯ繧ｹ繝√Ε繧ｵ繧､繧ｺ繧定ｿ斐☆(Device device, Size sz謖螳壹し繧､繧ｺ)
+ {
+ var deviceCapabilities = device.Capabilities;
+ var deviceCapabilitiesTextureCaps = deviceCapabilities.TextureCaps;
+
+ bool b譚｡莉ｶ莉倥″縺ｧ繧ｵ繧､繧ｺ縺ｯｼ偵ｮ邏ｯ荵励〒縺ｪ縺上※繧０K = (deviceCapabilitiesTextureCaps & TextureCaps.NonPow2Conditional) != 0;
+ bool b繧ｵ繧､繧ｺ縺ｯｼ偵ｮ邏ｯ荵励〒縺ｪ縺代ｌ縺ｰ縺ｪ繧峨↑縺 = (deviceCapabilitiesTextureCaps & TextureCaps.Pow2) != 0;
+ bool b豁｣譁ｹ蠖｢縺ｧ縺ｪ縺代ｌ縺ｰ縺ｪ繧峨↑縺 = (deviceCapabilitiesTextureCaps & TextureCaps.SquareOnly) != 0;
+ int n譛螟ｧ蟷 = deviceCapabilities.MaxTextureWidth;
+ int n譛螟ｧ鬮 = deviceCapabilities.MaxTextureHeight;
+ var sz繧ｵ繧､繧ｺ = new Size(sz謖螳壹し繧､繧ｺ.Width, sz謖螳壹し繧､繧ｺ.Height);
+
+ if (b繧ｵ繧､繧ｺ縺ｯｼ偵ｮ邏ｯ荵励〒縺ｪ縺代ｌ縺ｰ縺ｪ繧峨↑縺 && !b譚｡莉ｶ莉倥″縺ｧ繧ｵ繧､繧ｺ縺ｯｼ偵ｮ邏ｯ荵励〒縺ｪ縺上※繧０K)
+ {
+ // 蟷繧抵ｼ偵ｮ邏ｯ荵励↓縺吶ｋ
+ int n = 1;
+ do
+ {
+ n *= 2;
+ }
+ while (n <= sz謖螳壹し繧､繧ｺ.Width);
+ sz謖螳壹し繧､繧ｺ.Width = n;
+
+ // 鬮倥＆繧抵ｼ偵ｮ邏ｯ荵励↓縺吶ｋ
+ n = 1;
+ do
+ {
+ n *= 2;
+ }
+ while (n <= sz謖螳壹し繧､繧ｺ.Height);
+ sz謖螳壹し繧､繧ｺ.Height = n;
+ }
+
+ if (sz謖螳壹し繧､繧ｺ.Width > n譛螟ｧ蟷)
+ sz謖螳壹し繧､繧ｺ.Width = n譛螟ｧ蟷;
+
+ if (sz謖螳壹し繧､繧ｺ.Height > n譛螟ｧ鬮)
+ sz謖螳壹し繧､繧ｺ.Height = n譛螟ｧ鬮;
+
+ if (b豁｣譁ｹ蠖｢縺ｧ縺ｪ縺代ｌ縺ｰ縺ｪ繧峨↑縺)
+ {
+ if (sz繧ｵ繧､繧ｺ.Width > sz繧ｵ繧､繧ｺ.Height)
+ {
+ sz繧ｵ繧､繧ｺ.Height = sz繧ｵ繧､繧ｺ.Width;
+ }
+ else if (sz繧ｵ繧､繧ｺ.Width < sz繧ｵ繧､繧ｺ.Height)
+ {
+ sz繧ｵ繧､繧ｺ.Width = sz繧ｵ繧､繧ｺ.Height;
+ }
+ }
+
+ return sz繧ｵ繧､繧ｺ;
+ }
+
+
+ // 2012.3.21 縺輔ｉ縺ｪ繧 new 縺ｮ逵∫払菴懈姶
+
+ protected Rectangle rc蜈ｨ逕ｻ蜒; // 繝繧ｯ繧ｹ繝√Ε菴懊▲縺溘ｉ縺ゅ→縺ｯ荳榊､
+ public Color4 color4 = new Color4(1f, 1f, 1f, 1f); // 繧｢繝ｫ繝輔ぃ莉･螟悶ｯ荳榊､
+ //-----------------
+ #endregion
+ }
+}
diff --git a/FDK19/繧ｳ繝ｼ繝/04.繧ｰ繝ｩ繝輔ぅ繝繧ｯ/CTextureAutofold.cs b/FDK19/繧ｳ繝ｼ繝/04.繧ｰ繝ｩ繝輔ぅ繝繧ｯ/CTextureAutofold.cs
new file mode 100644
index 00000000..34566f82
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/04.繧ｰ繝ｩ繝輔ぅ繝繧ｯ/CTextureAutofold.cs
@@ -0,0 +1,390 @@
+ｻｿusing System;
+using System.Collections.Generic;
+using System.Text;
+using System.Drawing;
+using System.Drawing.Imaging;
+using System.IO;
+using System.Diagnostics;
+using SlimDX;
+using SlimDX.Direct3D9;
+
+using Device = SampleFramework.DeviceCache;
+
+namespace FDK
+{
+ ///
+ /// 邵ｦ髟ｷ_讓ｪ髟ｷ縺ｮ逕ｻ蜒上ｒ閾ｪ蜍輔〒謚倥ｊ縺溘◆繧薙〒繝繧ｯ繧ｹ繝√Ε蛹悶☆繧気Texture縲
+ /// 萓九∴縺ｰ縲768x30 縺ｮ繝繧ｯ繧ｹ繝√Ε繝輔ぃ繧､繝ｫ縺悟･蜉帙＆繧後◆繧峨
+ /// 蜀驛ｨ縺ｧ256x90 縺ｪ縺ｩ縲2縺ｮ縺ｹ縺堺ｹ励し繧､繧ｺ縺ｫ蜿弱ａ繧九ｈ縺縲∝驛ｨ縺ｧ繝繧ｯ繧ｹ繝√Ε逕ｻ蜒上ｒ閾ｪ蜍慕噪縺ｫ謚倥ｊ霑斐☆縲
+ /// 蠢隕√↓蠢懊§縺ｦ縲∵ｭ｣譁ｹ蠖｢繝繧ｯ繧ｹ繝√Ε縺ｫ繧ゅ☆繧九
+ /// 縺ｾ縺溘》2D謠冗判縺ｯ縲√◎縺ｮ謚倥ｊ霑斐＠繧貞刈蜻ｳ縺励※螳溯｡後☆繧九
+ ///
+ public class CTextureAf : CTexture, IDisposable
+ {
+
+ ///
+ /// 謖螳壹＆繧後◆逕ｻ蜒上ヵ繧｡繧､繝ｫ縺九ｉ Managed 繝繧ｯ繧ｹ繝√Ε繧剃ｽ懈舌☆繧九
+ /// 蛻ｩ逕ｨ蜿ｯ閭ｽ縺ｪ逕ｻ蜒丞ｽ｢蠑上ｯ縲。MP, JPG, PNG, TGA, DDS, PPM, DIB, HDR, PFM 縺ｮ縺縺壹ｌ縺九
+ ///
+ /// Direct3D9 繝繝舌う繧ｹ縲
+ /// 逕ｻ蜒上ヵ繧｡繧､繝ｫ蜷阪
+ /// 繝繧ｯ繧ｹ繝√Ε縺ｮ繝輔か繝ｼ繝槭ャ繝医
+ /// 逕ｻ蜒上ｮ鮟抵ｼ0xFFFFFFFFｼ峨ｒ騾城℃縺輔○繧九↑繧 true縲
+ /// 繝繧ｯ繧ｹ繝√Ε縺ｮ菴懈舌↓螟ｱ謨励＠縺ｾ縺励◆縲
+ public CTextureAf( Device device, string str繝輔ぃ繧､繝ｫ蜷, Format format, bool b鮟偵ｒ騾城℃縺吶ｋ )
+ : this( device, str繝輔ぃ繧､繝ｫ蜷, format, b鮟偵ｒ騾城℃縺吶ｋ, Pool.Managed )
+ {
+ }
+
+ ///
+ /// 逕ｻ蜒上ヵ繧｡繧､繝ｫ縺九ｉ繝繧ｯ繧ｹ繝√Ε繧堤函謌舌☆繧九
+ /// 蛻ｩ逕ｨ蜿ｯ閭ｽ縺ｪ逕ｻ蜒丞ｽ｢蠑上ｯ縲。MP, JPG, PNG, TGA, DDS, PPM, DIB, HDR, PFM 縺ｮ縺縺壹ｌ縺九
+ /// 繝繧ｯ繧ｹ繝√Ε縺ｮ繧ｵ繧､繧ｺ縺ｯ縲∫判蜒上ｮ繧ｵ繧､繧ｺ莉･荳翫√°縺､縲．3D9繝繝舌う繧ｹ縺ｧ逕滓仙庄閭ｽ縺ｪ譛蟆上ｮ繧ｵ繧､繧ｺ縺ｫ閾ｪ蜍慕噪縺ｫ隱ｿ遽縺輔ｌ繧九
+ /// 縺昴ｮ髫帙√ユ繧ｯ繧ｹ繝√Ε縺ｮ隱ｿ遽蠕後ｮ繧ｵ繧､繧ｺ縺ｫ縺ゅｏ縺帙◆逕ｻ蜒上ｮ諡｡螟ｧ邵ｮ蟆上ｯ陦後ｏ縺ｪ縺縲
+ /// 縺昴ｮ莉悶√Α繝繝励槭ャ繝玲焚縺ｯ 1縲ゞsage 縺ｯ None縲√う繝｡繝ｼ繧ｸ繝輔ぅ繝ｫ繧ｿ縺ｯ Point縲√Α繝繝励槭ャ繝励ヵ繧｣繝ｫ繧ｿ縺ｯ None 縺ｫ縺ｪ繧九
+ ///
+ /// Direct3D9 繝繝舌う繧ｹ縲
+ /// 逕ｻ蜒上ヵ繧｡繧､繝ｫ蜷阪
+ /// 繝繧ｯ繧ｹ繝√Ε縺ｮ繝輔か繝ｼ繝槭ャ繝医
+ /// 逕ｻ蜒上ｮ鮟抵ｼ0xFFFFFFFFｼ峨ｒ騾城℃縺輔○繧九↑繧 true縲
+ /// 繝繧ｯ繧ｹ繝√Ε縺ｮ邂｡逅譁ｹ豕輔
+ /// 繝繧ｯ繧ｹ繝√Ε縺ｮ菴懈舌↓螟ｱ謨励＠縺ｾ縺励◆縲
+ public CTextureAf( Device device, string str繝輔ぃ繧､繝ｫ蜷, Format format, bool b鮟偵ｒ騾城℃縺吶ｋ, Pool pool )
+ {
+ MakeTexture( device, str繝輔ぃ繧､繝ｫ蜷, format, b鮟偵ｒ騾城℃縺吶ｋ, pool );
+ }
+
+
+
+
+ public new void MakeTexture( Device device, string str繝輔ぃ繧､繝ｫ蜷, Format format, bool b鮟偵ｒ騾城℃縺吶ｋ, Pool pool )
+ {
+ if ( !File.Exists( str繝輔ぃ繧､繝ｫ蜷 ) ) // #27122 2012.1.13 from: ImageInformation 縺ｧ縺ｯ FileNotFound 萓句､悶ｯ霑斐▲縺ｦ縺薙↑縺縺ｮ縺ｧ縲√％縺薙〒閾ｪ蛻縺ｧ繝√ぉ繝繧ｯ縺吶ｋ縲ゅｏ縺九ｊ繧縺吶＞繝ｭ繧ｰ縺ｮ縺溘ａ縺ｫ縲
+ throw new FileNotFoundException( string.Format( "繝輔ぃ繧､繝ｫ縺悟ｭ伜惠縺励∪縺帙ｓ縲\n[{0}]", str繝輔ぃ繧､繝ｫ蜷 ) );
+
+ Byte[] _txData = File.ReadAllBytes( str繝輔ぃ繧､繝ｫ蜷 );
+ bool b譚｡莉ｶ莉倥″縺ｧ繧ｵ繧､繧ｺ縺ｯｼ偵ｮ邏ｯ荵励〒縺ｪ縺上※繧０K = ( device.Capabilities.TextureCaps & TextureCaps.NonPow2Conditional ) != 0;
+ bool b繧ｵ繧､繧ｺ縺ｯｼ偵ｮ邏ｯ荵励〒縺ｪ縺代ｌ縺ｰ縺ｪ繧峨↑縺 = ( device.Capabilities.TextureCaps & TextureCaps.Pow2 ) != 0;
+ bool b豁｣譁ｹ蠖｢縺ｧ縺ｪ縺代ｌ縺ｰ縺ｪ繧峨↑縺 = ( device.Capabilities.TextureCaps & TextureCaps.SquareOnly ) != 0;
+
+ // 縺昴ｂ縺昴ｂ縺薙ｓ縺ｪ譛驕ｩ蛹悶ｒ縺励↑縺上※繧医＞縺ｮ縺ｪ繧峨√＆縺｣縺輔→base縺ｫ蜃ｦ逅繧貞ｧ斐ｭ縺ｦ邨ゆｺ
+ if ( !b繧ｵ繧､繧ｺ縺ｯｼ偵ｮ邏ｯ荵励〒縺ｪ縺代ｌ縺ｰ縺ｪ繧峨↑縺 && b譚｡莉ｶ莉倥″縺ｧ繧ｵ繧､繧ｺ縺ｯｼ偵ｮ邏ｯ荵励〒縺ｪ縺上※繧０K )
+ {
+ //Debug.WriteLine( Path.GetFileName( str繝輔ぃ繧､繝ｫ蜷 ) + ": 譛驕ｩ蛹悶ｯ荳崎ｦ√〒縺吶" );
+ base.MakeTexture( device, str繝輔ぃ繧､繝ｫ蜷, format, b鮟偵ｒ騾城℃縺吶ｋ, pool );
+ return;
+ }
+
+ var information = ImageInformation.FromMemory( _txData );
+ int orgWidth = information.Width, orgHeight = information.Height;
+ int w = orgWidth, h = orgHeight, foldtimes;
+
+ #region [ 謚倥ｊ縺溘◆縺ｿ縺ゅｊ縺ｧ譛驕ｩ縺ｪ繝繧ｯ繧ｹ繝√Ε繧ｵ繧､繧ｺ縺後←縺縺ｪ繧九°繧堤｢ｺ隱阪☆繧(豁｣譁ｹ蠖｢縺ｫ縺吶ｋ縺九ｯ閠諷ｮ縺帙★) ]
+ if ( orgWidth >= orgHeight ) // 讓ｪ髟ｷ逕ｻ蜒上↑繧
+ {
+ this.b讓ｪ髟ｷ縺ｮ繝繧ｯ繧ｹ繝√Ε縺ｧ縺ゅｋ = true;
+ if ( !GetFoldedTextureSize( ref w, ref h, out foldtimes ) )
+ {
+//Debug.WriteLine( Path.GetFileName( str繝輔ぃ繧､繝ｫ蜷 ) + ": 譛驕ｩ蛹悶ｒ譁ｭ蠢ｵ縲" );
+ base.MakeTexture( device, str繝輔ぃ繧､繝ｫ蜷, format, b鮟偵ｒ騾城℃縺吶ｋ, pool );
+ return;
+ }
+ }
+ else // 邵ｦ髟ｷ逕ｻ蜒上↑繧
+ {
+ this.b讓ｪ髟ｷ縺ｮ繝繧ｯ繧ｹ繝√Ε縺ｧ縺ゅｋ = false;
+ if ( !GetFoldedTextureSize( ref h, ref w, out foldtimes ) ) // 邵ｦ讓ｪ蜈･繧梧崛縺医※蜻ｼ縺ｳ蜃ｺ縺
+ {
+//Debug.WriteLine( Path.GetFileName( str繝輔ぃ繧､繝ｫ蜷 ) + ": 譛驕ｩ蛹悶ｒ譁ｭ蠢ｵ縲" );
+ base.MakeTexture( device, str繝輔ぃ繧､繝ｫ蜷, format, b鮟偵ｒ騾城℃縺吶ｋ, pool );
+ return;
+ }
+ }
+ #endregion
+
+//Debug.WriteLine( Path.GetFileName( str繝輔ぃ繧､繝ｫ蜷 ) + ": texture譛驕ｩ蛹也ｵ先棡: width=" + w + ", height=" + h + ", 謚倥ｊ縺溘◆縺ｿ蝗樊焚=" + foldtimes );
+ #region [ 謚倥ｊ縺溘◆縺ｿ繝繧ｯ繧ｹ繝√Ε逕ｻ蜒上ｒ菴懊ｊ縲√ユ繧ｯ繧ｹ繝√Ε逋ｻ骭ｲ縺吶ｋ ]
+ // 繝舌う繝翫Μ(Byte驟榊)繧達itmap縺ｫ螟画鋤
+ MemoryStream mms = new MemoryStream( _txData );
+ Bitmap bmpOrg = new Bitmap( mms );
+ mms.Close();
+
+ Bitmap bmpNew = new Bitmap( w, h );
+ Graphics g = Graphics.FromImage( bmpNew );
+
+ for ( int n = 0; n <= foldtimes; n++ )
+ {
+ if ( b讓ｪ髟ｷ縺ｮ繝繧ｯ繧ｹ繝√Ε縺ｧ縺ゅｋ )
+ {
+ int x = n * w;
+ int currentHeight = n * orgHeight;
+ int currentWidth = ( n < foldtimes ) ? w : orgWidth - x;
+ Rectangle r = new Rectangle( x, 0, currentWidth, orgHeight );
+ Bitmap bmpTmp = bmpOrg.Clone( r, bmpOrg.PixelFormat ); // 縺薙％縺後懊ヨ繝ｫ繝阪ャ繧ｯ縺ｫ縺ｪ繧九ｈ縺縺ｪ繧峨∝ｾ梧律unsafe繧ｳ繝ｼ繝峨↓縺吶ｋ縲
+ g.DrawImage( bmpTmp, 0, currentHeight, currentWidth, orgHeight );
+ bmpTmp.Dispose();
+ }
+ else
+ {
+ int y = n * h;
+ int currentWidth = n * orgWidth;
+ int currentHeight = ( n < foldtimes ) ? h : orgHeight - y;
+ Rectangle r = new Rectangle( 0, y, orgWidth, currentHeight );
+ Bitmap bmpTmp = bmpOrg.Clone( r, bmpOrg.PixelFormat ); // 縺薙％縺後懊ヨ繝ｫ繝阪ャ繧ｯ縺ｫ縺ｪ繧九ｈ縺縺ｪ繧峨∝ｾ梧律unsafe繧ｳ繝ｼ繝峨↓縺吶ｋ縲
+ g.DrawImage( bmpTmp, currentWidth, 0, orgWidth, currentHeight );
+ bmpTmp.Dispose();
+ }
+ };
+ if ( b鮟偵ｒ騾城℃縺吶ｋ )
+ {
+ bmpNew.MakeTransparent( Color.Black );
+ }
+ g.Dispose();
+ g = null;
+ bmpOrg.Dispose();
+ bmpOrg = null;
+ base.MakeTexture( device, bmpNew, format, b鮟偵ｒ騾城℃縺吶ｋ, pool );
+ bmpNew.Dispose();
+ bmpNew = null;
+ #endregion
+
+ _orgWidth = orgWidth;
+ _orgHeight = orgHeight;
+ _foldtimes = foldtimes;
+ this.sz逕ｻ蜒上し繧､繧ｺ = new Size( orgWidth, orgHeight );
+ }
+
+ ///
+ /// 讓ｪ髟ｷ逕ｻ蜒上ｒ驕ｩ蛻縺ｪ繧ｵ繧､繧ｺ縺ｫ謚倥ｊ縺溘◆繧薙□縺ｨ縺阪ｮ譛驕ｩ繝繧ｯ繧ｹ繝√Ε繧ｵ繧､繧ｺ繧貞ｾ励ｋ縲
+ /// 邵ｦ髟ｷ逕ｻ蜒上↓蟇ｾ縺励※縺ｯ縲『idth/height繧貞･繧梧崛縺医※蜻ｼ縺ｳ蜃ｺ縺吶％縺ｨ縲
+ ///
+ ///
+ ///
+ ///
+ ///
+ private bool GetFoldedTextureSize( ref int width, ref int height, out int foldtimes )
+ {
+ int orgWidth = width, orgHeight = height;
+
+ #region [ width縺後2縺ｮ縺ｹ縺堺ｹ励°繧峨←繧後￥繧峨＞貅｢繧後※縺繧九°遒ｺ隱 ]
+ int pow = 1;
+ while ( orgWidth >= pow )
+ {
+ pow *= 2;
+ }
+ pow /= 2;
+ #endregion
+ #region [ 縺ｾ縺壹2縺ｮ縺ｹ縺堺ｹ励°繧峨≠縺ｵ繧後ｋ蛻繧呈釜繧願ｿ斐＠縺ｦ縲2縺ｮ縺ｹ縺堺ｹ励ｮ豁｣譁ｹ蠖｢繧ｵ繧､繧ｺ縺ｫ蜿弱∪繧九°繧堤｢ｺ隱 ]
+ foldtimes = ( orgWidth == pow ) ? 0 : 1; // 2縺ｮ縺ｹ縺堺ｹ励°繧峨ｮ貅｢繧後′縺ゅｌ縺ｰ縲√∪縺壹◎縺ｮ貅｢繧悟縺ｧ1蝗樊釜繧顔糞繧
+ if ( foldtimes != 0 )
+ {
+//Debug.WriteLine( "pow縺｡繧縺縺ｩ縺ｧ縺ｯ縺ｪ縺縺ｮ縺ｧ縲∵ｺ｢繧後≠繧翫ゅ∪縺壹ｯ1蝗樊釜繧翫◆縺溘縲" );
+ // 隧ｦ縺励↓縲『idth繧恥ow縺ｫ蛻繧願ｩｰ繧√1蝗樊釜繧願ｿ斐＠縺ｦ縺ｿ繧九
+ // width>height繧堤ｶｭ謖√＠縺ｦ縺繧九↑繧峨√ユ繧ｯ繧ｹ繝√Ε繧ｵ繧､繧ｺ縺ｯ繧医ｊ譛驕ｩ縺ｪ迥ｶ諷九↓縺ｪ縺｣縺溘→縺縺縺薙→縺ｫ縺ｪ繧九
+ if ( pow <= orgHeight * 2 ) // 譁ｰwidth > 譁ｰheight繧堤ｶｭ謖√〒縺阪↑縺上↑縺｣縺溘↑繧
+ { // 譛驕ｩ蛹紋ｸ榊庄縺ｨ縺ｿ縺ｪ縺励｜ase縺ｮ蜃ｦ逅縺ｫ蟋斐ｭ繧
+ return false;
+ }
+ }
+ #endregion
+ #region [ width > height 縺ｧ縺ｯ縺ｪ縺上↑繧九∪縺ｧ縲∵釜繧翫◆縺溘∩邯壹¢繧 ]
+ width = pow;
+ height = orgHeight * 2; // 蛻晄悄蛟､ｼ1蝗樊釜繧翫◆縺溘ｓ縺迥ｶ諷
+ do
+ {
+ width /= 2;
+ foldtimes = ( orgWidth / width ) + ( ( orgWidth % width > 0 ) ? 1 : 0 ) - 1;
+ height = orgHeight * ( foldtimes + 1 );
+ } while ( width > height );
+ width *= 2;
+ foldtimes = ( orgWidth / width ) + ( ( orgWidth % width > 0 ) ? 1 : 0 ) - 1;
+ height = orgHeight * ( foldtimes + 1 );
+ #endregion
+
+ return true;
+ }
+
+
+
+ ///
+ /// 繝繧ｯ繧ｹ繝√Ε繧 2D 逕ｻ蜒上→隕九↑縺励※謠冗判縺吶ｋ縲
+ ///
+ /// Direct3D9 繝繝舌う繧ｹ縲
+ /// 謠冗判菴咲ｽｮｼ医ユ繧ｯ繧ｹ繝√Ε縺ｮ蟾ｦ荳贋ｽ咲ｽｮ縺ｮ X 蠎ｧ讓兌dot]ｼ峨
+ /// 謠冗判菴咲ｽｮｼ医ユ繧ｯ繧ｹ繝√Ε縺ｮ蟾ｦ荳贋ｽ咲ｽｮ縺ｮ Y 蠎ｧ讓兌dot]ｼ峨
+ public new void t2D謠冗判( Device device, int x, int y )
+ {
+#if TEST_FOLDTEXTURE
+ base.t2D謠冗判( device, x, y, 1f, rc蜈ｨ逕ｻ蜒 );
+#else
+ for ( int n = 0; n <= _foldtimes; n++ )
+ {
+ Rectangle r;
+ if ( b讓ｪ髟ｷ縺ｮ繝繧ｯ繧ｹ繝√Ε縺ｧ縺ゅｋ )
+ {
+ int currentHeight = n * _orgHeight;
+ r = new Rectangle( 0, currentHeight, this.rc蜈ｨ逕ｻ蜒.Width, _orgHeight );
+ base.t2D謠冗判( device, x + n * this.rc蜈ｨ逕ｻ蜒.Width, y, 1f, r );
+ }
+ else
+ {
+ int currentWidth = n * _orgWidth;
+ r = new Rectangle( currentWidth, 0, _orgWidth, this.rc蜈ｨ逕ｻ蜒.Height );
+ base.t2D謠冗判( device, x, y + n * this.rc蜈ｨ逕ｻ蜒.Height, 1f, r );
+ }
+ }
+#endif
+ }
+ public new void t2D謠冗判( Device device, int x, int y, Rectangle rc )
+ {
+ Rectangle r;
+ if ( b讓ｪ髟ｷ縺ｮ繝繧ｯ繧ｹ繝√Ε縺ｧ縺ゅｋ )
+ {
+ int beginFold = rc.X / this.rc蜈ｨ逕ｻ蜒.Width;
+ int endFold = ( rc.X + rc.Width ) / rc蜈ｨ逕ｻ蜒.Width;
+ for ( int i = beginFold; i <= endFold; i++ )
+ {
+ if ( i > _foldtimes ) break;
+
+ int newRcY = i * _orgHeight + rc.Y;
+ int newRcX = ( i == beginFold ) ? ( rc.X % this.rc蜈ｨ逕ｻ蜒.Width ) : 0;
+ int newRcWidth = ( newRcX + rc.Width > rc蜈ｨ逕ｻ蜒.Width ) ? rc蜈ｨ逕ｻ蜒.Width - newRcX : rc.Width;
+
+ r = new Rectangle( newRcX, newRcY, newRcWidth, rc.Height );
+ base.t2D謠冗判( device, x, y, 1f, r );
+
+ int deltaX = ( i == beginFold ) ? ( i + 1 ) * rc蜈ｨ逕ｻ蜒.Width - rc.X : rc蜈ｨ逕ｻ蜒.Width;
+ int newWidth = rc.Width - deltaX;
+ x += deltaX;
+ rc.Width = newWidth;
+ }
+ }
+ else
+ {
+ int beginFold = rc.Y / this.rc蜈ｨ逕ｻ蜒.Height;
+ int endFold = ( rc.Y + rc.Height ) / rc蜈ｨ逕ｻ蜒.Height;
+ for ( int i = beginFold; i <= endFold; i++ )
+ {
+ if ( i > _foldtimes ) break;
+
+ int newRcX = i * _orgWidth + rc.X;
+ int newRcY = ( i == beginFold ) ? ( rc.Y % this.rc蜈ｨ逕ｻ蜒.Height ) : 0;
+ int newRcHeight = ( newRcY + rc.Height > rc蜈ｨ逕ｻ蜒.Height ) ? rc蜈ｨ逕ｻ蜒.Height - newRcY : rc.Height;
+
+ r = new Rectangle( newRcX, newRcY, rc.Width, newRcHeight );
+ base.t2D謠冗判( device, x, y, 1f, r );
+
+ int deltaY = ( i == beginFold ) ? ( i + 1 ) * rc蜈ｨ逕ｻ蜒.Height - rc.Y : rc蜈ｨ逕ｻ蜒.Height;
+ int newHeight = rc.Height - deltaY;
+ y += deltaY;
+ rc.Height = newHeight;
+ }
+ }
+
+ }
+ public new void t2D謠冗判( Device device, float x, float y )
+ {
+ t2D謠冗判( device, (int) x, (int) y );
+ }
+ public void t2D謠冗判( Device device, float x, float y, Rectangle rc )
+ {
+ t2D謠冗判( device, (int) x, (int) y, rc );
+ }
+
+ ///
+ /// 繝繧ｯ繧ｹ繝√Ε繧 2D 逕ｻ蜒上→隕九↑縺励※謠冗判縺吶ｋ縲
+ ///
+ /// Direct3D9 繝繝舌う繧ｹ縲
+ /// 謠冗判菴咲ｽｮｼ医ユ繧ｯ繧ｹ繝√Ε縺ｮ蟾ｦ荳贋ｽ咲ｽｮ縺ｮ X 蠎ｧ讓兌dot]ｼ峨
+ /// 謠冗判菴咲ｽｮｼ医ユ繧ｯ繧ｹ繝√Ε縺ｮ蟾ｦ荳贋ｽ咲ｽｮ縺ｮ Y 蠎ｧ讓兌dot]ｼ峨
+ public void t3D謠冗判( Device device, Matrix mat, float x, float y )
+ {
+#if TEST_FOLDTEXTURE
+ base.t2D謠冗判( device, x, y, 1f, rc蜈ｨ逕ｻ蜒 );
+#else
+ for ( int n = 0; n <= _foldtimes; n++ )
+ {
+ Rectangle r;
+ if ( b讓ｪ髟ｷ縺ｮ繝繧ｯ繧ｹ繝√Ε縺ｧ縺ゅｋ )
+ {
+ int currentHeight = n * _orgHeight;
+ r = new Rectangle( 0, currentHeight, this.rc蜈ｨ逕ｻ蜒.Width, _orgHeight );
+ base.t3D謠冗判( device, mat );
+ }
+ else
+ {
+ int currentWidth = n * _orgWidth;
+ r = new Rectangle( currentWidth, 0, _orgWidth, this.rc蜈ｨ逕ｻ蜒.Height );
+ base.t3D謠冗判( device, mat );
+ }
+ }
+#endif
+ }
+ public void t3D謠冗判( Device device, Matrix mat, float x, float y, Rectangle rc )
+ {
+ Rectangle r;
+ if ( b讓ｪ髟ｷ縺ｮ繝繧ｯ繧ｹ繝√Ε縺ｧ縺ゅｋ )
+ {
+ int beginFold = rc.X / this.rc蜈ｨ逕ｻ蜒.Width;
+ int endFold = ( rc.X + rc.Width ) / rc蜈ｨ逕ｻ蜒.Width;
+ for ( int i = beginFold; i <= endFold; i++ )
+ {
+ if ( i > _foldtimes ) break;
+
+ int newRcY = i * _orgHeight + rc.Y;
+ int newRcX = ( i == beginFold ) ? ( rc.X % this.rc蜈ｨ逕ｻ蜒.Width ) : 0;
+ int newRcWidth = ( newRcX + rc.Width > rc蜈ｨ逕ｻ蜒.Width ) ? rc蜈ｨ逕ｻ蜒.Width - newRcX : rc.Width;
+
+ r = new Rectangle( newRcX, newRcY, newRcWidth, rc.Height );
+ base.t3D謠冗判( device, mat, r );
+
+ int deltaX = ( i == beginFold ) ? ( i + 1 ) * rc蜈ｨ逕ｻ蜒.Width - rc.X : rc蜈ｨ逕ｻ蜒.Width;
+ int newWidth = rc.Width - deltaX;
+ x += deltaX;
+ rc.Width = newWidth;
+ }
+ }
+ else
+ {
+ int beginFold = rc.Y / this.rc蜈ｨ逕ｻ蜒.Height;
+ int endFold = ( rc.Y + rc.Height ) / rc蜈ｨ逕ｻ蜒.Height;
+ for ( int i = beginFold; i <= endFold; i++ )
+ {
+ if ( i > _foldtimes ) break;
+
+ int newRcX = i * _orgWidth + rc.X;
+ int newRcY = ( i == beginFold ) ? ( rc.Y % this.rc蜈ｨ逕ｻ蜒.Height ) : 0;
+ int newRcHeight = ( newRcY + rc.Height > rc蜈ｨ逕ｻ蜒.Height ) ? rc蜈ｨ逕ｻ蜒.Height - newRcY : rc.Height;
+
+ r = new Rectangle( newRcX, newRcY, rc.Width, newRcHeight );
+ base.t3D謠冗判( device, mat, r );
+
+ int deltaY = ( i == beginFold ) ? ( i + 1 ) * rc蜈ｨ逕ｻ蜒.Height - rc.Y : rc蜈ｨ逕ｻ蜒.Height;
+ int newHeight = rc.Height - deltaY;
+ y += deltaY;
+ rc.Height = newHeight;
+ }
+ }
+
+ }
+
+ #region [ private ]
+ //-----------------
+ private bool b讓ｪ髟ｷ縺ｮ繝繧ｯ繧ｹ繝√Ε縺ｧ縺ゅｋ;
+
+ ///
+ /// 蜈逕ｻ蜒上ｮWidth
+ ///
+ private int _orgWidth;
+ ///
+ /// 蜈逕ｻ蜒上ｮHeight
+ ///
+ private int _orgHeight;
+ ///
+ /// 謚倥ｊ縺溘◆縺ｿ蝗樊焚
+ ///
+ private int _foldtimes;
+ //-----------------
+ #endregion
+ }
+}
diff --git a/FDK19/繧ｳ繝ｼ繝/04.繧ｰ繝ｩ繝輔ぅ繝繧ｯ/CTextureCreateFailedException.cs b/FDK19/繧ｳ繝ｼ繝/04.繧ｰ繝ｩ繝輔ぅ繝繧ｯ/CTextureCreateFailedException.cs
new file mode 100644
index 00000000..1644e050
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/04.繧ｰ繝ｩ繝輔ぅ繝繧ｯ/CTextureCreateFailedException.cs
@@ -0,0 +1,29 @@
+ｻｿusing System;
+using System.Collections.Generic;
+using System.Text;
+using System.Runtime.Serialization;
+
+namespace FDK
+{
+ ///
+ /// 繝繧ｯ繧ｹ繝√Ε縺ｮ菴懈舌↓螟ｱ謨励＠縺ｾ縺励◆縲
+ ///
+ public class CTextureCreateFailedException : Exception
+ {
+ public CTextureCreateFailedException()
+ {
+ }
+ public CTextureCreateFailedException( string message )
+ : base( message )
+ {
+ }
+ public CTextureCreateFailedException( SerializationInfo info, StreamingContext context )
+ : base( info, context )
+ {
+ }
+ public CTextureCreateFailedException( string message, Exception innerException )
+ : base( message, innerException )
+ {
+ }
+ }
+}
diff --git a/FDK19/繧ｳ繝ｼ繝/04.繧ｰ繝ｩ繝輔ぅ繝繧ｯ/鬆らせ繝輔か繝ｼ繝槭ャ繝(Vertex)/ColoredVertex.cs b/FDK19/繧ｳ繝ｼ繝/04.繧ｰ繝ｩ繝輔ぅ繝繧ｯ/鬆らせ繝輔か繝ｼ繝槭ャ繝(Vertex)/ColoredVertex.cs
new file mode 100644
index 00000000..9bfe05d9
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/04.繧ｰ繝ｩ繝輔ぅ繝繧ｯ/鬆らせ繝輔か繝ｼ繝槭ャ繝(Vertex)/ColoredVertex.cs
@@ -0,0 +1,120 @@
+ｻｿ/*
+* Copyright (c) 2007-2010 SlimDX Group
+*
+* Permission is hereby granted, free of charge, to any person obtaining a copy
+* of this software and associated documentation files (the "Software"), to deal
+* in the Software without restriction, including without limitation the rights
+* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+* copies of the Software, and to permit persons to whom the Software is
+* furnished to do so, subject to the following conditions:
+*
+* The above copyright notice and this permission notice shall be included in
+* all copies or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+* THE SOFTWARE.
+*/
+
+using System;
+using System.Globalization;
+using System.Runtime.InteropServices;
+
+using SlimDX;
+
+namespace FDK {
+ ///
+ /// Represents a vertex with a position and a color.
+ ///
+ [StructLayout(LayoutKind.Sequential)]
+ public struct ColoredVertex : IEquatable {
+ ///
+ /// Gets or sets the position of the vertex.
+ ///
+ public Vector3 Position {
+ get;
+ set;
+ }
+
+ ///
+ /// Gets or sets the color of the vertex.
+ ///
+ public int Color {
+ get;
+ set;
+ }
+
+ ///
+ /// Initializes a new instance of the struct.
+ ///
+ /// The position.
+ /// The color.
+ public ColoredVertex(Vector3 position, int color)
+ : this() {
+ Position = position;
+ Color = color;
+ }
+
+ ///
+ /// Implements operator ==.
+ ///
+ /// The left.
+ /// The right.
+ /// The result of the operator.
+ public static bool operator ==(ColoredVertex left, ColoredVertex right) {
+ return left.Equals(right);
+ }
+
+ ///
+ /// Implements operator !=.
+ ///
+ /// The left side of the operator.
+ /// The right side of the operator.
+ /// The result of the operator.
+ public static bool operator !=(ColoredVertex left, ColoredVertex right) {
+ return !(left == right);
+ }
+
+ ///
+ /// Returns the hash code for this instance.
+ ///
+ ///
+ /// A 32-bit signed integer that is the hash code for this instance.
+ ///
+ public override int GetHashCode() {
+ return Position.GetHashCode() + Color.GetHashCode();
+ }
+
+ ///
+ /// Indicates whether this instance and a specified object are equal.
+ ///
+ /// Another object to compare to.
+ ///
+ /// true if and this instance are the same type and represent the same value; otherwise, false.
+ ///
+ public override bool Equals(object obj) {
+ if (obj == null)
+ return false;
+
+ if (GetType() != obj.GetType())
+ return false;
+
+ return Equals((ColoredVertex)obj);
+ }
+
+ ///
+ /// Indicates whether the current object is equal to another object of the same type.
+ ///
+ /// An object to compare with this object.
+ ///
+ /// true if the current object is equal to the parameter; otherwise, false.
+ ///
+ public bool Equals(ColoredVertex other) {
+ return (Position == other.Position && Color == other.Color);
+ }
+ }
+}
diff --git a/FDK19/繧ｳ繝ｼ繝/04.繧ｰ繝ｩ繝輔ぅ繝繧ｯ/鬆らせ繝輔か繝ｼ繝槭ャ繝(Vertex)/PositionColoredTexturedVertex.cs b/FDK19/繧ｳ繝ｼ繝/04.繧ｰ繝ｩ繝輔ぅ繝繧ｯ/鬆らせ繝輔か繝ｼ繝槭ャ繝(Vertex)/PositionColoredTexturedVertex.cs
new file mode 100644
index 00000000..ea0110cb
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/04.繧ｰ繝ｩ繝輔ぅ繝繧ｯ/鬆らせ繝輔か繝ｼ繝槭ャ繝(Vertex)/PositionColoredTexturedVertex.cs
@@ -0,0 +1,73 @@
+ｻｿusing System;
+using System.Collections.Generic;
+using System.Text;
+using System.Runtime.InteropServices;
+using System.Globalization;
+using SlimDX;
+using SlimDX.Direct3D9;
+
+namespace FDK
+{
+ [StructLayout( LayoutKind.Sequential )]
+ public struct PositionColoredTexturedVertex : IEquatable
+ {
+ public Vector3 Position;
+ public int Color;
+ public Vector2 TextureCoordinates;
+
+ public static int SizeInBytes
+ {
+ get
+ {
+ return Marshal.SizeOf( typeof( PositionColoredTexturedVertex ) );
+ }
+ }
+ public static VertexFormat Format
+ {
+ get
+ {
+ return ( VertexFormat.Texture1 | VertexFormat.Diffuse | VertexFormat.Position );
+ }
+ }
+ public PositionColoredTexturedVertex( Vector3 position, int color, Vector2 textureCoordinates )
+ {
+ this = new PositionColoredTexturedVertex();
+ this.Position = position;
+ this.Color = color;
+ this.TextureCoordinates = textureCoordinates;
+ }
+
+ public static bool operator ==( PositionColoredTexturedVertex left, PositionColoredTexturedVertex right )
+ {
+ return left.Equals( right );
+ }
+ public static bool operator !=( PositionColoredTexturedVertex left, PositionColoredTexturedVertex right )
+ {
+ return !( left == right );
+ }
+ public override int GetHashCode()
+ {
+ return ( ( this.Position.GetHashCode() + this.Color.GetHashCode() ) + this.TextureCoordinates.GetHashCode() );
+ }
+ public override bool Equals( object obj )
+ {
+ if( obj == null )
+ {
+ return false;
+ }
+ if( base.GetType() != obj.GetType() )
+ {
+ return false;
+ }
+ return this.Equals( (PositionColoredTexturedVertex) obj );
+ }
+ public bool Equals( PositionColoredTexturedVertex other )
+ {
+ return ( ( ( this.Position == other.Position ) && ( this.Color == other.Color ) ) && ( this.TextureCoordinates == other.TextureCoordinates ) );
+ }
+ public override string ToString()
+ {
+ return string.Format( CultureInfo.CurrentCulture, "{0} ({1}, {2})", new object[] { this.Position.ToString(), System.Drawing.Color.FromArgb( this.Color ).ToString(), this.TextureCoordinates.ToString() } );
+ }
+ }
+}
diff --git a/FDK19/繧ｳ繝ｼ繝/04.繧ｰ繝ｩ繝輔ぅ繝繧ｯ/鬆らせ繝輔か繝ｼ繝槭ャ繝(Vertex)/TexturedVertex.cs b/FDK19/繧ｳ繝ｼ繝/04.繧ｰ繝ｩ繝輔ぅ繝繧ｯ/鬆らせ繝輔か繝ｼ繝槭ャ繝(Vertex)/TexturedVertex.cs
new file mode 100644
index 00000000..22356fdc
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/04.繧ｰ繝ｩ繝輔ぅ繝繧ｯ/鬆らせ繝輔か繝ｼ繝槭ャ繝(Vertex)/TexturedVertex.cs
@@ -0,0 +1,120 @@
+ｻｿ/*
+* Copyright (c) 2007-2010 SlimDX Group
+*
+* Permission is hereby granted, free of charge, to any person obtaining a copy
+* of this software and associated documentation files (the "Software"), to deal
+* in the Software without restriction, including without limitation the rights
+* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+* copies of the Software, and to permit persons to whom the Software is
+* furnished to do so, subject to the following conditions:
+*
+* The above copyright notice and this permission notice shall be included in
+* all copies or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+* THE SOFTWARE.
+*/
+
+using System;
+using System.Globalization;
+using System.Runtime.InteropServices;
+
+using SlimDX;
+
+namespace FDK {
+ ///
+ /// Represents a vertex with a position and a texture coordinate.
+ ///
+ [StructLayout(LayoutKind.Sequential)]
+ public struct TexturedVertex : IEquatable {
+ ///
+ /// Gets or sets the position of the vertex.
+ ///
+ public Vector3 Position {
+ get;
+ set;
+ }
+
+ ///
+ /// Gets or sets the texture coordinate for the vertex.
+ ///
+ public Vector2 TextureCoordinate {
+ get;
+ set;
+ }
+
+ ///
+ /// Initializes a new instance of the struct.
+ ///
+ /// The position.
+ /// The color.
+ public TexturedVertex(Vector3 position, Vector2 textureCoordinate)
+ : this() {
+ Position = position;
+ TextureCoordinate = textureCoordinate;
+ }
+
+ ///
+ /// Implements operator ==.
+ ///
+ /// The left.
+ /// The right.
+ /// The result of the operator.
+ public static bool operator ==(TexturedVertex left, TexturedVertex right) {
+ return left.Equals(right);
+ }
+
+ ///
+ /// Implements operator !=.
+ ///
+ /// The left side of the operator.
+ /// The right side of the operator.
+ /// The result of the operator.
+ public static bool operator !=(TexturedVertex left, TexturedVertex right) {
+ return !(left == right);
+ }
+
+ ///
+ /// Returns the hash code for this instance.
+ ///
+ ///
+ /// A 32-bit signed integer that is the hash code for this instance.
+ ///
+ public override int GetHashCode() {
+ return Position.GetHashCode() + TextureCoordinate.GetHashCode();
+ }
+
+ ///
+ /// Indicates whether this instance and a specified object are equal.
+ ///
+ /// Another object to compare to.
+ ///
+ /// true if and this instance are the same type and represent the same value; otherwise, false.
+ ///
+ public override bool Equals(object obj) {
+ if (obj == null)
+ return false;
+
+ if (GetType() != obj.GetType())
+ return false;
+
+ return Equals((TexturedVertex)obj);
+ }
+
+ ///
+ /// Indicates whether the current object is equal to another object of the same type.
+ ///
+ /// An object to compare with this object.
+ ///
+ /// true if the current object is equal to the parameter; otherwise, false.
+ ///
+ public bool Equals(TexturedVertex other) {
+ return (Position == other.Position && TextureCoordinate == other.TextureCoordinate);
+ }
+ }
+}
diff --git a/FDK19/繧ｳ繝ｼ繝/04.繧ｰ繝ｩ繝輔ぅ繝繧ｯ/鬆らせ繝輔か繝ｼ繝槭ャ繝(Vertex)/TransformedColoredTexturedVertex.cs b/FDK19/繧ｳ繝ｼ繝/04.繧ｰ繝ｩ繝輔ぅ繝繧ｯ/鬆らせ繝輔か繝ｼ繝槭ャ繝(Vertex)/TransformedColoredTexturedVertex.cs
new file mode 100644
index 00000000..44ad7770
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/04.繧ｰ繝ｩ繝輔ぅ繝繧ｯ/鬆らせ繝輔か繝ｼ繝槭ャ繝(Vertex)/TransformedColoredTexturedVertex.cs
@@ -0,0 +1,73 @@
+ｻｿusing System;
+using System.Collections.Generic;
+using System.Text;
+using System.Runtime.InteropServices;
+using System.Globalization;
+using SlimDX;
+using SlimDX.Direct3D9;
+
+namespace FDK
+{
+ [StructLayout( LayoutKind.Sequential )]
+ public struct TransformedColoredTexturedVertex : IEquatable
+ {
+ public Vector4 Position;
+ public int Color;
+ public Vector2 TextureCoordinates;
+
+ public static int SizeInBytes
+ {
+ get
+ {
+ return Marshal.SizeOf( typeof( TransformedColoredTexturedVertex ) );
+ }
+ }
+ public static VertexFormat Format
+ {
+ get
+ {
+ return ( VertexFormat.Texture1 | VertexFormat.Diffuse | VertexFormat.PositionRhw );
+ }
+ }
+ public TransformedColoredTexturedVertex( Vector4 position, int color, Vector2 textureCoordinates )
+ {
+ this = new TransformedColoredTexturedVertex();
+ this.Position = position;
+ this.Color = color;
+ this.TextureCoordinates = textureCoordinates;
+ }
+
+ public static bool operator ==( TransformedColoredTexturedVertex left, TransformedColoredTexturedVertex right )
+ {
+ return left.Equals( right );
+ }
+ public static bool operator !=( TransformedColoredTexturedVertex left, TransformedColoredTexturedVertex right )
+ {
+ return !( left == right );
+ }
+ public override int GetHashCode()
+ {
+ return ( ( this.Position.GetHashCode() + this.Color.GetHashCode() ) + this.TextureCoordinates.GetHashCode() );
+ }
+ public override bool Equals( object obj )
+ {
+ if( obj == null )
+ {
+ return false;
+ }
+ if( base.GetType() != obj.GetType() )
+ {
+ return false;
+ }
+ return this.Equals( (TransformedColoredTexturedVertex) obj );
+ }
+ public bool Equals( TransformedColoredTexturedVertex other )
+ {
+ return ( ( ( this.Position == other.Position ) && ( this.Color == other.Color ) ) && ( this.TextureCoordinates == other.TextureCoordinates ) );
+ }
+ public override string ToString()
+ {
+ return string.Format( CultureInfo.CurrentCulture, "{0} ({1}, {2})", new object[] { this.Position.ToString(), System.Drawing.Color.FromArgb( this.Color ).ToString(), this.TextureCoordinates.ToString() } );
+ }
+ }
+}
diff --git a/FDK19/繧ｳ繝ｼ繝/04.繧ｰ繝ｩ繝輔ぅ繝繧ｯ/鬆らせ繝輔か繝ｼ繝槭ャ繝(Vertex)/TransformedColoredVertex.cs b/FDK19/繧ｳ繝ｼ繝/04.繧ｰ繝ｩ繝輔ぅ繝繧ｯ/鬆らせ繝輔か繝ｼ繝槭ャ繝(Vertex)/TransformedColoredVertex.cs
new file mode 100644
index 00000000..71bd1a7d
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/04.繧ｰ繝ｩ繝輔ぅ繝繧ｯ/鬆らせ繝輔か繝ｼ繝槭ャ繝(Vertex)/TransformedColoredVertex.cs
@@ -0,0 +1,120 @@
+ｻｿ/*
+* Copyright (c) 2007-2010 SlimDX Group
+*
+* Permission is hereby granted, free of charge, to any person obtaining a copy
+* of this software and associated documentation files (the "Software"), to deal
+* in the Software without restriction, including without limitation the rights
+* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+* copies of the Software, and to permit persons to whom the Software is
+* furnished to do so, subject to the following conditions:
+*
+* The above copyright notice and this permission notice shall be included in
+* all copies or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+* THE SOFTWARE.
+*/
+
+using System;
+using System.Globalization;
+using System.Runtime.InteropServices;
+
+using SlimDX;
+
+namespace FDK {
+ ///
+ /// Represents a vertex with a pre-transformed position and a color.
+ ///
+ [StructLayout(LayoutKind.Sequential)]
+ public struct TransformedColoredVertex : IEquatable {
+ ///
+ /// Gets or sets the pre-transformed position of the vertex.
+ ///
+ public Vector4 Position {
+ get;
+ set;
+ }
+
+ ///
+ /// Gets or sets the color of the vertex.
+ ///
+ public int Color {
+ get;
+ set;
+ }
+
+ ///
+ /// Initializes a new instance of the struct.
+ ///
+ /// The position.
+ /// The color.
+ public TransformedColoredVertex(Vector4 position, int color)
+ : this() {
+ Position = position;
+ Color = color;
+ }
+
+ ///
+ /// Implements operator ==.
+ ///
+ /// The left.
+ /// The right.
+ /// The result of the operator.
+ public static bool operator ==(TransformedColoredVertex left, TransformedColoredVertex right) {
+ return left.Equals(right);
+ }
+
+ ///
+ /// Implements operator !=.
+ ///
+ /// The left side of the operator.
+ /// The right side of the operator.
+ /// The result of the operator.
+ public static bool operator !=(TransformedColoredVertex left, TransformedColoredVertex right) {
+ return !(left == right);
+ }
+
+ ///
+ /// Returns the hash code for this instance.
+ ///
+ ///
+ /// A 32-bit signed integer that is the hash code for this instance.
+ ///
+ public override int GetHashCode() {
+ return Position.GetHashCode() + Color.GetHashCode();
+ }
+
+ ///
+ /// Indicates whether this instance and a specified object are equal.
+ ///
+ /// Another object to compare to.
+ ///
+ /// true if and this instance are the same type and represent the same value; otherwise, false.
+ ///
+ public override bool Equals(object obj) {
+ if (obj == null)
+ return false;
+
+ if (GetType() != obj.GetType())
+ return false;
+
+ return Equals((TransformedColoredVertex)obj);
+ }
+
+ ///
+ /// Indicates whether the current object is equal to another object of the same type.
+ ///
+ /// An object to compare with this object.
+ ///
+ /// true if the current object is equal to the parameter; otherwise, false.
+ ///
+ public bool Equals(TransformedColoredVertex other) {
+ return (Position == other.Position && Color == other.Color);
+ }
+ }
+}
diff --git a/FDK19/繧ｳ繝ｼ繝/05.DirectShow/CDStoWAVFileImage.cs b/FDK19/繧ｳ繝ｼ繝/05.DirectShow/CDStoWAVFileImage.cs
new file mode 100644
index 00000000..9a1bbbab
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/05.DirectShow/CDStoWAVFileImage.cs
@@ -0,0 +1,198 @@
+ｻｿusing System;
+using System.Collections.Generic;
+using System.Text;
+using System.IO;
+using System.Runtime.InteropServices;
+using System.Diagnostics;
+using DirectShowLib;
+using SharpDX.Multimedia;
+
+namespace FDK
+{
+ public class CDStoWAVFileImage
+ {
+ ///
+ /// 謖螳壹＆繧後◆蜍慕判繝輔ぃ繧､繝ｫ縺九ｉ髻ｳ螢ｰ縺ｮ縺ｿ繧偵お繝ｳ繧ｳ繝ｼ繝峨＠縲仝AV繝輔ぃ繧､繝ｫ繧､繝｡繝ｼ繧ｸ繧剃ｽ懈舌＠縺ｦ霑斐☆縲
+ ///
+ public static void t螟画鋤( string fileName, out byte[] wavFileImage )
+ {
+ int hr = 0;
+
+ IGraphBuilder graphBuilder = null;
+
+ try
+ {
+ graphBuilder = (IGraphBuilder) new FilterGraph();
+
+ #region [ 繧ｪ繝ｼ繝繧｣繧ｪ逕ｨ繧ｵ繝ｳ繝励Ν繧ｰ繝ｩ繝舌ｮ菴懈舌→霑ｽ蜉縲]
+ //-----------------
+ ISampleGrabber sampleGrabber = null;
+ try
+ {
+ sampleGrabber = (ISampleGrabber) new SampleGrabber();
+
+
+ // 繧ｵ繝ｳ繝励Ν繧ｰ繝ｩ繝舌ｮ繝｡繝繧｣繧｢繧ｿ繧､繝励ｮ險ｭ螳壹
+
+ var mediaType = new AMMediaType() {
+ majorType = MediaType.Audio,
+ subType = MediaSubType.PCM,
+ formatType = FormatType.WaveEx,
+ };
+ try
+ {
+ hr = sampleGrabber.SetMediaType( mediaType );
+ DsError.ThrowExceptionForHR( hr );
+ }
+ finally
+ {
+ if( mediaType != null )
+ DsUtils.FreeAMMediaType( mediaType );
+ }
+
+
+ // 繧ｵ繝ｳ繝励Ν繧ｰ繝ｩ繝舌ｮ繝舌ャ繝輔ぃ繝ｪ繝ｳ繧ｰ繧呈怏蜉ｹ縺ｫ縺吶ｋ縲
+
+ hr = sampleGrabber.SetBufferSamples( true );
+ DsError.ThrowExceptionForHR( hr );
+
+
+ // 繧ｵ繝ｳ繝励Ν繧ｰ繝ｩ繝舌↓繧ｳ繝ｼ繝ｫ繝舌ャ繧ｯ繧定ｿｽ蜉縺吶ｋ縲
+
+ sampleGrabberProc = new CSampleGrabberCallBack();
+ hr = sampleGrabber.SetCallback( sampleGrabberProc, 1 ); // 1:繧ｳ繝ｼ繝ｫ繝舌ャ繧ｯ縺ｮ BufferCB() 繝｡繧ｽ繝繝峨ｮ譁ｹ繧貞他縺ｳ蜃ｺ縺吶
+
+
+ // 繧ｵ繝ｳ繝励Ν繧ｰ繝ｩ繝舌ｒ繧ｰ繝ｩ繝輔↓霑ｽ蜉縺吶ｋ縲
+
+ hr = graphBuilder.AddFilter( (IBaseFilter) sampleGrabber, "SampleGrabber for Audio/PCM" );
+ DsError.ThrowExceptionForHR( hr );
+ }
+ finally
+ {
+ C蜈ｱ騾.tCOM繧ｪ繝悶ず繧ｧ繧ｯ繝医ｒ隗｣謾ｾ縺吶ｋ( ref sampleGrabber );
+ }
+ //-----------------
+ #endregion
+
+ var e = new DirectShowLib.DsROTEntry( graphBuilder );
+
+ // fileName 縺九ｉ繧ｰ繝ｩ繝輔ｒ閾ｪ蜍慕函謌舌
+
+ hr = graphBuilder.RenderFile( fileName, null ); // IMediaControl.RenderFile() 縺ｯ謗ｨ螂ｨ縺輔ｌ縺ｪ縺
+ DsError.ThrowExceptionForHR( hr );
+
+
+ // 繝薙ョ繧ｪ繝ｬ繝ｳ繝繝ｩ繧帝勁蜴ｻ縲
+
+ CDirectShow.t繝薙ョ繧ｪ繝ｬ繝ｳ繝繝ｩ繧偵げ繝ｩ繝輔°繧蛾勁蜴ｻ縺吶ｋ( graphBuilder ); // 繧ｪ繝ｼ繝繧｣繧ｪ繝ｬ繝ｳ繝繝ｩ繧誰ull縺ｫ螟峨∴繧九ｈ繧雁燕縺ｫ螳溯｡後☆繧九％縺ｨ縲ゑｼCDirectShow.t繧ｪ繝ｼ繝繧｣繧ｪ繝ｬ繝ｳ繝繝ｩ繧誰ull繝ｬ繝ｳ繝繝ｩ縺ｫ螟峨∴縺ｦ繝輔か繝ｼ繝槭ャ繝医ｒ蜿門ｾ励☆繧() 縺ｮ荳ｭ縺ｧ荳蠎ｦ蜀咲函縺吶ｋ縺ｮ縺ｧ縲√◎縺ｮ縺ｨ縺阪↓Active繧ｦ繧｣繝ｳ繝峨え縺瑚｡ｨ遉ｺ縺輔ｌ縺ｦ縺励∪縺縺溘ａ縲ゑｼ
+
+
+ // 繧ｪ繝ｼ繝繧｣繧ｪ繝ｬ繝ｳ繝繝ｩ繧 NullRenderer 縺ｫ鄂ｮ謠帙
+
+ WaveFormat wfx;
+ byte[] wfx諡｡蠑ｵ鬆伜沺;
+ CDirectShow.t繧ｪ繝ｼ繝繧｣繧ｪ繝ｬ繝ｳ繝繝ｩ繧誰ull繝ｬ繝ｳ繝繝ｩ縺ｫ螟峨∴縺ｦ繝輔か繝ｼ繝槭ャ繝医ｒ蜿門ｾ励☆繧( graphBuilder, out wfx, out wfx諡｡蠑ｵ鬆伜沺 );
+
+
+ // 蝓ｺ貅悶け繝ｭ繝繧ｯ繧 NULLｼ域怙鬮倬滂ｼ峨↓險ｭ螳壹☆繧九
+
+ IMediaFilter mediaFilter = graphBuilder as IMediaFilter;
+ mediaFilter.SetSyncSource( null );
+ mediaFilter = null;
+
+
+ // 繝｡繝｢繝ｪ繧ｹ繝医Μ繝ｼ繝縺ｫ繝繧ｳ繝ｼ繝峨ョ繝ｼ繧ｿ繧貞ｺ蜉帙☆繧九
+
+ sampleGrabberProc.MemoryStream = new MemoryStream(); // CDirectShow.t繧ｪ繝ｼ繝繧｣繧ｪ繝ｬ繝ｳ繝繝ｩ繧誰ull繝ｬ繝ｳ繝繝ｩ縺ｫ螟峨∴縺ｦ繝輔か繝ｼ繝槭ャ繝医ｒ蜿門ｾ励☆繧() 縺ｧ荳蠎ｦ蜀咲函縺励※縺繧九ｮ縺ｧ縲√せ繝医Μ繝ｼ繝繧偵け繝ｪ繧｢縺吶ｋ縲
+ var ms = sampleGrabberProc.MemoryStream;
+ var bw = new BinaryWriter( ms );
+ bw.Write( new byte[] { 0x52, 0x49, 0x46, 0x46 } ); // 'RIFF'
+ bw.Write( (UInt32) 0 ); // 繝輔ぃ繧､繝ｫ繧ｵ繧､繧ｺ - 8 [byte]ｼ帑ｻ翫ｯ荳肴弱↑縺ｮ縺ｧ蠕後〒荳頑嶌縺阪☆繧九
+ bw.Write( new byte[] { 0x57, 0x41, 0x56, 0x45 } ); // 'WAVE'
+ bw.Write( new byte[] { 0x66, 0x6D, 0x74, 0x20 } ); // 'fmt '
+ bw.Write( (UInt32) ( 16 + ( ( wfx諡｡蠑ｵ鬆伜沺.Length > 0 ) ? ( 2/*sizeof(WAVEFORMATEX.cbSize)*/ + wfx諡｡蠑ｵ鬆伜沺.Length ) : 0 ) ) ); // fmt繝√Ε繝ｳ繧ｯ縺ｮ繧ｵ繧､繧ｺ[byte]
+ bw.Write( (UInt16) wfx.Encoding); // 繝輔か繝ｼ繝槭ャ繝IDｼ医Μ繝九いPCM縺ｪ繧1ｼ
+ bw.Write( (UInt16) wfx.Channels ); // 繝√Ε繝ｳ繝阪Ν謨ｰ
+ bw.Write( (UInt32) wfx.SampleRate); // 繧ｵ繝ｳ繝励Μ繝ｳ繧ｰ繝ｬ繝ｼ繝
+ bw.Write( (UInt32) wfx.AverageBytesPerSecond ); // 繝繝ｼ繧ｿ騾溷ｺｦ
+ bw.Write( (UInt16) wfx.BlockAlign); // 繝悶Ο繝繧ｯ繧ｵ繧､繧ｺ
+ bw.Write( (UInt16) wfx.BitsPerSample ); // 繧ｵ繝ｳ繝励Ν縺ゅ◆繧翫ｮ繝薙ャ繝域焚
+ if( wfx諡｡蠑ｵ鬆伜沺.Length > 0 )
+ {
+ bw.Write( (UInt16) wfx諡｡蠑ｵ鬆伜沺.Length ); // 諡｡蠑ｵ鬆伜沺縺ｮ繧ｵ繧､繧ｺ[byte]
+ bw.Write( wfx諡｡蠑ｵ鬆伜沺 ); // 諡｡蠑ｵ繝繝ｼ繧ｿ
+ }
+ bw.Write( new byte[] { 0x64, 0x61, 0x74, 0x61 } ); // 'data'
+ int nDATA繝√Ε繝ｳ繧ｯ繧ｵ繧､繧ｺ菴咲ｽｮ = (int) ms.Position;
+ bw.Write( (UInt32) 0 ); // data繝√Ε繝ｳ繧ｯ縺ｮ繧ｵ繧､繧ｺ[byte]ｼ帑ｻ翫ｯ荳肴弱↑縺ｮ縺ｧ蠕後〒荳頑嶌縺阪☆繧九
+
+ #region [ 蜀咲函繧帝幕蟋九＠縲∫ｵゆｺ繧貞ｾ縺､縲- 蜀咲函荳ｭ縲《ampleGrabberProc.MemoryStream 縺ｫ PCM 繝繝ｼ繧ｿ縺瑚塘遨阪＆繧後※縺縺上]
+ //-----------------
+ IMediaControl mediaControl = graphBuilder as IMediaControl;
+ mediaControl.Run(); // 蜀咲函髢句ｧ
+
+ IMediaEvent mediaEvent = graphBuilder as IMediaEvent;
+ EventCode eventCode;
+ hr = mediaEvent.WaitForCompletion( -1, out eventCode );
+ DsError.ThrowExceptionForHR( hr );
+ if( eventCode != EventCode.Complete )
+ throw new Exception( "蜀咲函蠕縺｡縺ｫ螟ｱ謨励＠縺ｾ縺励◆縲" );
+
+ mediaControl.Stop();
+ mediaEvent = null;
+ mediaControl = null;
+ //-----------------
+ #endregion
+
+ bw.Seek( 4, SeekOrigin.Begin );
+ bw.Write( (UInt32) ms.Length - 8 ); // 繝輔ぃ繧､繝ｫ繧ｵ繧､繧ｺ - 8 [byte]
+
+ bw.Seek( nDATA繝√Ε繝ｳ繧ｯ繧ｵ繧､繧ｺ菴咲ｽｮ, SeekOrigin.Begin );
+ bw.Write( (UInt32) ms.Length - ( nDATA繝√Ε繝ｳ繧ｯ繧ｵ繧､繧ｺ菴咲ｽｮ + 4 ) ); // data繝√Ε繝ｳ繧ｯ繧ｵ繧､繧ｺ [byte]
+
+
+ // 蜃ｺ蜉帙◎縺ｮｼ偵ｒ菴懈舌
+
+ wavFileImage = ms.ToArray();
+
+
+ // 邨ゆｺ蜃ｦ逅縲
+
+ bw.Close();
+ sampleGrabberProc.Dispose(); // ms.Close()
+ }
+ finally
+ {
+ C蜈ｱ騾.tCOM繧ｪ繝悶ず繧ｧ繧ｯ繝医ｒ隗｣謾ｾ縺吶ｋ( ref graphBuilder );
+ }
+ }
+
+ #region [ private ]
+ //-----------------
+ private class CSampleGrabberCallBack : ISampleGrabberCB, IDisposable
+ {
+ public MemoryStream MemoryStream = new MemoryStream();
+
+ public int BufferCB( double SampleTime, IntPtr pBuffer, int BufferLen )
+ {
+ var bytes = new byte[ BufferLen ];
+ Marshal.Copy( pBuffer, bytes, 0, BufferLen ); // unmanage 竊 manage
+ this.MemoryStream.Write( bytes, 0, BufferLen ); // byte[] 竊 Stream
+ return CWin32.S_OK;
+ }
+ public int SampleCB( double SampleTime, IMediaSample pSample )
+ {
+ throw new NotImplementedException( "螳溯｣縺輔ｌ縺ｦ縺縺ｾ縺帙ｓ縲" );
+ }
+
+ public void Dispose()
+ {
+ this.MemoryStream.Close();
+ }
+ }
+ private static CSampleGrabberCallBack sampleGrabberProc = null;
+ //-----------------
+ #endregion
+ }
+}
diff --git a/FDK19/繧ｳ繝ｼ繝/05.DirectShow/CDirectShow.cs b/FDK19/繧ｳ繝ｼ繝/05.DirectShow/CDirectShow.cs
new file mode 100644
index 00000000..b7ca2f2d
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/05.DirectShow/CDirectShow.cs
@@ -0,0 +1,1610 @@
+ｻｿusing System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+using System.IO;
+using System.Drawing;
+using System.Drawing.Imaging;
+using System.Threading;
+using SlimDX;
+using SlimDX.Direct3D9;
+using SharpDX.Multimedia;
+using DirectShowLib;
+
+namespace FDK
+{
+ ///
+ /// DirectShow繧堤畑縺縺溘け繝ｪ繝繝暦ｼ亥虚逕ｻｼ矩浹螢ｰｼ峨ｒ謇ｱ縺縲
+ /// ｼ代▽縺ｮ繧ｯ繝ｪ繝繝励↓縺､縺搾ｼ代▽縺ｮ CDirectShow 繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ繧堤函謌舌☆繧九
+ /// 蜀咲函縺ｮ髢句ｧ九ｄ蛛懈ｭ｢縺ｪ縺ｩ縺ｮ謫堺ｽ懊ｮ莉悶∽ｻｻ諢上ｮ譎らせ縺ｧ繧ｹ繝翫ャ繝励う繝｡繝ｼ繧ｸ繧貞叙蠕励☆繧九％縺ｨ縺後〒縺阪ｋ縲
+ ///
+ public class CDirectShow : IDisposable
+ {
+ // 繝励Ο繝代ユ繧｣
+
+ public const uint WM_DSGRAPHNOTIFY = CWin32.WM_APP + 1;
+
+ public enum E繧ｰ繝ｩ繝輔ｮ迥ｶ諷 { 螳悟ｨ蛛懈ｭ｢荳ｭ, 蜀咲函縺ｮ縺ｿ蛛懈ｭ｢荳ｭ, 蜀咲函荳ｭ, 螳悟ｨ蛛懈ｭ｢縺ｸ驕ｷ遘ｻ荳ｭ, 蜀咲函縺ｮ縺ｿ蛛懈ｭ｢縺ｸ驕ｷ遘ｻ荳ｭ, 蜀咲函縺ｸ驕ｷ遘ｻ荳ｭ, 譛ｪ螳 }
+ public E繧ｰ繝ｩ繝輔ｮ迥ｶ諷 e繧ｰ繝ｩ繝輔ｮ迥ｶ諷
+ {
+ get
+ {
+ var status = E繧ｰ繝ｩ繝輔ｮ迥ｶ諷.譛ｪ螳;
+
+ if( this.MediaCtrl != null )
+ {
+ FilterState fs;
+ int hr = this.MediaCtrl.GetState( 0, out fs ); // 縺昴ｌ縺ｪ繧翫↓驥阪◆縺縺ｮ縺ｧ豕ｨ諢上
+
+ if( hr == CWin32.E_FAIL )
+ {
+ #region [ 螟ｱ謨励]
+ //-----------------
+ status = E繧ｰ繝ｩ繝輔ｮ迥ｶ諷.譛ｪ螳;
+ //-----------------
+ #endregion
+ }
+ else if( hr == CWin32.VFW_S_STATE_INTERMEDIATE )
+ {
+ #region [ 驕ｷ遘ｻ荳ｭ縲]
+ //-----------------
+ switch( fs )
+ {
+ case FilterState.Running:
+ status = E繧ｰ繝ｩ繝輔ｮ迥ｶ諷.蜀咲函縺ｸ驕ｷ遘ｻ荳ｭ;
+ break;
+
+ case FilterState.Paused:
+ status = E繧ｰ繝ｩ繝輔ｮ迥ｶ諷.蜀咲函縺ｮ縺ｿ蛛懈ｭ｢縺ｸ驕ｷ遘ｻ荳ｭ;
+ break;
+
+ case FilterState.Stopped:
+ status = E繧ｰ繝ｩ繝輔ｮ迥ｶ諷.螳悟ｨ蛛懈ｭ｢縺ｸ驕ｷ遘ｻ荳ｭ;
+ break;
+
+ default:
+ status = E繧ｰ繝ｩ繝輔ｮ迥ｶ諷.譛ｪ螳;
+ break;
+ }
+ //-----------------
+ #endregion
+ }
+ else
+ {
+ #region [ 螳牙ｮ夂憾諷九]
+ //-----------------
+ switch( fs )
+ {
+ case FilterState.Running:
+ status = E繧ｰ繝ｩ繝輔ｮ迥ｶ諷.蜀咲函荳ｭ;
+ break;
+
+ case FilterState.Paused:
+ status = E繧ｰ繝ｩ繝輔ｮ迥ｶ諷.蜀咲函縺ｮ縺ｿ蛛懈ｭ｢荳ｭ;
+ break;
+
+ case FilterState.Stopped:
+ status = E繧ｰ繝ｩ繝輔ｮ迥ｶ諷.螳悟ｨ蛛懈ｭ｢荳ｭ;
+ break;
+
+ default:
+ status = E繧ｰ繝ｩ繝輔ｮ迥ｶ諷.譛ｪ螳;
+ break;
+ }
+ //-----------------
+ #endregion
+ }
+ }
+ return status;
+ }
+ }
+ public bool b蜀咲函荳ｭ;
+ public bool b繝ｫ繝ｼ繝怜咲函;
+
+ public int n蟷px
+ {
+ get;
+ protected set;
+ }
+ public int n鬮倥＆px
+ {
+ get;
+ protected set;
+ }
+ public int n繧ｹ繧ｭ繝｣繝ｳ繝ｩ繧､繝ｳ蟷byte
+ {
+ get;
+ protected set;
+ }
+ public int n繝繝ｼ繧ｿ繧ｵ繧､繧ｺbyte
+ {
+ get;
+ protected set;
+ }
+ public bool b荳贋ｸ句渚霆｢
+ {
+ get;
+ protected set;
+ }
+
+ public bool b髻ｳ螢ｰ縺ｮ縺ｿ
+ {
+ get;
+ protected set;
+ }
+
+ public long n迴ｾ蝨ｨ縺ｮ繧ｰ繝ｩ繝輔ｮ蜀咲函菴咲ｽｮms
+ {
+ get
+ {
+ if( this.MediaSeeking == null )
+ return 0;
+
+ long current;
+ int hr = this.MediaSeeking.GetCurrentPosition( out current );
+ DsError.ThrowExceptionForHR( hr );
+ return (long) ( current / ( 1000.0 * 10.0 ) );
+ }
+ }
+ ///
+ /// 辟｡髻ｳ:0ｽ100:蜴滄浹縲Ｔet 縺ｮ縺ｿ縲
+ ///
+ public int n髻ｳ驥
+ {
+ get
+ {
+ return this._n髻ｳ驥;
+ }
+ set
+ {
+ if( this.BasicAudio == null )
+ return;
+
+
+ // 蛟､繧剃ｿ晏ｭ倥
+
+ this._n髻ｳ驥 = value;
+
+
+ // 繝ｪ繝九い髻ｳ驥上ｒ繝繧ｷ繝吶Ν髻ｳ驥上↓螟画鋤縲
+
+ int n髻ｳ驥重b = 0;
+
+ if( value == 0 )
+ {
+ n髻ｳ驥重b = -10000; // 螳悟ｨ辟｡髻ｳ
+ }
+ else
+ {
+ n髻ｳ驥重b = (int) ( ( 20.0 * Math.Log10( ( (double) value ) / 100.0 ) ) * 100.0 );
+ }
+
+
+ // 繝繧ｷ繝吶Ν髻ｳ驥上〒繧ｰ繝ｩ繝輔ｮ髻ｳ驥上ｒ螟画峩縲
+
+ this.BasicAudio.put_Volume( n髻ｳ驥重b );
+ }
+ }
+ ///
+ /// 蟾ｦ:-100ｽ樔ｸｭ螟ｮ:0ｽ100:蜿ｳ縲Ｔet 縺ｮ縺ｿ縲
+ ///
+ public int n菴咲ｽｮ
+ {
+ set
+ {
+ if( this.BasicAudio == null )
+ return;
+
+ // 繝ｪ繝九い菴咲ｽｮ繧偵ョ繧ｷ繝吶Ν菴咲ｽｮ縺ｫ螟画鋤縲
+
+ int n菴咲ｽｮ = Math.Min( Math.Max( value, -100 ), +100 );
+ int n菴咲ｽｮdb = 0;
+
+ if( n菴咲ｽｮ == 0 )
+ {
+ n菴咲ｽｮdb = 0;
+ }
+ else if( n菴咲ｽｮ == -100 )
+ {
+ n菴咲ｽｮdb = -10000;
+ }
+ else if( n菴咲ｽｮ == 100 )
+ {
+ n菴咲ｽｮdb = +10000;
+ }
+ else if( n菴咲ｽｮ < 0 )
+ {
+ n菴咲ｽｮdb = (int) ( ( 20.0 * Math.Log10( ( (double) ( n菴咲ｽｮ + 100 ) ) / 100.0 ) ) * 100.0 );
+ }
+ else
+ {
+ n菴咲ｽｮdb = (int) ( ( -20.0 * Math.Log10( ( (double) ( 100 - n菴咲ｽｮ ) ) / 100.0 ) ) * 100.0 );
+ }
+
+ // 繝繧ｷ繝吶Ν菴咲ｽｮ縺ｧ繧ｰ繝ｩ繝輔ｮ菴咲ｽｮ繧貞､画峩縲
+
+ this.BasicAudio.put_Balance( n菴咲ｽｮdb );
+ }
+ }
+ public IMediaControl MediaCtrl;
+ public IMediaEventEx MediaEventEx;
+ public IMediaSeeking MediaSeeking;
+ public IBasicAudio BasicAudio;
+ public IGraphBuilder graphBuilder;
+
+ ///
+ /// CDirectShow繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｫ蝗ｺ譛峨ｮID縲
+ /// DirectShow 繧､繝吶Φ繝医ｒ繧ｦ繧｣繝ｳ繝峨え縺ｫ逋ｺ菫｡縺吶ｋ髫帙｀essageID 縺ｨ縺励※ "WM_APP+繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹID" 繧堤匱菫｡縺吶ｋ縲
+ /// 縺薙ｌ縺ｫ繧医ｊ縲∝女縺大ｴ縺ｧ繧､繝吶Φ繝育匱菫｡繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ繧堤音螳壹☆繧九％縺ｨ縺悟庄閭ｽ縺ｫ縺ｪ繧九
+ ///
+ public int n繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹID
+ {
+ get;
+ protected set;
+ }
+
+
+ // 繝｡繧ｽ繝繝
+
+ public CDirectShow()
+ {
+ }
+ public CDirectShow( string fileName, IntPtr hWnd, bool b繧ｪ繝ｼ繝繧｣繧ｪ繝ｬ繝ｳ繝繝ｩ縺ｪ縺 )
+ {
+ // 蛻晄悄蛹悶
+
+ this.n蟷px = 0;
+ this.n鬮倥＆px = 0;
+ this.b荳贋ｸ句渚霆｢ = false;
+ this.n繧ｹ繧ｭ繝｣繝ｳ繝ｩ繧､繝ｳ蟷byte = 0;
+ this.n繝繝ｼ繧ｿ繧ｵ繧､繧ｺbyte = 0;
+ this.b髻ｳ螢ｰ縺ｮ縺ｿ = false;
+ this.graphBuilder = null;
+ this.MediaCtrl = null;
+ this.b蜀咲函荳ｭ = false;
+ this.b繝ｫ繝ｼ繝怜咲函 = false;
+
+
+ // 髱咏噪繝ｪ繧ｹ繝医↓逋ｻ骭ｲ縺励√う繝ｳ繧ｹ繧ｿ繝ｳ繧ｹID繧貞ｾ励ｋ縲
+
+ CDirectShow.t繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ繧堤匳骭ｲ縺吶ｋ( this );
+
+
+ // 荳ｦ蛻怜ｦ逅貅門ｙ縲
+
+ if( CDirectShow.n荳ｦ蛻怜ｺｦ == 0 ) // 邂怜ｺ縺後∪縺縺ｪ繧臥ｮ怜ｺ縺吶ｋ縲
+ CDirectShow.n荳ｦ蛻怜ｺｦ = Environment.ProcessorCount; // 荳ｦ蛻怜ｺｦｼ戮PU謨ｰ縺ｨ縺吶ｋ縲
+
+ unsafe
+ {
+ this.dg繝ｩ繧､繝ｳ謠冗判ARGB32 = new DG繝ｩ繧､繝ｳ謠冗判[ CDirectShow.n荳ｦ蛻怜ｺｦ ];
+ this.dg繝ｩ繧､繝ｳ謠冗判XRGB32 = new DG繝ｩ繧､繝ｳ謠冗判[ CDirectShow.n荳ｦ蛻怜ｺｦ ];
+
+ for( int i = 0; i < CDirectShow.n荳ｦ蛻怜ｺｦ; i++ )
+ {
+ this.dg繝ｩ繧､繝ｳ謠冗判ARGB32[ i ] = new DG繝ｩ繧､繝ｳ謠冗判( this.t繝ｩ繧､繝ｳ謠冗判ARGB32 );
+ this.dg繝ｩ繧､繝ｳ謠冗判XRGB32[ i ] = new DG繝ｩ繧､繝ｳ謠冗判( this.t繝ｩ繧､繝ｳ謠冗判XRGB32 );
+ }
+ }
+
+ try
+ {
+ int hr = 0;
+
+
+ // 繧ｰ繝ｩ繝輔ン繝ｫ繝繧堤函謌舌
+
+ this.graphBuilder = (IGraphBuilder) new FilterGraph();
+#if DEBUG
+ // ROT 縺ｸ縺ｮ逋ｻ骭ｲ縲
+ this.rot = new DsROTEntry( graphBuilder );
+#endif
+
+
+ // QueryInterface縲ょｭ伜惠縺励↑縺代ｌ縺ｰ null縲
+
+ this.MediaCtrl = this.graphBuilder as IMediaControl;
+ this.MediaEventEx = this.graphBuilder as IMediaEventEx;
+ this.MediaSeeking = this.graphBuilder as IMediaSeeking;
+ this.BasicAudio = this.graphBuilder as IBasicAudio;
+
+
+ // IMemoryRenderer 繧偵げ繝ｩ繝輔↓謖ｿ蜈･縲
+
+ AMMediaType mediaType = null;
+
+ this.memoryRendererObject = new MemoryRenderer();
+ this.memoryRenderer = (IMemoryRenderer) this.memoryRendererObject;
+ var baseFilter = (IBaseFilter) this.memoryRendererObject;
+
+ hr = this.graphBuilder.AddFilter( baseFilter, "MemoryRenderer" );
+ DsError.ThrowExceptionForHR( hr );
+
+
+ // fileName 縺九ｉ繧ｰ繝ｩ繝輔ｒ閾ｪ蜍慕函謌舌
+
+ hr = this.graphBuilder.RenderFile( fileName, null ); // IMediaControl.RenderFile() 縺ｯ謗ｨ螂ｨ縺輔ｌ縺ｪ縺
+ DsError.ThrowExceptionForHR( hr );
+
+
+ // 髻ｳ螢ｰ縺ｮ縺ｿｼ
+
+ {
+ IBaseFilter videoRenderer;
+ IPin videoInputPin;
+ IBaseFilter audioRenderer;
+ IPin audioInputPin;
+#if MemoryRenderer
+ CDirectShow.t繝薙ョ繧ｪ繝ｬ繝ｳ繝繝ｩ縺ｨ縺昴ｮ蜈･蜉帙ヴ繝ｳ繧呈爾縺励※霑斐☆( this.graphBuilder, out videoRenderer, out videoInputPin );
+#else
+ CDirectShow.SearchMMRenderers( this.graphBuilder, out videoRenderer, out videoInputPin, out audioRenderer, out audioInputPin );
+#endif
+ if( videoRenderer == null && audioRenderer != null )
+ this.b髻ｳ螢ｰ縺ｮ縺ｿ = true;
+ else
+ {
+ C蜈ｱ騾.tCOM繧ｪ繝悶ず繧ｧ繧ｯ繝医ｒ隗｣謾ｾ縺吶ｋ( ref videoInputPin );
+ C蜈ｱ騾.tCOM繧ｪ繝悶ず繧ｧ繧ｯ繝医ｒ隗｣謾ｾ縺吶ｋ( ref videoRenderer );
+ C蜈ｱ騾.tCOM繧ｪ繝悶ず繧ｧ繧ｯ繝医ｒ隗｣謾ｾ縺吶ｋ( ref audioInputPin );
+ C蜈ｱ騾.tCOM繧ｪ繝悶ず繧ｧ繧ｯ繝医ｒ隗｣謾ｾ縺吶ｋ( ref audioRenderer );
+ }
+ }
+
+
+ // 繧､繝｡繝ｼ繧ｸ諠蝣ｱ繧貞叙蠕励
+
+ if( !this.b髻ｳ螢ｰ縺ｮ縺ｿ )
+ {
+ long n;
+ int m;
+ this.memoryRenderer.GetWidth( out n );
+ this.n蟷px = (int) n;
+ this.memoryRenderer.GetHeight( out n );
+ this.n鬮倥＆px = (int) n;
+ this.memoryRenderer.IsBottomUp( out m );
+ this.b荳贋ｸ句渚霆｢ = ( m != 0 );
+ this.memoryRenderer.GetBufferSize( out n );
+ this.n繝繝ｼ繧ｿ繧ｵ繧､繧ｺbyte = (int) n;
+ this.n繧ｹ繧ｭ繝｣繝ｳ繝ｩ繧､繝ｳ蟷byte = (int) this.n繝繝ｼ繧ｿ繧ｵ繧､繧ｺbyte / this.n鬮倥＆px;
+ // C蜈ｱ騾.tCOM繧ｪ繝悶ず繧ｧ繧ｯ繝医ｒ隗｣謾ｾ縺吶ｋ( ref baseFilter ); 縺ｪ繧薙°繧ｭ繝｣繧ｹ繝亥縺ｮ繧ｪ繝悶ず繧ｧ繧ｯ繝医∪縺ｧ隗｣謾ｾ縺輔ｌ繧九ｮ縺ｧ隗｣謾ｾ遖∵ｭ｢縲
+ }
+
+
+ // 繧ｰ繝ｩ繝輔ｒ菫ｮ豁｣縺吶ｋ縲
+
+ if( b繧ｪ繝ｼ繝繧｣繧ｪ繝ｬ繝ｳ繝繝ｩ縺ｪ縺 )
+ {
+ WaveFormat dummy1;
+ byte[] dummy2;
+ CDirectShow.t繧ｪ繝ｼ繝繧｣繧ｪ繝ｬ繝ｳ繝繝ｩ繧誰ull繝ｬ繝ｳ繝繝ｩ縺ｫ螟峨∴縺ｦ繝輔か繝ｼ繝槭ャ繝医ｒ蜿門ｾ励☆繧( this.graphBuilder, out dummy1, out dummy2 );
+ }
+
+
+ // 縺昴ｮ莉悶ｮ蜃ｦ逅縲
+
+ this.t蜀咲函貅門ｙ髢句ｧ(); // 1蝗樔ｻ･荳 IMediaControl 繧貞他縺ｳ蜃ｺ縺励※縺ｪ縺縺ｨ縲！ReferenceClock 縺ｯ蜿門ｾ励〒縺阪↑縺縲
+ this.t驕ｷ遘ｻ螳御ｺ縺ｾ縺ｧ蠕縺｣縺ｦ迥ｶ諷九ｒ蜿門ｾ励☆繧(); // 螳悟ｨ縺ｫ Pause 縺ｸ驕ｷ遘ｻ縺吶ｋ縺ｮ繧貞ｾ縺､縲ゑｼ育腸蠅萓晏ｭ假ｼ
+
+
+ // 繧､繝吶Φ繝育畑繧ｦ繧｣繝ｳ繝峨え繝上Φ繝峨Ν繧定ｨｭ螳壹
+
+ this.MediaEventEx.SetNotifyWindow( hWnd, (int) WM_DSGRAPHNOTIFY, new IntPtr( this.n繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹID ) );
+ }
+#if !DEBUG
+ catch( Exception e )
+ {
+ C蜈ｱ騾.t萓句､悶ｮ隧ｳ邏ｰ繧偵Ο繧ｰ縺ｫ蜃ｺ蜉帙☆繧( e );
+ this.Dispose();
+ throw; // 萓句､也匱蜃ｺ縲
+ }
+#endif
+ finally
+ {
+ }
+ }
+
+ public void t蜀咲函貅門ｙ髢句ｧ()
+ {
+ if( this.MediaCtrl != null )
+ {
+ int hr = this.MediaCtrl.Pause(); // 蜀咲函貅門ｙ繧帝幕蟋九☆繧九ゅ％縺薙〒縺ｯ貅門ｙ縺悟ｮ御ｺ縺吶ｋ縺ｾ縺ｧ蠕縺溘↑縺縲
+ DsError.ThrowExceptionForHR( hr );
+ }
+ }
+ public void t蜀咲函髢句ｧ()
+ {
+ if( this.MediaCtrl != null && --this.n蜀咲函荳譎ょ●豁｢蜻ｼ縺ｳ蜃ｺ縺励ｮ邏ｯ遨榊屓謨ｰ <= 0 )
+ {
+ //this.t驕ｷ遘ｻ螳御ｺ縺ｾ縺ｧ蠕縺｣縺ｦ迥ｶ諷九ｒ蜿門ｾ励☆繧(); // 蜀咲函貅門ｙｼ医□繧阪≧ｼ峨′縺ｾ縺螳御ｺ縺励※縺ｪ縺代ｌ縺ｰ縲∝ｾ縺､縲 竊 諢丞､悶→驥阪＞蜃ｦ逅縺ｪ縺ｮ縺ｧ螟夜Κ縺ｧ蛻､譁ｭ縺励※螳溯｡後☆繧九ｈ縺螟画峩縺吶ｋ縲(2011.8.7)
+
+ int hr = this.MediaCtrl.Run(); // 蜀咲函髢句ｧ九
+ DsError.ThrowExceptionForHR( hr );
+
+ this.n蜀咲函荳譎ょ●豁｢蜻ｼ縺ｳ蜃ｺ縺励ｮ邏ｯ遨榊屓謨ｰ = 0; // 荳譎ょ●豁｢蝗樊焚縺ｯ縺薙％縺ｧ繝ｪ繧ｻ繝繝医＆繧後ｋ縲
+ this.b蜀咲函荳ｭ = true;
+ }
+ }
+ public void t蜀咲函荳譎ょ●豁｢()
+ {
+ if( this.MediaCtrl != null && this.n蜀咲函荳譎ょ●豁｢蜻ｼ縺ｳ蜃ｺ縺励ｮ邏ｯ遨榊屓謨ｰ == 0 )
+ {
+ int hr = this.MediaCtrl.Pause();
+ DsError.ThrowExceptionForHR( hr );
+ }
+ this.n蜀咲函荳譎ょ●豁｢蜻ｼ縺ｳ蜃ｺ縺励ｮ邏ｯ遨榊屓謨ｰ++;
+ this.b蜀咲函荳ｭ = false;
+ }
+ public void t蜀咲函蛛懈ｭ｢()
+ {
+ if( this.MediaCtrl != null )
+ {
+ int hr = this.MediaCtrl.Stop();
+ DsError.ThrowExceptionForHR( hr );
+ }
+
+ // 谺｡縺ｸ縺ｮ貅門ｙ縲
+ //this.t蜀咲函菴咲ｽｮ繧貞､画峩縺吶ｋ( 0.0 ); 竊 繧医ｊ邏ｰ縺九￥蛻ｶ蠕｡縺吶ｋ縺溘ａ縺ｫ縲：DK螟夜Κ縺ｧ蛻ｶ蠕｡縺吶ｋ繧医≧縺ｫ螟画峩縲(2011.8.7)
+ //this.t蜀咲函貅門ｙ髢句ｧ();
+
+ this.n蜀咲函荳譎ょ●豁｢蜻ｼ縺ｳ蜃ｺ縺励ｮ邏ｯ遨榊屓謨ｰ = 0; // 蛛懈ｭ｢縺吶ｋ縺ｨ縲∽ｸ譎ょ●豁｢蜻ｼ縺ｳ蜃ｺ縺礼ｴｯ遨榊屓謨ｰ縺ｯ繝ｪ繧ｻ繝繝医＆繧後ｋ縲
+ this.b蜀咲函荳ｭ = false;
+ }
+ public void t蜀咲函菴咲ｽｮ繧貞､画峩( double db蜀咲函菴咲ｽｮms )
+ {
+ if( this.MediaSeeking == null )
+ return;
+
+ int hr = this.MediaSeeking.SetPositions(
+ DsLong.FromInt64( (long) ( db蜀咲函菴咲ｽｮms * 1000.0 * 10.0 ) ),
+ AMSeekingSeekingFlags.AbsolutePositioning,
+ null,
+ AMSeekingSeekingFlags.NoPositioning );
+
+ DsError.ThrowExceptionForHR( hr );
+ }
+ public void t譛蛻昴°繧牙咲函髢句ｧ()
+ {
+ this.t蜀咲函菴咲ｽｮ繧貞､画峩( 0.0 );
+ this.t蜀咲函髢句ｧ();
+ }
+ public E繧ｰ繝ｩ繝輔ｮ迥ｶ諷 t驕ｷ遘ｻ螳御ｺ縺ｾ縺ｧ蠕縺｣縺ｦ迥ｶ諷九ｒ蜿門ｾ励☆繧()
+ {
+ var status = E繧ｰ繝ｩ繝輔ｮ迥ｶ諷.譛ｪ螳;
+
+ if( this.MediaCtrl != null )
+ {
+ FilterState fs;
+ int hr = this.MediaCtrl.GetState( 1000, out fs ); // 驕ｷ遘ｻ螳御ｺ縺ｾ縺ｧ譛螟ｧ1000ms蠕縺､縲
+ }
+ return this.e繧ｰ繝ｩ繝輔ｮ迥ｶ諷;
+ }
+ public unsafe void t迴ｾ譎らせ縺ｫ縺翫¢繧区怙譁ｰ縺ｮ繧ｹ繝翫ャ繝励う繝｡繝ｼ繧ｸ繧探exture縺ｫ霆｢蜀吶☆繧( CTexture texture )
+ {
+ int hr;
+
+ #region [ 蜀咲函縺励※縺ｪ縺縺ｪ繧我ｽ輔ｂ縺帙★蟶ｰ驍縲ゑｼ井ｸ譎ょ●豁｢荳ｭ縺ｯOK縲ゑｼ云
+ //-----------------
+ if( !this.b蜀咲函荳ｭ )
+ return;
+ //-----------------
+ #endregion
+ #region [ 髻ｳ螢ｰ縺ｮ縺ｿ縺ｪ繧我ｽ輔ｂ縺励↑縺縲]
+ //-----------------
+ if( this.b髻ｳ螢ｰ縺ｮ縺ｿ )
+ return;
+ //-----------------
+ #endregion
+
+ DataRectangle dr = texture.texture.LockRectangle( 0, LockFlags.Discard );
+ try
+ {
+ if( this.n繧ｹ繧ｭ繝｣繝ｳ繝ｩ繧､繝ｳ蟷byte == dr.Pitch )
+ {
+ #region [ (A) 繝斐ャ繝√′蜷医≧縺ｮ縺ｧ縲√ユ繧ｯ繧ｹ繝√Ε縺ｫ逶ｴ謗･霆｢騾√☆繧九]
+ //-----------------
+ hr = this.memoryRenderer.GetCurrentBuffer( dr.Data.DataPointer, this.n繝繝ｼ繧ｿ繧ｵ繧､繧ｺbyte );
+ DsError.ThrowExceptionForHR( hr );
+ //-----------------
+ #endregion
+ }
+ else
+ {
+ this.b荳贋ｸ句渚霆｢ = false; // 縺薙■繧峨ｮ譁ｹ豕輔〒縺ｯ蟶ｸ縺ｫ豁｣蟶ｸ
+
+ #region [ (B) 繝斐ャ繝√′蜷医ｏ縺ｪ縺縺ｮ縺ｧ縲√Γ繝｢繝ｪ縺ｫ霆｢騾√＠縺ｦ縺九ｉ繝繧ｯ繧ｹ繝√Ε縺ｫ霆｢騾√☆繧九]
+ //-----------------
+
+ #region [ IMemoryRenderer 縺九ｉ繝舌ャ繝輔ぃ縺ｫ繧､繝｡繝ｼ繧ｸ繝繝ｼ繧ｿ繧定ｪｭ縺ｿ霎ｼ繧縲]
+ //-----------------
+ if( this.ip == IntPtr.Zero )
+ this.ip = Marshal.AllocCoTaskMem( this.n繝繝ｼ繧ｿ繧ｵ繧､繧ｺbyte );
+
+ hr = this.memoryRenderer.GetCurrentBuffer( this.ip, this.n繝繝ｼ繧ｿ繧ｵ繧､繧ｺbyte );
+ DsError.ThrowExceptionForHR( hr );
+ //-----------------
+ #endregion
+
+ #region [ 繝繧ｯ繧ｹ繝√Ε縺ｫ繧ｹ繝翫ャ繝励う繝｡繝ｼ繧ｸ繧定ｻ｢騾√]
+ //-----------------
+ bool bARGB32 = true;
+
+ switch( texture.Format )
+ {
+ case Format.A8R8G8B8:
+ bARGB32 = true;
+ break;
+
+ case Format.X8R8G8B8:
+ bARGB32 = false;
+ break;
+
+ default:
+ return; // 譛ｪ蟇ｾ蠢懊ｮ繝輔か繝ｼ繝槭ャ繝医ｯ辟｡隕悶
+ }
+
+ // 繧ｹ繝ｬ繝繝峨励ｼ繝ｫ繧剃ｽｿ縺｣縺ｦ荳ｦ蛻苓ｻ｢騾√☆繧区ｺ門ｙ縲
+
+ this.ptrSnap = (byte*) this.ip.ToPointer();
+ var ptr = stackalloc UInt32*[ CDirectShow.n荳ｦ蛻怜ｺｦ ]; // stackallocｼGC蟇ｾ雎｡螟悶√Γ繧ｽ繝繝臥ｵゆｺ譎ゅ↓閾ｪ蜍暮幕謾ｾｼ峨ｯ縲√せ繧ｿ繝繧ｯ螟画焚逶ｸ謇九↓縺励°菴ｿ縺医↑縺縲
+ ptr[ 0 ] = (UInt32*) dr.Data.DataPointer.ToPointer(); // 竊
+ for( int i = 1; i < CDirectShow.n荳ｦ蛻怜ｺｦ; i++ ) // 繧ｹ繧ｿ繝繧ｯ螟画焚縺ｧ遒ｺ菫昴∝晄悄蛹悶＠縺ｦ窶ｦ
+ ptr[ i ] = ptr[ i - 1 ] + this.n蟷px; // 竊
+ this.ptrTexture = ptr; // 繧ｹ繧ｿ繝繧ｯ螟画焚繧偵け繝ｩ繧ｹ繝｡繝ｳ繝舌↓貂｡縺呻ｼ医％繧後↑繧碓Kｼ峨
+
+
+ // 荳ｦ蛻怜ｺｦ縺鯉ｼ代↑繧峨す繝ｳ繧ｰ繝ｫ繧ｹ繝ｬ繝繝峨ｼ剃ｻ･荳翫↑繧峨槭Ν繝√せ繝ｬ繝繝峨〒霆｢騾√☆繧九
+ // 竊 CPU縺鯉ｼ代▽縺ｮ蝣ｴ蜷医√ｏ縺悶ｏ縺悶せ繝ｬ繝繝峨励ｼ繝ｫ縺ｮ繧ｹ繝ｬ繝繝峨〒蜃ｦ逅縺吶ｋ縺ｮ縺ｯ辟｡鬧縲
+
+ if( CDirectShow.n荳ｦ蛻怜ｺｦ == 1 )
+ {
+ if( bARGB32 )
+ this.t繝ｩ繧､繝ｳ謠冗判ARGB32( 0 );
+ else
+ this.t繝ｩ繧､繝ｳ謠冗判XRGB32( 0 );
+ }
+ else
+ {
+ // 霆｢騾髢句ｧ九
+
+ var ar = new IAsyncResult[ CDirectShow.n荳ｦ蛻怜ｺｦ ];
+ for( int i = 0; i < CDirectShow.n荳ｦ蛻怜ｺｦ; i++ )
+ {
+ ar[ i ] = ( bARGB32 ) ?
+ this.dg繝ｩ繧､繝ｳ謠冗判ARGB32[ i ].BeginInvoke( i, null, null ) :
+ this.dg繝ｩ繧､繝ｳ謠冗判XRGB32[ i ].BeginInvoke( i, null, null );
+ }
+
+
+ // 霆｢騾∝ｮ御ｺ蠕縺｡縲
+
+ for( int i = 0; i < CDirectShow.n荳ｦ蛻怜ｺｦ; i++ )
+ {
+ if( bARGB32 )
+ this.dg繝ｩ繧､繝ｳ謠冗判ARGB32[ i ].EndInvoke( ar[ i ] );
+ else
+ this.dg繝ｩ繧､繝ｳ謠冗判XRGB32[ i ].EndInvoke( ar[ i ] );
+ }
+ }
+
+ this.ptrSnap = null;
+ this.ptrTexture = null;
+ //-----------------
+ #endregion
+
+ //-----------------
+ #endregion
+ }
+ }
+ finally
+ {
+ texture.texture.UnlockRectangle( 0 );
+ }
+ }
+
+ private IntPtr ip = IntPtr.Zero;
+
+ public static void t繧ｰ繝ｩ繝輔ｒ隗｣譫舌＠繝繝舌ャ繧ｰ蜃ｺ蜉帙☆繧( IGraphBuilder graphBuilder )
+ {
+ if( graphBuilder == null )
+ {
+ Debug.WriteLine( "謖螳壹＆繧後◆繧ｰ繝ｩ繝輔′ null 縺ｧ縺吶" );
+ return;
+ }
+
+ int hr = 0;
+
+ IEnumFilters eFilters;
+ hr = graphBuilder.EnumFilters( out eFilters );
+ DsError.ThrowExceptionForHR( hr );
+ {
+ var filters = new IBaseFilter[ 1 ];
+ while( eFilters.Next( 1, filters, IntPtr.Zero ) == CWin32.S_OK )
+ {
+ FilterInfo filterInfo;
+ hr = filters[ 0 ].QueryFilterInfo( out filterInfo );
+ DsError.ThrowExceptionForHR( hr );
+ {
+ Debug.WriteLine( filterInfo.achName ); // 繝輔ぅ繝ｫ繧ｿ蜷崎｡ｨ遉ｺ縲
+ if( filterInfo.pGraph != null )
+ C蜈ｱ騾.tCOM繧ｪ繝悶ず繧ｧ繧ｯ繝医ｒ隗｣謾ｾ縺吶ｋ( ref filterInfo.pGraph );
+ }
+
+ IEnumPins ePins;
+ hr = filters[ 0 ].EnumPins( out ePins );
+ DsError.ThrowExceptionForHR( hr );
+ {
+ var pins = new IPin[ 1 ];
+ while( ePins.Next( 1, pins, IntPtr.Zero ) == CWin32.S_OK )
+ {
+ PinInfo pinInfo;
+ hr = pins[ 0 ].QueryPinInfo( out pinInfo );
+ DsError.ThrowExceptionForHR( hr );
+ {
+ Debug.Write( " " + pinInfo.name ); // 繝斐Φ蜷崎｡ｨ遉ｺ縲
+ Debug.Write( ( pinInfo.dir == PinDirection.Input ) ? " 竊 " : " 竊 " );
+
+ IPin connectPin;
+ hr = pins[ 0 ].ConnectedTo( out connectPin );
+ if( hr != CWin32.S_OK )
+ Debug.WriteLine( "(譛ｪ謗･邯)" );
+ else
+ {
+ DsError.ThrowExceptionForHR( hr );
+
+ PinInfo connectPinInfo;
+ hr = connectPin.QueryPinInfo( out connectPinInfo );
+ DsError.ThrowExceptionForHR( hr );
+ {
+ FilterInfo connectFilterInfo;
+ hr = connectPinInfo.filter.QueryFilterInfo( out connectFilterInfo );
+ DsError.ThrowExceptionForHR( hr );
+ {
+ Debug.Write( "[" + connectFilterInfo.achName + "]." ); // 謗･邯壼医ヵ繧｣繝ｫ繧ｿ蜷
+
+ if( connectFilterInfo.pGraph != null )
+ C蜈ｱ騾.tCOM繧ｪ繝悶ず繧ｧ繧ｯ繝医ｒ隗｣謾ｾ縺吶ｋ( ref connectFilterInfo.pGraph );
+ }
+
+ Debug.WriteLine( connectPinInfo.name ); // 謗･邯壼医ヴ繝ｳ蜷
+ if( connectPinInfo.filter != null )
+ C蜈ｱ騾.tCOM繧ｪ繝悶ず繧ｧ繧ｯ繝医ｒ隗｣謾ｾ縺吶ｋ( ref connectPinInfo.filter );
+ DsUtils.FreePinInfo( connectPinInfo );
+ }
+ C蜈ｱ騾.tCOM繧ｪ繝悶ず繧ｧ繧ｯ繝医ｒ隗｣謾ｾ縺吶ｋ( ref connectPin );
+ }
+ if( pinInfo.filter != null )
+ C蜈ｱ騾.tCOM繧ｪ繝悶ず繧ｧ繧ｯ繝医ｒ隗｣謾ｾ縺吶ｋ( ref pinInfo.filter );
+ DsUtils.FreePinInfo( pinInfo );
+ }
+ C蜈ｱ騾.tCOM繧ｪ繝悶ず繧ｧ繧ｯ繝医ｒ隗｣謾ｾ縺吶ｋ( ref pins[ 0 ] );
+ }
+ }
+ C蜈ｱ騾.tCOM繧ｪ繝悶ず繧ｧ繧ｯ繝医ｒ隗｣謾ｾ縺吶ｋ( ref ePins );
+
+ C蜈ｱ騾.tCOM繧ｪ繝悶ず繧ｧ繧ｯ繝医ｒ隗｣謾ｾ縺吶ｋ( ref filters[ 0 ] );
+ }
+ }
+ C蜈ｱ騾.tCOM繧ｪ繝悶ず繧ｧ繧ｯ繝医ｒ隗｣謾ｾ縺吶ｋ( ref eFilters );
+
+ Debug.Flush();
+ }
+ public static void t繧ｪ繝ｼ繝繧｣繧ｪ繝ｬ繝ｳ繝繝ｩ繧誰ull繝ｬ繝ｳ繝繝ｩ縺ｫ螟峨∴縺ｦ繝輔か繝ｼ繝槭ャ繝医ｒ蜿門ｾ励☆繧( IGraphBuilder graphBuilder, out WaveFormat wfx, out byte[] wfx諡｡蠑ｵ繝繝ｼ繧ｿ )
+ {
+ int hr = 0;
+
+ IBaseFilter audioRenderer = null;
+ IPin rendererInputPin = null;
+ IPin rendererConnectedOutputPin = null;
+ IBaseFilter nullRenderer = null;
+ IPin nullRendererInputPin = null;
+ wfx = null;
+ wfx諡｡蠑ｵ繝繝ｼ繧ｿ = new byte[ 0 ];
+
+ try
+ {
+ // audioRenderer 繧呈爾縺吶
+
+ audioRenderer = CDirectShow.t繧ｪ繝ｼ繝繧｣繧ｪ繝ｬ繝ｳ繝繝ｩ繧呈爾縺励※霑斐☆( graphBuilder );
+ if( audioRenderer == null )
+ return; // 縺ｪ縺九▲縺
+
+ #region [ 髻ｳ驥上ぞ繝ｭ縺ｧ荳蠎ｦ蜀咲函縺吶ｋ縲ゑｼ医が繝ｼ繝繧｣繧ｪ繝ｬ繝ｳ繝繝ｩ縺ｮ蜈･蜉帙ヴ繝ｳMediaType縺後∵磁邯壽凾縺ｨ縺ｯ逡ｰ縺ｪ繧九梧ｭ｣縺励＞繧ゅｮ縲阪↓螟峨ｏ繧句庄閭ｽ諤ｧ縺後≠繧九◆繧√ゑｼ云
+ //-----------------
+ {
+ // 縺薙％縺ｫ譚･縺滓凾轤ｹ縺ｧ縲√げ繝ｩ繝輔ｮ繝薙ョ繧ｪ繝ｬ繝ｳ繝繝ｩ縺ｯ辟｡蜉ｹ蛹厄ｼNullRenderer縺ｸ縺ｮ鄂ｮ謠帙ｄ髯､蜴ｻ縺ｪ縺ｩｼ峨＠縺ｦ縺翫￥縺薙→縲
+ // 縺輔ｂ縺ｪ縺縺ｨ縲ヾtopWhenReady() 譎ゅ↓荳迸ｬ縺縺 Active繧ｦ繧｣繝ｳ繝峨え縺瑚｡ｨ遉ｺ縺輔ｌ縺ｦ縺励∪縺縲
+
+ var mediaCtrl = (IMediaControl) graphBuilder;
+ var basicAudio = (IBasicAudio) graphBuilder;
+
+ basicAudio.put_Volume( -10000 ); // 譛蟆城浹驥
+
+
+ // 繧ｰ繝ｩ繝輔ｒ蜀咲函縺励※縺吶＄豁｢繧√ｋ縲ゑｼPaused 竊 Stopped 縺ｸ驕ｷ遘ｻ縺吶ｋｼ
+
+ mediaCtrl.StopWhenReady();
+
+
+ // 繧ｰ繝ｩ繝輔′ Stopped 縺ｫ驕ｷ遘ｻ螳御ｺ縺吶ｋ縺ｾ縺ｧ蠕縺､縲ゑｼStopWhenReady() 縺ｯ繧ｰ繝ｩ繝輔′ Stopped 縺ｫ縺ｪ繧九ｮ繧貞ｾ縺溘★縺ｫ蟶ｰ縺｣縺ｦ縺上ｋ縲ゑｼ
+
+ FilterState fs = FilterState.Paused;
+ hr = CWin32.S_FALSE;
+ while( fs != FilterState.Stopped || hr != CWin32.S_OK )
+ hr = mediaCtrl.GetState( 10, out fs );
+
+
+ // 邨ゆｺ蜃ｦ逅縲
+
+ basicAudio.put_Volume( 0 ); // 譛螟ｧ髻ｳ驥
+
+ basicAudio = null;
+ mediaCtrl = null;
+ }
+ //-----------------
+ #endregion
+
+ // audioRenderer 縺ｮ蜈･蜉帙ヴ繝ｳ繧呈爾縺吶
+
+ rendererInputPin = t譛蛻昴ｮ蜈･蜉帙ヴ繝ｳ繧呈爾縺励※霑斐☆( audioRenderer );
+ if( rendererInputPin == null )
+ return;
+
+
+ // WAVE繝輔か繝ｼ繝槭ャ繝医ｒ蜿門ｾ励＠縲『fx 蠑墓焚縺ｸ譬ｼ邏阪☆繧九
+
+ var type = new AMMediaType();
+ hr = rendererInputPin.ConnectionMediaType( type );
+ DsError.ThrowExceptionForHR( hr );
+ try
+ {
+ wfx = new WaveFormat();
+
+ #region [ type.formatPtr 縺九ｉ wfx 縺ｫ縲∵僑蠑ｵ鬆伜沺繧帝勁縺上ョ繝ｼ繧ｿ繧偵さ繝斐ｼ縺吶ｋ縲]
+ //-----------------
+ var wfxTemp = new WaveFormatEx(); // SlimDX.Multimedia.WaveFormat 縺ｯ Marshal.PtrToStructure() 縺ｧ菴ｿ縺医↑縺縺ｮ縺ｧ縲√◎繧後′菴ｿ縺医ｋ DirectShowLib.WaveFormatEx 繧剃ｻ九＠縺ｦ蜿門ｾ励☆繧九ゑｼ磯擇蛟停ｦｼ
+ Marshal.PtrToStructure( type.formatPtr, (object) wfxTemp );
+ wfx = WaveFormat.CreateCustomFormat((WaveFormatEncoding)wfxTemp.wFormatTag, wfxTemp.nSamplesPerSec, wfxTemp.nChannels, wfxTemp.nAvgBytesPerSec, wfxTemp.nBlockAlign, wfxTemp.wBitsPerSample);
+ //-----------------
+ #endregion
+ #region [ 諡｡蠑ｵ鬆伜沺縺悟ｭ伜惠縺吶ｋ縺ｪ繧峨◎繧後ｒ wfx諡｡蠑ｵ繝繝ｼ繧ｿ 縺ｫ譬ｼ邏阪☆繧九 ]
+ //-----------------
+ int nWaveFormatEx譛ｬ菴薙し繧､繧ｺ = 16 + 2; // sizeof( WAVEFORMAT ) + sizof( WAVEFORMATEX.cbSize )
+ int n縺ｯ縺ｿ蜃ｺ縺励し繧､繧ｺbyte = type.formatSize - nWaveFormatEx譛ｬ菴薙し繧､繧ｺ;
+
+ if( n縺ｯ縺ｿ蜃ｺ縺励し繧､繧ｺbyte > 0 )
+ {
+ wfx諡｡蠑ｵ繝繝ｼ繧ｿ = new byte[ n縺ｯ縺ｿ蜃ｺ縺励し繧､繧ｺbyte ];
+ var hGC = GCHandle.Alloc( wfx諡｡蠑ｵ繝繝ｼ繧ｿ, GCHandleType.Pinned ); // 蜍輔￥縺ｪ繧医ｼ
+ unsafe
+ {
+ byte* src = (byte*) type.formatPtr.ToPointer();
+ byte* dst = (byte*) hGC.AddrOfPinnedObject().ToPointer();
+ CWin32.CopyMemory( dst, src + nWaveFormatEx譛ｬ菴薙し繧､繧ｺ, (uint) n縺ｯ縺ｿ蜃ｺ縺励し繧､繧ｺbyte );
+ }
+ hGC.Free();
+ }
+ //-----------------
+ #endregion
+ }
+ finally
+ {
+ if( type != null )
+ DsUtils.FreeAMMediaType( type );
+ }
+
+
+ // audioRenderer 縺ｫ縺､縺ｪ縺後ｋ蜃ｺ蜉帙ヴ繝ｳ繧呈爾縺吶
+
+ hr = rendererInputPin.ConnectedTo( out rendererConnectedOutputPin );
+ DsError.ThrowExceptionForHR( hr );
+
+
+ // audioRenderer 繧偵げ繝ｩ繝輔°繧牙譁ｭ縺吶ｋ縲
+
+ rendererInputPin.Disconnect();
+ rendererConnectedOutputPin.Disconnect();
+
+
+ // audioRenderer 繧偵げ繝ｩ繝輔°繧蛾勁蜴ｻ縺吶ｋ縲
+
+ hr = graphBuilder.RemoveFilter( audioRenderer );
+ DsError.ThrowExceptionForHR( hr );
+
+
+ // nullRenderer 繧剃ｽ懈舌＠縲√げ繝ｩ繝輔↓霑ｽ蜉縺吶ｋ縲
+
+ nullRenderer = (IBaseFilter) new NullRenderer();
+ hr = graphBuilder.AddFilter( nullRenderer, "Audio Null Renderer" );
+ DsError.ThrowExceptionForHR( hr );
+
+
+ // nullRenderer 縺ｮ蜈･蜉帙ヴ繝ｳ繧呈爾縺吶
+
+ hr = nullRenderer.FindPin( "In", out nullRendererInputPin );
+ DsError.ThrowExceptionForHR( hr );
+
+
+ // nullRenderer 繧偵げ繝ｩ繝輔↓謗･邯壹☆繧九
+
+ hr = rendererConnectedOutputPin.Connect( nullRendererInputPin, null );
+ DsError.ThrowExceptionForHR( hr );
+ }
+ finally
+ {
+ C蜈ｱ騾.tCOM繧ｪ繝悶ず繧ｧ繧ｯ繝医ｒ隗｣謾ｾ縺吶ｋ( ref nullRendererInputPin );
+ C蜈ｱ騾.tCOM繧ｪ繝悶ず繧ｧ繧ｯ繝医ｒ隗｣謾ｾ縺吶ｋ( ref nullRenderer );
+ C蜈ｱ騾.tCOM繧ｪ繝悶ず繧ｧ繧ｯ繝医ｒ隗｣謾ｾ縺吶ｋ( ref rendererConnectedOutputPin );
+ C蜈ｱ騾.tCOM繧ｪ繝悶ず繧ｧ繧ｯ繝医ｒ隗｣謾ｾ縺吶ｋ( ref rendererInputPin );
+ C蜈ｱ騾.tCOM繧ｪ繝悶ず繧ｧ繧ｯ繝医ｒ隗｣謾ｾ縺吶ｋ( ref audioRenderer );
+ }
+ }
+ public static void ConnectNullRendererFromSampleGrabber(IGraphBuilder graphBuilder, IBaseFilter sampleGrabber)
+ {
+ int hr = 0;
+ IBaseFilter videoRenderer = null;
+ IPin videoRendererInputPin = null;
+ IBaseFilter audioRenderer = null;
+ IPin audioRendererInputPin = null;
+ IPin connectedOutputPin = null;
+ IPin nullRendererInputPin = null;
+ IPin grabberOutputPin = null;
+ IPin grabberOutputConnectedPin = null;
+
+ try
+ {
+ // videoRenderer 繧呈爾縺吶
+ CDirectShow.SearchMMRenderers(graphBuilder, out videoRenderer, out videoRendererInputPin, out audioRenderer, out audioRendererInputPin);
+ if (videoRenderer != null && videoRendererInputPin != null)
+ {
+ // 譌｢蟄倥ｮ繝ｬ繝ｳ繝繝ｩ縺ｫ縺､縺ｪ縺後▲縺ｦ縺繧九ヴ繝ｳ蟇ｾ繧貞叙蠕
+ hr = videoRendererInputPin.ConnectedTo(out connectedOutputPin);
+ DsError.ThrowExceptionForHR(hr);
+
+ // 縺昴ｌ繧峨ｒ蛻譁ｭ縲ょ燕谿ｵ縺ｮ蜃ｺ蜉帙ヴ繝ｳ縺ｨ繝薙ョ繧ｪ繝ｬ繝ｳ繝繝ｩ縺ｮ蜈･蜉帙ヴ繝ｳ繧貞譁ｭ縺吶ｋ縲ょ曙譁ｹ蜷代°繧牙譁ｭ縺励↑縺縺ｨ繧ｰ繝ｩ繝輔°繧牙繧企屬縺輔ｌ縺ｪ縺縺ｮ縺ｧ豕ｨ諢上
+ hr = videoRendererInputPin.Disconnect();
+ DsError.ThrowExceptionForHR(hr);
+ hr = connectedOutputPin.Disconnect();
+ DsError.ThrowExceptionForHR(hr);
+
+ // 繝薙ョ繧ｪ繝ｬ繝ｳ繝繝ｩ繧偵げ繝ｩ繝輔°繧蛾勁蜴ｻ縺励√レ繝ｫ繝ｬ繝ｳ繝繝ｩ繧定ｿｽ蜉
+ hr = graphBuilder.RemoveFilter(videoRenderer);
+ DsError.ThrowExceptionForHR(hr);
+ IBaseFilter nullRenderer = new NullRenderer() as IBaseFilter;
+ hr = graphBuilder.AddFilter(nullRenderer, "Video Null Renderer");
+ DsError.ThrowExceptionForHR(hr);
+
+ // nullRenderer 縺ｮ蜈･蜉帙ヴ繝ｳ繧呈爾縺吶
+ hr = nullRenderer.FindPin("In", out nullRendererInputPin);
+ DsError.ThrowExceptionForHR(hr);
+ hr = nullRendererInputPin.Disconnect();
+ DsError.ThrowExceptionForHR(hr);
+
+ // 繧ｰ繝ｩ繝舌ｮ Out 縺ｨ Null Renderer 縺ｮ In 繧呈磁邯壹☆繧九
+ hr = sampleGrabber.FindPin("Out", out grabberOutputPin);
+ DsError.ThrowExceptionForHR(hr);
+ hr = grabberOutputPin.ConnectedTo(out grabberOutputConnectedPin);
+ // grabber縺ｮout縺ｫ菴輔ｂ縺､縺ｪ縺後▲縺ｦ縺縺ｪ縺蝣ｴ蜷(縺､縺ｾ繧翫“rabber縺ｮout縺ｨrenderer縺ｮin縺檎峩邨舌＠縺ｦ縺繧句ｴ蜷)縺ｯ縲
+ // grabber縺ｮout縺ｨ縲∝挨縺ｮ繝輔ぅ繝ｫ繧ｿ縺ｮin縺ｮ髢薙ｮ蛻譁ｭ蜃ｦ逅繧定｡後ｏ縺ｪ縺縲
+ if (hr != CWin32.S_OK)
+ {
+ //Debug.WriteLine("grabber out: 譛ｪ謗･邯:");
+ }
+ else
+ {
+ hr = grabberOutputConnectedPin.Disconnect();
+ DsError.ThrowExceptionForHR(hr);
+ hr = grabberOutputPin.Disconnect();
+ DsError.ThrowExceptionForHR(hr);
+ }
+ hr = grabberOutputPin.Connect(nullRendererInputPin, null);
+ DsError.ThrowExceptionForHR(hr);
+ }
+
+ if ( audioRenderer != null && audioRendererInputPin != null )
+ {
+ C蜈ｱ騾.tCOM繧ｪ繝悶ず繧ｧ繧ｯ繝医ｒ隗｣謾ｾ縺吶ｋ(ref connectedOutputPin);
+
+ // 譌｢蟄倥ｮ繝ｬ繝ｳ繝繝ｩ縺ｫ縺､縺ｪ縺後▲縺ｦ縺繧九ヴ繝ｳ蟇ｾ繧貞叙蠕
+ hr = audioRendererInputPin.ConnectedTo(out connectedOutputPin);
+ DsError.ThrowExceptionForHR(hr);
+
+ // 縺昴ｌ繧峨ｒ蛻譁ｭ縲ょ燕谿ｵ縺ｮ蜃ｺ蜉帙ヴ繝ｳ縺ｨ繝薙ョ繧ｪ繝ｬ繝ｳ繝繝ｩ縺ｮ蜈･蜉帙ヴ繝ｳ繧貞譁ｭ縺吶ｋ縲ょ曙譁ｹ蜷代°繧牙譁ｭ縺励↑縺縺ｨ繧ｰ繝ｩ繝輔°繧牙繧企屬縺輔ｌ縺ｪ縺縺ｮ縺ｧ豕ｨ諢上
+ hr = audioRendererInputPin.Disconnect();
+ DsError.ThrowExceptionForHR(hr);
+ hr = connectedOutputPin.Disconnect();
+ DsError.ThrowExceptionForHR(hr);
+
+ // 繝薙ョ繧ｪ繝ｬ繝ｳ繝繝ｩ繧偵げ繝ｩ繝輔°繧蛾勁蜴ｻ縺励√レ繝ｫ繝ｬ繝ｳ繝繝ｩ繧定ｿｽ蜉
+ hr = graphBuilder.RemoveFilter(audioRenderer);
+ DsError.ThrowExceptionForHR(hr);
+ IBaseFilter nullRenderer = new NullRenderer() as IBaseFilter;
+ hr = graphBuilder.AddFilter(nullRenderer, "Audio Null Renderer");
+ DsError.ThrowExceptionForHR(hr);
+
+ C蜈ｱ騾.tCOM繧ｪ繝悶ず繧ｧ繧ｯ繝医ｒ隗｣謾ｾ縺吶ｋ(ref nullRendererInputPin);
+ hr = nullRenderer.FindPin("In", out nullRendererInputPin);
+ DsError.ThrowExceptionForHR(hr);
+ hr = connectedOutputPin.Connect(nullRendererInputPin, null);
+ DsError.ThrowExceptionForHR(hr);
+ }
+ }
+ finally
+ {
+ C蜈ｱ騾.tCOM繧ｪ繝悶ず繧ｧ繧ｯ繝医ｒ隗｣謾ｾ縺吶ｋ(ref connectedOutputPin);
+ C蜈ｱ騾.tCOM繧ｪ繝悶ず繧ｧ繧ｯ繝医ｒ隗｣謾ｾ縺吶ｋ(ref videoRendererInputPin);
+ C蜈ｱ騾.tCOM繧ｪ繝悶ず繧ｧ繧ｯ繝医ｒ隗｣謾ｾ縺吶ｋ(ref videoRenderer);
+ C蜈ｱ騾.tCOM繧ｪ繝悶ず繧ｧ繧ｯ繝医ｒ隗｣謾ｾ縺吶ｋ(ref audioRenderer);
+ C蜈ｱ騾.tCOM繧ｪ繝悶ず繧ｧ繧ｯ繝医ｒ隗｣謾ｾ縺吶ｋ(ref audioRendererInputPin);
+ C蜈ｱ騾.tCOM繧ｪ繝悶ず繧ｧ繧ｯ繝医ｒ隗｣謾ｾ縺吶ｋ(ref nullRendererInputPin);
+ C蜈ｱ騾.tCOM繧ｪ繝悶ず繧ｧ繧ｯ繝医ｒ隗｣謾ｾ縺吶ｋ(ref grabberOutputPin);
+ C蜈ｱ騾.tCOM繧ｪ繝悶ず繧ｧ繧ｯ繝医ｒ隗｣謾ｾ縺吶ｋ(ref grabberOutputConnectedPin);
+ }
+ }
+ private static void SearchMMRenderers( IFilterGraph graph, out IBaseFilter videoRenderer, out IPin inputVPin, out IBaseFilter audioRenderer, out IPin inputAPin )
+ {
+ int hr = 0;
+ string strVR繝輔ぅ繝ｫ繧ｿ蜷 = null;
+ string strVR繝斐ΦID = null;
+ string strAR繝輔ぅ繝ｫ繧ｿ蜷 = null;
+ string strAR繝斐ΦID = null;
+
+ // 繝薙ョ繧ｪ繝ｬ繝ｳ繝繝ｩ縺ｨ蜈･蜉帙ヴ繝ｳ繧呈爾縺励√◎縺ｮ繝輔ぅ繝ｫ繧ｿ蜷阪→繝斐ΦID繧呈而縺医ｋ縲
+
+ IEnumFilters eFilters;
+ hr = graph.EnumFilters( out eFilters );
+ DsError.ThrowExceptionForHR( hr );
+ try
+ {
+ var filters = new IBaseFilter[ 1 ];
+ while( eFilters.Next( 1, filters, IntPtr.Zero ) == CWin32.S_OK )
+ {
+ try
+ {
+ #region [ 蜃ｺ蜉帙ヴ繝ｳ縺後↑縺ｼ医Ξ繝ｳ繝繝ｩ縺ｧ縺ゅｋｼ峨％縺ｨ繧堤｢ｺ隱阪☆繧九]
+ //-----------------
+ IEnumPins ePins;
+ bool b蜃ｺ蜉帙ヴ繝ｳ縺後≠繧 = false;
+
+ hr = filters[ 0 ].EnumPins( out ePins );
+ DsError.ThrowExceptionForHR( hr );
+ try
+ {
+ var pins = new IPin[ 1 ];
+ while( ePins.Next( 1, pins, IntPtr.Zero ) == CWin32.S_OK )
+ {
+ try
+ {
+ if( b蜃ｺ蜉帙ヴ繝ｳ縺後≠繧 )
+ continue;
+
+ PinDirection dir;
+ hr = pins[ 0 ].QueryDirection( out dir );
+ DsError.ThrowExceptionForHR( hr );
+ if( dir == PinDirection.Output )
+ b蜃ｺ蜉帙ヴ繝ｳ縺後≠繧 = true;
+ }
+ finally
+ {
+ C蜈ｱ騾.tCOM繧ｪ繝悶ず繧ｧ繧ｯ繝医ｒ隗｣謾ｾ縺吶ｋ( ref pins[ 0 ] );
+ }
+ }
+ }
+ finally
+ {
+ C蜈ｱ騾.tCOM繧ｪ繝悶ず繧ｧ繧ｯ繝医ｒ隗｣謾ｾ縺吶ｋ( ref ePins );
+ }
+
+ if( b蜃ｺ蜉帙ヴ繝ｳ縺後≠繧 )
+ continue; // 谺｡縺ｮ繝輔ぅ繝ｫ繧ｿ縺ｸ
+
+ //-----------------
+ #endregion
+ #region [ 謗･邯壻ｸｭ縺ｮ蜈･蜉帙ヴ繝ｳ縺 MEDIATYPE_Video 縺ｫ蟇ｾ蠢懊＠縺ｦ縺縺溘ｉ縲√ヵ繧｣繝ｫ繧ｿ蜷阪→繝斐ΦID繧貞叙蠕励☆繧九]
+ //-----------------
+ hr = filters[ 0 ].EnumPins( out ePins );
+ DsError.ThrowExceptionForHR( hr );
+ try
+ {
+ var pins = new IPin[ 1 ];
+ while( ePins.Next( 1, pins, IntPtr.Zero ) == CWin32.S_OK )
+ {
+ try
+ {
+ if( !string.IsNullOrEmpty( strVR繝輔ぅ繝ｫ繧ｿ蜷 ) )
+ continue;
+
+ var mediaType = new AMMediaType();
+
+ #region [ 迴ｾ蝨ｨ謗･邯壻ｸｭ縺ｮ MediaType 繧貞叙蠕励ゅ▽縺ｪ縺後▲縺ｦ縺ｪ縺代ｌ縺ｰ谺｡縺ｮ繝斐Φ縺ｸ縲]
+ //-----------------
+ hr = pins[ 0 ].ConnectionMediaType( mediaType );
+ if( hr == CWin32.VFW_E_NOT_CONNECTED )
+ continue; // 縺､縺ｪ縺後▲縺ｦ縺ｪ縺
+ DsError.ThrowExceptionForHR( hr );
+ //-----------------
+ #endregion
+
+ try
+ {
+ if( mediaType.majorType.Equals( MediaType.Video ) )
+ {
+ #region [ 繝輔ぅ繝ｫ繧ｿ蜷榊叙蠕暦ｼ‐
+ //-----------------
+ FilterInfo filterInfo;
+ hr = filters[ 0 ].QueryFilterInfo( out filterInfo );
+ DsError.ThrowExceptionForHR( hr );
+ strVR繝輔ぅ繝ｫ繧ｿ蜷 = filterInfo.achName;
+ C蜈ｱ騾.tCOM繧ｪ繝悶ず繧ｧ繧ｯ繝医ｒ隗｣謾ｾ縺吶ｋ( ref filterInfo.pGraph );
+ //-----------------
+ #endregion
+ #region [ 繝斐ΦID蜿門ｾ暦ｼ‐
+ //-----------------
+ hr = pins[ 0 ].QueryId( out strVR繝斐ΦID );
+ DsError.ThrowExceptionForHR( hr );
+ //-----------------
+ #endregion
+ }
+ else if( mediaType.majorType.Equals( MediaType.Audio ) )
+ {
+ FilterInfo filterInfo;
+ hr = filters[0].QueryFilterInfo(out filterInfo);
+ DsError.ThrowExceptionForHR(hr);
+ strAR繝輔ぅ繝ｫ繧ｿ蜷 = filterInfo.achName;
+ C蜈ｱ騾.tCOM繧ｪ繝悶ず繧ｧ繧ｯ繝医ｒ隗｣謾ｾ縺吶ｋ(ref filterInfo.pGraph);
+ hr = pins[0].QueryId(out strAR繝斐ΦID);
+ DsError.ThrowExceptionForHR(hr);
+ }
+ }
+ finally
+ {
+ DsUtils.FreeAMMediaType( mediaType );
+ }
+ }
+ finally
+ {
+ C蜈ｱ騾.tCOM繧ｪ繝悶ず繧ｧ繧ｯ繝医ｒ隗｣謾ｾ縺吶ｋ( ref pins[ 0 ] );
+ }
+ }
+ }
+ finally
+ {
+ C蜈ｱ騾.tCOM繧ｪ繝悶ず繧ｧ繧ｯ繝医ｒ隗｣謾ｾ縺吶ｋ( ref ePins );
+ }
+
+ //-----------------
+ #endregion
+ }
+ finally
+ {
+ C蜈ｱ騾.tCOM繧ｪ繝悶ず繧ｧ繧ｯ繝医ｒ隗｣謾ｾ縺吶ｋ( ref filters[ 0 ] );
+ }
+ }
+ }
+ finally
+ {
+ C蜈ｱ騾.tCOM繧ｪ繝悶ず繧ｧ繧ｯ繝医ｒ隗｣謾ｾ縺吶ｋ( ref eFilters );
+ }
+
+
+ // 謾ｹ繧√※繝輔ぅ繝ｫ繧ｿ蜷阪→繝斐ΦID縺九ｉ縺薙ｌ繧峨ｮ繧､繝ｳ繧ｿ繝ｼ繝輔ぉ繝ｼ繧ｹ繧貞叙蠕励＠縲∵綾繧雁､縺ｨ縺励※霑斐☆縲
+
+ videoRenderer = null;
+ inputVPin = null;
+ audioRenderer = null;
+ inputAPin = null;
+
+ if( !string.IsNullOrEmpty( strVR繝輔ぅ繝ｫ繧ｿ蜷 ) )
+ {
+ hr = graph.FindFilterByName( strVR繝輔ぅ繝ｫ繧ｿ蜷, out videoRenderer );
+ DsError.ThrowExceptionForHR( hr );
+
+ hr = videoRenderer.FindPin( strVR繝斐ΦID, out inputVPin );
+ DsError.ThrowExceptionForHR( hr );
+ }
+
+ if( !string.IsNullOrEmpty( strAR繝輔ぅ繝ｫ繧ｿ蜷 ) )
+ {
+ hr = graph.FindFilterByName(strAR繝輔ぅ繝ｫ繧ｿ蜷, out audioRenderer);
+ DsError.ThrowExceptionForHR(hr);
+
+ hr = audioRenderer.FindPin(strAR繝斐ΦID, out inputAPin);
+ DsError.ThrowExceptionForHR(hr);
+ }
+ }
+
+ public static void t繝薙ョ繧ｪ繝ｬ繝ｳ繝繝ｩ繧偵げ繝ｩ繝輔°繧蛾勁蜴ｻ縺吶ｋ( IGraphBuilder graphBuilder )
+ {
+ int hr = 0;
+
+ IBaseFilter videoRenderer = null;
+ IPin renderInputPin = null;
+ IPin connectedOutputPin = null;
+
+ try
+ {
+ // videoRenderer 繧呈爾縺吶
+
+ CDirectShow.t繝薙ョ繧ｪ繝ｬ繝ｳ繝繝ｩ縺ｨ縺昴ｮ蜈･蜉帙ヴ繝ｳ繧呈爾縺励※霑斐☆( graphBuilder, out videoRenderer, out renderInputPin );
+ if( videoRenderer == null || renderInputPin == null )
+ return; // 縺ｪ縺九▲縺
+
+ #region [ renderInputPin 縺ｸ謗･邯壹＠縺ｦ縺繧句燕谿ｵ縺ｮ蜃ｺ蜉帙ヴ繝ｳ connectedOutputPin 繧呈爾縺吶 ]
+ //-----------------
+ renderInputPin.ConnectedTo( out connectedOutputPin );
+ //-----------------
+ #endregion
+
+ if( connectedOutputPin == null )
+ return; // 縺ｪ縺九▲縺
+
+
+ // 蜑肴ｮｵ縺ｮ蜃ｺ蜉帙ヴ繝ｳ縺ｨ繝薙ョ繧ｪ繝ｬ繝ｳ繝繝ｩ縺ｮ蜈･蜉帙ヴ繝ｳ繧貞譁ｭ縺吶ｋ縲ょ曙譁ｹ蜷代°繧牙譁ｭ縺励↑縺縺ｨ繧ｰ繝ｩ繝輔°繧牙繧企屬縺輔ｌ縺ｪ縺縺ｮ縺ｧ豕ｨ諢上
+
+ renderInputPin.Disconnect();
+ connectedOutputPin.Disconnect();
+
+
+ // 繝薙ョ繧ｪ繝ｬ繝ｳ繝繝ｩ繧偵げ繝ｩ繝輔°繧蛾勁蜴ｻ縲
+
+ graphBuilder.RemoveFilter( videoRenderer );
+ }
+ finally
+ {
+ C蜈ｱ騾.tCOM繧ｪ繝悶ず繧ｧ繧ｯ繝医ｒ隗｣謾ｾ縺吶ｋ( ref connectedOutputPin );
+ C蜈ｱ騾.tCOM繧ｪ繝悶ず繧ｧ繧ｯ繝医ｒ隗｣謾ｾ縺吶ｋ( ref renderInputPin );
+ C蜈ｱ騾.tCOM繧ｪ繝悶ず繧ｧ繧ｯ繝医ｒ隗｣謾ｾ縺吶ｋ( ref videoRenderer );
+ }
+ }
+
+ private static IPin t譛蛻昴ｮ蜈･蜉帙ヴ繝ｳ繧呈爾縺励※霑斐☆( IBaseFilter baseFilter )
+ {
+ int hr = 0;
+
+ IPin firstInputPin = null;
+
+ IEnumPins ePins;
+ hr = baseFilter.EnumPins( out ePins );
+ DsError.ThrowExceptionForHR( hr );
+ try
+ {
+ var pins = new IPin[ 1 ];
+ while( ePins.Next( 1, pins, IntPtr.Zero ) == CWin32.S_OK )
+ {
+ PinInfo pinfo = new PinInfo() { filter = null };
+ try
+ {
+ hr = pins[ 0 ].QueryPinInfo( out pinfo );
+ DsError.ThrowExceptionForHR( hr );
+
+ if( pinfo.dir == PinDirection.Input )
+ {
+ firstInputPin = pins[ 0 ];
+ break;
+ }
+ }
+ finally
+ {
+ if( pinfo.filter != null )
+ C蜈ｱ騾.tCOM繧ｪ繝悶ず繧ｧ繧ｯ繝医ｒ隗｣謾ｾ縺吶ｋ( ref pinfo.filter );
+ DsUtils.FreePinInfo( pinfo );
+
+ if( firstInputPin == null )
+ C蜈ｱ騾.tCOM繧ｪ繝悶ず繧ｧ繧ｯ繝医ｒ隗｣謾ｾ縺吶ｋ( ref pins[ 0 ] );
+ }
+ }
+ }
+ finally
+ {
+ C蜈ｱ騾.tCOM繧ｪ繝悶ず繧ｧ繧ｯ繝医ｒ隗｣謾ｾ縺吶ｋ( ref ePins );
+ }
+
+ return firstInputPin;
+ }
+ private static void t繝薙ョ繧ｪ繝ｬ繝ｳ繝繝ｩ縺ｨ縺昴ｮ蜈･蜉帙ヴ繝ｳ繧呈爾縺励※霑斐☆( IFilterGraph graph, out IBaseFilter videoRenderer, out IPin inputPin )
+ {
+ int hr = 0;
+ string str繝輔ぅ繝ｫ繧ｿ蜷 = null;
+ string str繝斐ΦID = null;
+
+
+ // 繝薙ョ繧ｪ繝ｬ繝ｳ繝繝ｩ縺ｨ蜈･蜉帙ヴ繝ｳ繧呈爾縺励√◎縺ｮ繝輔ぅ繝ｫ繧ｿ蜷阪→繝斐ΦID繧呈而縺医ｋ縲
+
+ IEnumFilters eFilters;
+ hr = graph.EnumFilters( out eFilters );
+ DsError.ThrowExceptionForHR( hr );
+ try
+ {
+ var filters = new IBaseFilter[ 1 ];
+ while( eFilters.Next( 1, filters, IntPtr.Zero ) == CWin32.S_OK )
+ {
+ try
+ {
+ #region [ 蜃ｺ蜉帙ヴ繝ｳ縺後↑縺ｼ医Ξ繝ｳ繝繝ｩ縺ｧ縺ゅｋｼ峨％縺ｨ繧堤｢ｺ隱阪☆繧九]
+ //-----------------
+ IEnumPins ePins;
+ bool b蜃ｺ蜉帙ヴ繝ｳ縺後≠繧 = false;
+
+ hr = filters[ 0 ].EnumPins( out ePins );
+ DsError.ThrowExceptionForHR( hr );
+ try
+ {
+ var pins = new IPin[ 1 ];
+ while( ePins.Next( 1, pins, IntPtr.Zero ) == CWin32.S_OK )
+ {
+ try
+ {
+ if( b蜃ｺ蜉帙ヴ繝ｳ縺後≠繧 )
+ continue;
+
+ PinDirection dir;
+ hr = pins[ 0 ].QueryDirection( out dir );
+ DsError.ThrowExceptionForHR( hr );
+ if( dir == PinDirection.Output )
+ b蜃ｺ蜉帙ヴ繝ｳ縺後≠繧 = true;
+ }
+ finally
+ {
+ C蜈ｱ騾.tCOM繧ｪ繝悶ず繧ｧ繧ｯ繝医ｒ隗｣謾ｾ縺吶ｋ( ref pins[ 0 ] );
+ }
+ }
+ }
+ finally
+ {
+ C蜈ｱ騾.tCOM繧ｪ繝悶ず繧ｧ繧ｯ繝医ｒ隗｣謾ｾ縺吶ｋ( ref ePins );
+ }
+
+ if( b蜃ｺ蜉帙ヴ繝ｳ縺後≠繧 )
+ continue; // 谺｡縺ｮ繝輔ぅ繝ｫ繧ｿ縺ｸ
+
+ //-----------------
+ #endregion
+ #region [ 謗･邯壻ｸｭ縺ｮ蜈･蜉帙ヴ繝ｳ縺 MEDIATYPE_Video 縺ｫ蟇ｾ蠢懊＠縺ｦ縺縺溘ｉ縲√ヵ繧｣繝ｫ繧ｿ蜷阪→繝斐ΦID繧貞叙蠕励☆繧九]
+ //-----------------
+ hr = filters[ 0 ].EnumPins( out ePins );
+ DsError.ThrowExceptionForHR( hr );
+ try
+ {
+ var pins = new IPin[ 1 ];
+ while( ePins.Next( 1, pins, IntPtr.Zero ) == CWin32.S_OK )
+ {
+ try
+ {
+ if( !string.IsNullOrEmpty( str繝輔ぅ繝ｫ繧ｿ蜷 ) )
+ continue;
+
+ var mediaType = new AMMediaType();
+
+ #region [ 迴ｾ蝨ｨ謗･邯壻ｸｭ縺ｮ MediaType 繧貞叙蠕励ゅ▽縺ｪ縺後▲縺ｦ縺ｪ縺代ｌ縺ｰ谺｡縺ｮ繝斐Φ縺ｸ縲]
+ //-----------------
+ hr = pins[ 0 ].ConnectionMediaType( mediaType );
+ if( hr == CWin32.VFW_E_NOT_CONNECTED )
+ continue; // 縺､縺ｪ縺後▲縺ｦ縺ｪ縺
+ DsError.ThrowExceptionForHR( hr );
+ //-----------------
+ #endregion
+
+ try
+ {
+ if( mediaType.majorType.Equals( MediaType.Video ) )
+ {
+ #region [ 繝輔ぅ繝ｫ繧ｿ蜷榊叙蠕暦ｼ‐
+ //-----------------
+ FilterInfo filterInfo;
+ hr = filters[ 0 ].QueryFilterInfo( out filterInfo );
+ DsError.ThrowExceptionForHR( hr );
+ str繝輔ぅ繝ｫ繧ｿ蜷 = filterInfo.achName;
+ C蜈ｱ騾.tCOM繧ｪ繝悶ず繧ｧ繧ｯ繝医ｒ隗｣謾ｾ縺吶ｋ( ref filterInfo.pGraph );
+ //-----------------
+ #endregion
+ #region [ 繝斐ΦID蜿門ｾ暦ｼ‐
+ //-----------------
+ hr = pins[ 0 ].QueryId( out str繝斐ΦID );
+ DsError.ThrowExceptionForHR( hr );
+ //-----------------
+ #endregion
+
+ continue; // 谺｡縺ｮ繝斐Φ縺ｸ縲
+ }
+ }
+ finally
+ {
+ DsUtils.FreeAMMediaType( mediaType );
+ }
+ }
+ finally
+ {
+ C蜈ｱ騾.tCOM繧ｪ繝悶ず繧ｧ繧ｯ繝医ｒ隗｣謾ｾ縺吶ｋ( ref pins[ 0 ] );
+ }
+ }
+ }
+ finally
+ {
+ C蜈ｱ騾.tCOM繧ｪ繝悶ず繧ｧ繧ｯ繝医ｒ隗｣謾ｾ縺吶ｋ( ref ePins );
+ }
+
+ //-----------------
+ #endregion
+ }
+ finally
+ {
+ C蜈ｱ騾.tCOM繧ｪ繝悶ず繧ｧ繧ｯ繝医ｒ隗｣謾ｾ縺吶ｋ( ref filters[ 0 ] );
+ }
+ }
+ }
+ finally
+ {
+ C蜈ｱ騾.tCOM繧ｪ繝悶ず繧ｧ繧ｯ繝医ｒ隗｣謾ｾ縺吶ｋ( ref eFilters );
+ }
+
+
+ // 謾ｹ繧√※繝輔ぅ繝ｫ繧ｿ蜷阪→繝斐ΦID縺九ｉ縺薙ｌ繧峨ｮ繧､繝ｳ繧ｿ繝ｼ繝輔ぉ繝ｼ繧ｹ繧貞叙蠕励＠縲∵綾繧雁､縺ｨ縺励※霑斐☆縲
+
+ videoRenderer = null;
+ inputPin = null;
+
+ if( !string.IsNullOrEmpty( str繝輔ぅ繝ｫ繧ｿ蜷 ) )
+ {
+ hr = graph.FindFilterByName( str繝輔ぅ繝ｫ繧ｿ蜷, out videoRenderer );
+ DsError.ThrowExceptionForHR( hr );
+
+ hr = videoRenderer.FindPin( str繝斐ΦID, out inputPin );
+ DsError.ThrowExceptionForHR( hr );
+ }
+ }
+ private static IBaseFilter t繧ｪ繝ｼ繝繧｣繧ｪ繝ｬ繝ｳ繝繝ｩ繧呈爾縺励※霑斐☆( IFilterGraph graph )
+ {
+ int hr = 0;
+ IBaseFilter audioRenderer = null;
+
+ IEnumFilters eFilters;
+ hr = graph.EnumFilters( out eFilters );
+ DsError.ThrowExceptionForHR( hr );
+ try
+ {
+ var filters = new IBaseFilter[ 1 ];
+ while( eFilters.Next( 1, filters, IntPtr.Zero ) == CWin32.S_OK )
+ {
+ if( ( filters[ 0 ] as IAMAudioRendererStats ) != null )
+ {
+ audioRenderer = filters[ 0 ];
+ break;
+ }
+
+ C蜈ｱ騾.tCOM繧ｪ繝悶ず繧ｧ繧ｯ繝医ｒ隗｣謾ｾ縺吶ｋ( ref filters[ 0 ] );
+ }
+ }
+ finally
+ {
+ C蜈ｱ騾.tCOM繧ｪ繝悶ず繧ｧ繧ｯ繝医ｒ隗｣謾ｾ縺吶ｋ( ref eFilters );
+ }
+ return audioRenderer;
+ }
+
+
+ #region [ 髱咏噪繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ邂｡逅 ]
+ //-----------------
+ public const int n繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹID縺ｮ譛螟ｧ謨ｰ = 100;
+ protected static Dictionary dic繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ = new Dictionary(); // <繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹID, 縺昴ｮID繧呈戟縺､繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ>
+
+ protected static void t繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ繧堤匳骭ｲ縺吶ｋ( CDirectShow ds )
+ {
+ for( int i = 1; i < CDirectShow.n繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹID縺ｮ譛螟ｧ謨ｰ; i++ )
+ {
+ if( !CDirectShow.dic繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ.ContainsKey( i ) ) // 遨ｺ縺縺ｦ縺繧狗分蜿ｷ繧剃ｽｿ縺縲
+ {
+ ds.n繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹID = i;
+ CDirectShow.dic繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ.Add( i, ds );
+ break;
+ }
+ }
+ }
+ protected static void t繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ繧定ｧ｣謾ｾ縺吶ｋ( int n繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹID )
+ {
+ if( CDirectShow.dic繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ.ContainsKey( n繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹID ) )
+ CDirectShow.dic繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ.Remove( n繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹID );
+ }
+ //-----------------
+ #endregion
+
+ #region [ Dispose-Finalize 繝代ち繝ｼ繝ｳ螳溯｣ ]
+ //-----------------
+ public virtual void Dispose()
+ {
+ this.Dispose( true );
+ GC.SuppressFinalize( this ); // 縺｡繧繧薙→ Dispose 縺輔ｌ縺溘ｮ縺ｧ縲√ヵ繧｡繧､繝翫Λ繧､繧ｺ荳崎ｦ√〒縺ゅｋ縺薙→繧 CLR 縺ｫ莨昴∴繧九
+ }
+ protected virtual void Dispose( bool bManaged繝ｪ繧ｽ繝ｼ繧ｹ繧りｧ｣謾ｾ縺吶ｋ )
+ {
+ if( bManaged繝ｪ繧ｽ繝ｼ繧ｹ繧りｧ｣謾ｾ縺吶ｋ )
+ {
+ #region [ ROT縺九ｉ隗｣謾ｾ縺吶ｋ縲]
+ //-----------------
+#if DEBUG
+ C蜈ｱ騾.tDispose縺吶ｋ( ref this.rot );
+#endif
+ //-----------------
+ #endregion
+
+ CDirectShow.t繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ繧定ｧ｣謾ｾ縺吶ｋ( this.n繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹID );
+ }
+
+ #region [ 繧､繝ｳ繧ｿ繝ｼ繝輔ぉ繝ｼ繧ｹ蜿らｧ繧偵↑縺上＠縲，OM繧ｪ繝悶ず繧ｧ繧ｯ繝医ｒ隗｣謾ｾ縺吶ｋ縲 ]
+ //-----------------
+ if( this.ip != IntPtr.Zero )
+ {
+ Marshal.FreeCoTaskMem( this.ip );
+ this.ip = IntPtr.Zero;
+ }
+
+ if( this.MediaCtrl != null )
+ {
+ this.MediaCtrl.Stop();
+ this.MediaCtrl = null;
+ }
+
+ if( this.MediaEventEx != null )
+ {
+ this.MediaEventEx.SetNotifyWindow( IntPtr.Zero, 0, IntPtr.Zero );
+ this.MediaEventEx = null;
+ }
+
+ if( this.MediaSeeking != null )
+ this.MediaSeeking = null;
+
+ if( this.BasicAudio != null )
+ this.BasicAudio = null;
+
+ C蜈ｱ騾.tCOM繧ｪ繝悶ず繧ｧ繧ｯ繝医ｒ隗｣謾ｾ縺吶ｋ( ref this.nullRenderer );
+ C蜈ｱ騾.tCOM繧ｪ繝悶ず繧ｧ繧ｯ繝医ｒ隗｣謾ｾ縺吶ｋ( ref this.memoryRenderer );
+ C蜈ｱ騾.tCOM繧ｪ繝悶ず繧ｧ繧ｯ繝医ｒ隗｣謾ｾ縺吶ｋ( ref this.memoryRendererObject );
+ C蜈ｱ騾.tCOM繧ｪ繝悶ず繧ｧ繧ｯ繝医ｒ隗｣謾ｾ縺吶ｋ( ref this.graphBuilder );
+ //-----------------
+ #endregion
+
+ C蜈ｱ騾.t螳悟ｨ縺ｪ繧ｬ繝吶ｼ繧ｸ繧ｳ繝ｬ繧ｯ繧ｷ繝ｧ繝ｳ繧貞ｮ滓命縺吶ｋ();
+ }
+ ~CDirectShow()
+ {
+ // 繝輔ぃ繧､繝翫Λ繧､繧ｶ縺悟他縺ｰ繧後◆縺ｨ縺縺縺薙→縺ｯ縲．ispose() 縺輔ｌ縺ｪ縺九▲縺溘→縺縺縺薙→縲
+ // 縺薙ｮ蝣ｴ蜷医｀anaged 繝ｪ繧ｽ繝ｼ繧ｹ縺ｯ蜈医↓繝輔ぃ繧､繝翫Λ繧､繧ｺ縺輔ｌ縺ｦ縺繧句庄閭ｽ諤ｧ縺後≠繧九ｮ縺ｧ縲ゞnmamaed 繝ｪ繧ｽ繝ｼ繧ｹ縺ｮ縺ｿ繧定ｧ｣謾ｾ縺吶ｋ縲
+
+ this.Dispose( false );
+ }
+ //-----------------
+ #endregion
+
+ #region [ protected ]
+ //-----------------
+ protected MemoryRenderer memoryRendererObject = null;
+ protected IMemoryRenderer memoryRenderer = null;
+ protected IBaseFilter nullRenderer = null;
+ protected int n蜀咲函荳譎ょ●豁｢蜻ｼ縺ｳ蜃ｺ縺励ｮ邏ｯ遨榊屓謨ｰ = 0;
+ //-----------------
+ #endregion
+
+ #region [ private ]
+ //-----------------
+ private int _n髻ｳ驥 = 100;
+#if DEBUG
+ private DsROTEntry rot = null;
+#endif
+
+ // 蜿ｯ閭ｽ縺ｪ謨ｰ縺ｮ繧ｹ繝ｬ繝繝峨ｒ菴ｿ逕ｨ縺励※逕ｻ蜒上ｒ霆｢騾√☆繧九ょ､ｧ縺阪＞逕ｻ蜒上⊇縺ｩ譛牙柑縲ょ､壹☆縺弱ｋ縺ｨ繝励ｼ繝ｫ蜀縺ｮ繧ｹ繝ｬ繝繝峨′遨ｺ縺上∪縺ｧ蠕縺溘＆繧後ｋ縺ｮ縺ｧ豕ｨ諢上
+ private static int n荳ｦ蛻怜ｺｦ = 0; // 0 縺ｮ蝣ｴ蜷医∵怙蛻昴ｮ逕滓先凾縺ｫ荳ｦ蛻怜ｺｦ繧呈ｱｺ螳壹☆繧九
+
+ private DG繝ｩ繧､繝ｳ謠冗判[] dg繝ｩ繧､繝ｳ謠冗判ARGB32;
+ private DG繝ｩ繧､繝ｳ謠冗判[] dg繝ｩ繧､繝ｳ謠冗判XRGB32;
+ private unsafe delegate void DG繝ｩ繧､繝ｳ謠冗判( int n );
+ private unsafe byte* ptrSnap = null;
+ private unsafe UInt32** ptrTexture = null;
+
+ private unsafe void t繝ｩ繧､繝ｳ謠冗判XRGB32( int n )
+ {
+ // Snap 縺ｯ RGB32縲ゝexture縺ｯ X8R8G8B8
+
+ UInt32* ptrTexture = this.ptrTexture[ n ];
+ for( int y = n; y < this.n鬮倥＆px; y += CDirectShow.n荳ｦ蛻怜ｺｦ )
+ {
+ byte* ptrPixel = ptrSnap + ( ( ( this.n鬮倥＆px - y ) - 1 ) * this.n繧ｹ繧ｭ繝｣繝ｳ繝ｩ繧､繝ｳ蟷byte );
+
+ // 繧｢繝ｫ繝輔ぃ辟｡隕悶↑縺ｮ縺ｧ荳諡ｬ繧ｳ繝斐ｼ縲CopyMemory() 縺ｯ閾ｪ蜑阪〒繝ｫ繝ｼ繝怜ｱ暮幕縺吶ｋ繧医ｊ繧る溘＞縲
+ CWin32.CopyMemory( (void*) ptrTexture, (void*) ptrPixel, (uint) ( this.n蟷px * 4 ) );
+
+ ptrTexture += this.n蟷px * CDirectShow.n荳ｦ蛻怜ｺｦ;
+ }
+ }
+ private unsafe void t繝ｩ繧､繝ｳ謠冗判ARGB32( int n )
+ {
+ // Snap 縺ｯ RGB32縲ゝexture縺ｯ A8R8G8B8
+
+ UInt32* ptrTexture = this.ptrTexture[ n ];
+ for( int y = n; y < this.n鬮倥＆px; y += CDirectShow.n荳ｦ蛻怜ｺｦ )
+ {
+ UInt32* ptrPixel = (UInt32*) ( ptrSnap + ( ( ( this.n鬮倥＆px - y ) - 1 ) * this.n繧ｹ繧ｭ繝｣繝ｳ繝ｩ繧､繝ｳ蟷byte ) );
+
+ //for( int x = 0; x < this.n蟷px; x++ )
+ // *( ptrTexture + x ) = 0xFF000000 | *ptrPixel++;
+ // 竊薙Ν繝ｼ繝怜ｱ暮幕縺ｫ繧医ｊ鬮倬溷喧縲160fps 縺ｮ譖ｲ縺 200fps 縺ｾ縺ｧ荳翫′縺｣縺溘
+
+ if( this.n蟷px == 0 ) goto LEXIT;
+ UInt32* pt = ptrTexture;
+ UInt32 nAlpha = 0xFF000000;
+ int d = ( this.n蟷px % 32 );
+
+ switch( d )
+ {
+ case 1: goto L031;
+ case 2: goto L030;
+ case 3: goto L029;
+ case 4: goto L028;
+ case 5: goto L027;
+ case 6: goto L026;
+ case 7: goto L025;
+ case 8: goto L024;
+ case 9: goto L023;
+ case 10: goto L022;
+ case 11: goto L021;
+ case 12: goto L020;
+ case 13: goto L019;
+ case 14: goto L018;
+ case 15: goto L017;
+ case 16: goto L016;
+ case 17: goto L015;
+ case 18: goto L014;
+ case 19: goto L013;
+ case 20: goto L012;
+ case 21: goto L011;
+ case 22: goto L010;
+ case 23: goto L009;
+ case 24: goto L008;
+ case 25: goto L007;
+ case 26: goto L006;
+ case 27: goto L005;
+ case 28: goto L004;
+ case 29: goto L003;
+ case 30: goto L002;
+ case 31: goto L001;
+ }
+
+ L000: *pt++ = nAlpha | *ptrPixel++;
+ L001: *pt++ = nAlpha | *ptrPixel++;
+ L002: *pt++ = nAlpha | *ptrPixel++;
+ L003: *pt++ = nAlpha | *ptrPixel++;
+ L004: *pt++ = nAlpha | *ptrPixel++;
+ L005: *pt++ = nAlpha | *ptrPixel++;
+ L006: *pt++ = nAlpha | *ptrPixel++;
+ L007: *pt++ = nAlpha | *ptrPixel++;
+ L008: *pt++ = nAlpha | *ptrPixel++;
+ L009: *pt++ = nAlpha | *ptrPixel++;
+ L010: *pt++ = nAlpha | *ptrPixel++;
+ L011: *pt++ = nAlpha | *ptrPixel++;
+ L012: *pt++ = nAlpha | *ptrPixel++;
+ L013: *pt++ = nAlpha | *ptrPixel++;
+ L014: *pt++ = nAlpha | *ptrPixel++;
+ L015: *pt++ = nAlpha | *ptrPixel++;
+ L016: *pt++ = nAlpha | *ptrPixel++;
+ L017: *pt++ = nAlpha | *ptrPixel++;
+ L018: *pt++ = nAlpha | *ptrPixel++;
+ L019: *pt++ = nAlpha | *ptrPixel++;
+ L020: *pt++ = nAlpha | *ptrPixel++;
+ L021: *pt++ = nAlpha | *ptrPixel++;
+ L022: *pt++ = nAlpha | *ptrPixel++;
+ L023: *pt++ = nAlpha | *ptrPixel++;
+ L024: *pt++ = nAlpha | *ptrPixel++;
+ L025: *pt++ = nAlpha | *ptrPixel++;
+ L026: *pt++ = nAlpha | *ptrPixel++;
+ L027: *pt++ = nAlpha | *ptrPixel++;
+ L028: *pt++ = nAlpha | *ptrPixel++;
+ L029: *pt++ = nAlpha | *ptrPixel++;
+ L030: *pt++ = nAlpha | *ptrPixel++;
+ L031: *pt++ = nAlpha | *ptrPixel++;
+ if( ( pt - ptrTexture ) < this.n蟷px ) goto L000;
+
+ LEXIT:
+ ptrTexture += this.n蟷px * CDirectShow.n荳ｦ蛻怜ｺｦ;
+ }
+ }
+ //-----------------
+ #endregion
+ }
+}
diff --git a/FDK19/繧ｳ繝ｼ繝/05.DirectShow/MemoryRenderer.cs b/FDK19/繧ｳ繝ｼ繝/05.DirectShow/MemoryRenderer.cs
new file mode 100644
index 00000000..06b4f24d
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/05.DirectShow/MemoryRenderer.cs
@@ -0,0 +1,36 @@
+ｻｿusing System;
+using System.Collections.Generic;
+using System.Text;
+using System.Runtime.InteropServices;
+
+namespace FDK
+{
+ using HRESULT = Int32;
+ using BOOL = Int32;
+
+ [ComImport, Guid( "CE3CE3EE-5C4E-4BDC-A467-C068E1FC3DA5" )]
+ public class MemoryRenderer // 菴輔ｂ邯呎価縺励※縺ｯ縺ｪ繧峨↑縺縲
+ {
+ // 菴輔ｂ險倩ｿｰ縺励※縺ｯ縺ｪ繧峨↑縺縲
+ // 莉｣繧上ｊ縺ｫ縲｀emoryRenderer 縺ｮ逕滓仙ｾ後√く繝｣繧ｹ繝医〒竊薙ｮ繧､繝ｳ繧ｿ繝ｼ繝輔ぉ繝ｼ繧ｹ繧貞叙蠕励☆繧九
+ }
+
+ [ComImport, Guid( "FFAA4A1A-D63D-4688-9C66-D18CA7B99488" ), InterfaceType( ComInterfaceType.InterfaceIsIUnknown )]
+ public interface IMemoryRenderer
+ {
+ [PreserveSig]
+ HRESULT GetWidth( out long nWidht );
+
+ [PreserveSig]
+ HRESULT GetHeight( out long nHeight );
+
+ [PreserveSig]
+ HRESULT GetBufferSize( out long nBufferSize );
+
+ [PreserveSig]
+ HRESULT GetCurrentBuffer( IntPtr pBuffer, long nBufferSize );
+
+ [PreserveSig]
+ HRESULT IsBottomUp( out BOOL bBottomUp );
+ }
+}
diff --git a/FDK19/繧ｳ繝ｼ繝/06.Tempo/CBeatDetect.cs b/FDK19/繧ｳ繝ｼ繝/06.Tempo/CBeatDetect.cs
new file mode 100644
index 00000000..4b3b9734
--- /dev/null
+++ b/FDK19/繧ｳ繝ｼ繝/06.Tempo/CBeatDetect.cs
@@ -0,0 +1,209 @@
+ｻｿusing System;
+using System.Collections.Generic;
+using System.Text;
+using System.Diagnostics;
+using System.Threading;
+using Un4seen.Bass;
+//using Un4seen.BassAsio;
+//using Un4seen.BassWasapi;
+//using Un4seen.Bass.AddOn.Mix;
+using Un4seen.Bass.AddOn.Fx;
+
+namespace FDK
+{
+ public class CBeatDetect : IDisposable
+ {
+ public struct stBeatPos
+ {
+ public float fBeatTime;
+ public int n蟆冗ｯ逡ｪ蜿ｷ;
+ public int nGrid;
+ public int n蟆冗ｯ蜀Grid;
+ public bool b辟｡蜉ｹ; //
+ public bool b繝ｬ繝ｼ繝ｳ陦ｨ遉ｺ縺吶ｋ; // 譛ｪ菴ｿ逕ｨ
+
+ public stBeatPos( float _fBeatTime, int _n蟆冗ｯ逡ｪ蜿ｷ, int _nGrid, int _n蟆冗ｯ蜀Grid, bool _b辟｡蜉ｹ, bool _b繝ｬ繝ｼ繝ｳ陦ｨ遉ｺ縺吶ｋ )
+ {
+ fBeatTime = _fBeatTime;
+ n蟆冗ｯ逡ｪ蜿ｷ = _n蟆冗ｯ逡ｪ蜿ｷ;
+ nGrid = _nGrid;
+ n蟆冗ｯ蜀Grid = _n蟆冗ｯ蜀Grid;
+ b辟｡蜉ｹ = _b辟｡蜉ｹ;
+ b繝ｬ繝ｼ繝ｳ陦ｨ遉ｺ縺吶ｋ= _b繝ｬ繝ｼ繝ｳ陦ｨ遉ｺ縺吶ｋ;
+ }
+ }
+
+ #region [ 繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ ]
+ public CBeatDetect()
+ {
+ Initialize();
+ }
+ public CBeatDetect( string _filename )
+ {
+ this.filename = _filename;
+ Initialize();
+ }
+ #endregion
+ #region [ 蛻晄悄蛹(繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ縺九ｉ蜻ｼ縺ｳ蜃ｺ縺輔ｌ繧) ]
+ private void Initialize()
+ {
+ if ( this.listBeatPositions == null )
+ {
+ this.listBeatPositions = new List();
+ }
+
+ #region [ BASS registration ]
+ // BASS.NET 繝ｦ繝ｼ繧ｶ逋ｻ骭ｲｼBASS繧ｹ繝励Λ繝繧ｷ繝･縺碁撼陦ｨ遉ｺ縺ｫ縺ｪ繧具ｼ峨
+
+ BassNet.Registration( "dtx2013@gmail.com", "2X9181017152222" );
+ #endregion
+ #region [ BASS Version Check ]
+ // BASS 縺ｮ繝舌ｼ繧ｸ繝ｧ繝ｳ繝√ぉ繝繧ｯ縲
+ int nBASSVersion = Utils.HighWord( Bass.BASS_GetVersion() );
+ if ( nBASSVersion != Bass.BASSVERSION )
+ throw new DllNotFoundException( string.Format( "bass.dll 縺ｮ繝舌ｼ繧ｸ繝ｧ繝ｳ縺檎焚縺ｪ繧翫∪縺({0})縲ゅ％縺ｮ繝励Ο繧ｰ繝ｩ繝縺ｯ繝舌ｼ繧ｸ繝ｧ繝ｳ{1}縺ｧ蜍穂ｽ懊＠縺ｾ縺吶", nBASSVersion, Bass.BASSVERSION ) );
+
+ int nBASSFXVersion = Utils.HighWord( BassFx.BASS_FX_GetVersion() );
+ if ( nBASSFXVersion != BassFx.BASSFXVERSION )
+ throw new DllNotFoundException( string.Format( "bass_fx.dll 縺ｮ繝舌ｼ繧ｸ繝ｧ繝ｳ縺檎焚縺ｪ繧翫∪縺({0})縲ゅ％縺ｮ繝励Ο繧ｰ繝ｩ繝縺ｯ繝舌ｼ繧ｸ繝ｧ繝ｳ{1}縺ｧ蜍穂ｽ懊＠縺ｾ縺吶", nBASSFXVersion, BassFx.BASSFXVERSION ) );
+ #endregion
+
+ #region [ BASS 縺ｮ險ｭ螳壹]
+ //this.bIsBASSFree = true;
+ //Debug.Assert( Bass.BASS_SetConfig( BASSConfig.BASS_CONFIG_UPDATEPERIOD, 0 ), // 0:BASS繧ｹ繝医Μ繝ｼ繝縺ｮ閾ｪ蜍墓峩譁ｰ繧定｡後ｏ縺ｪ縺縲(繧ｵ繧ｦ繝ｳ繝牙ｺ蜉帙＠縺ｪ縺縺溘ａ)
+ // string.Format( "BASS_SetConfig() 縺ｫ螟ｱ謨励＠縺ｾ縺励◆縲[{0}", Bass.BASS_ErrorGetCode() ) );
+ #endregion
+ #region [ BASS 縺ｮ蛻晄悄蛹悶]
+ int n繝繝舌う繧ｹ = 0; // 0:"no sound" 窶ｦ BASS 縺九ｉ縺ｯ繝繝舌う繧ｹ縺ｸ繧｢繧ｯ繧ｻ繧ｹ縺輔○縺ｪ縺縲
+ int n蜻ｨ豕｢謨ｰ = 44100; // 莉ｮ豎ｺ繧√Ｍ繝繝舌う繧ｹｼ遺旺繝峨Λ繧､繝撰ｼ峨′繝阪う繝繧｣繝悶↓蟇ｾ蠢懊＠縺ｦ縺繧句捉豕｢謨ｰ縺ｧ縺ゅｌ縺ｰ菴輔〒繧ゅ＞縺ｼ溘ｈ縺縺縲ゅ＞縺壹ｌ縺ｫ縺励ｍBASSMX縺ｧ閾ｪ蜍慕噪縺ｫ繝ｪ繧ｵ繝ｳ繝励Μ繝ｳ繧ｰ縺輔ｌ繧九
+ if ( !Bass.BASS_Init( n繝繝舌う繧ｹ, n蜻ｨ豕｢謨ｰ, BASSInit.BASS_DEVICE_DEFAULT, IntPtr.Zero ) )
+ throw new Exception( string.Format( "BASS 縺ｮ蛻晄悄蛹悶↓螟ｱ謨励＠縺ｾ縺励◆縲(BASS_Init)[{0}]", Bass.BASS_ErrorGetCode().ToString() ) );
+ #endregion
+
+ #region [ 謖螳壹＆繧後◆繧ｵ繧ｦ繝ｳ繝峨ヵ繧｡繧､繝ｫ繧達ASS縺ｧ繧ｪ繝ｼ繝励Φ縺励∝ｿ隕∵怙蟆城剞縺ｮ諠蝣ｱ繧貞叙蠕励☆繧九]
+ //this.hBassStream = Bass.BASS_StreamCreateFile( this.filename, 0, 0, BASSFlag.BASS_STREAM_PRESCAN | BASSFlag.BASS_STREAM_DECODE );
+ this.hBassStream = Bass.BASS_StreamCreateFile( this.filename, 0, 0, BASSFlag.BASS_STREAM_DECODE );
+ if ( this.hBassStream == 0 )
+ throw new Exception( string.Format( "{0}: 繧ｵ繧ｦ繝ｳ繝峨せ繝医Μ繝ｼ繝縺ｮ逕滓舌↓螟ｱ謨励＠縺ｾ縺励◆縲(BASS_StreamCreateFile)[{1}]", filename, Bass.BASS_ErrorGetCode().ToString() ) );
+
+ this.nTotalBytes = Bass.BASS_ChannelGetLength( this.hBassStream );
+
+ this.nTotalSeconds = Bass.BASS_ChannelBytes2Seconds( this.hBassStream, nTotalBytes );
+ if ( !Bass.BASS_ChannelGetAttribute( this.hBassStream, BASSAttribute.BASS_ATTRIB_FREQ, ref fFreq ) )
+ {
+ string errmes = string.Format( "繧ｵ繧ｦ繝ｳ繝峨せ繝医Μ繝ｼ繝縺ｮ蜻ｨ豕｢謨ｰ蜿門ｾ励↓螟ｱ謨励＠縺ｾ縺励◆縲(BASS_ChannelGetAttribute)[{0}]", Bass.BASS_ErrorGetCode().ToString() );
+ Bass.BASS_Free();
+ throw new Exception( errmes );
+ }
+ #endregion
+ }
+ #endregion
+
+ ///
+ /// 譖ｲ蜈ｨ菴薙ｮ繝繝ｳ繝昴ｒ蜿門ｾ励☆繧
+ ///
+ /// 繝繝ｳ繝晏､
+ /// 繝繝ｳ繝晏､縺ｮ遽蝗ｲ縺ｯ70-300
+ public float GetTempo()
+ {
+ fTempo = BassFx.BASS_FX_BPM_DecodeGet(
+ this.hBassStream,
+ 0,
+ nTotalSeconds,
+ ( 300 << 16 ) + 70, // MAX BPM=320, MIN BPM=70
+ //0,
+ BASSFXBpm.BASS_FX_BPM_DEFAULT, //BASSFXBpm.BASS_FX_BPM_MULT2,
+ null,
+ IntPtr.Zero );
+ return fTempo;
+ }
+ ///
+ /// 譖ｲ縺ｮ荳驛ｨ蛻縺ｮ繝繝ｳ繝昴ｒ蜿門ｾ励☆繧
+ ///
+ /// 髢句ｧ倶ｽ咲ｽｮ
+ /// 邨ゆｺ菴咲ｽｮ
+ /// 繝繝ｳ繝晏､
+ /// 繝繝ｳ繝晏､縺ｮ遽蝗ｲ縺ｯ70-300
+ public float GetTempo( double startSec, double endSec )
+ {
+ fTempo = BassFx.BASS_FX_BPM_DecodeGet(
+ this.hBassStream,
+ startSec,
+ endSec,
+ ( 300 << 16 ) + 70, // MAX BPM=320, MIN BPM=70
+ //0,
+ BASSFXBpm.BASS_FX_BPM_DEFAULT, //BASSFXBpm.BASS_FX_BPM_MULT2,
+ null,
+ IntPtr.Zero );
+ return fTempo;
+ }
+
+
+ ///
+ /// Beat縺ｮ讀懷ｺ菴咲ｽｮ繧鱈ist縺ｧ霑斐☆
+ ///
+ /// Beat讀懷ｺ菴咲ｽｮ鄒､
+ public List GetBeatPositions()
+ {
+ #region [ BeatPosition譬ｼ邏阪Μ繧ｹ繝医ｮ蛻晄悄蛹 ]
+ if ( this.listBeatPositions != null )
+ {
+ this.listBeatPositions.Clear();
+ }
+ else
+ {
+ this.listBeatPositions = new List();
+ }
+ #endregion
+
+ BPMBEATPROC _beatProc = new BPMBEATPROC( GetBeat_ProgressCallback );
+
+ bool ret = BassFx.BASS_FX_BPM_BeatDecodeGet(
+ this.hBassStream,
+ 0,
+ nTotalSeconds,
+ //0,
+ BASSFXBpm.BASS_FX_BPM_DEFAULT, //BASSFXBpm.BASS_FX_BPM_MULT2,
+ _beatProc,
+ IntPtr.Zero );
+
+ return this.listBeatPositions;
+ }
+
+ private void GetBeat_ProgressCallback( int channel, double beatpos, IntPtr user )
+ {
+ stBeatPos sbp = new stBeatPos(
+ (float) beatpos,
+ 0,
+ 0,
+ 0,
+ false,
+ true
+ );
+
+
+ listBeatPositions.Add( sbp );
+// Debug.WriteLine( "Beat at: " + beatpos.ToString() );
+ }
+
+
+
+
+ public void Dispose() // 菴ｿ縺邨ゅｏ縺｣縺溘ｉ蠢縺咼ispose()縺吶ｋ縺薙→縲BASS縺ｮ繝ｪ繧ｽ繝ｼ繧ｹ繧呈升繧翫▲縺ｱ縺ｪ縺励↓縺吶ｋ縺ｨ縲∽ｻ悶ｮ蜀咲函縺ｫ荳埼ｽ蜷医′逕溘§繧九◆繧√
+ {
+ BassFx.BASS_FX_BPM_Free( this.hBassStream );
+ Bass.BASS_StreamFree( this.hBassStream );
+ this.hBassStream = -1;
+ Bass.BASS_Free();
+ }
+
+ // =============
+ private string filename = "";
+ private int hBassStream = -1;
+ private long nTotalBytes = 0;
+ private double nTotalSeconds = 0.0f;
+ private float fFreq = 0.0f;
+ private float fTempo;
+ private List listBeatPositions = null;
+ }
+}
diff --git a/README.old.md b/README.old.md
new file mode 100644
index 00000000..ac769ac7
--- /dev/null
+++ b/README.old.md
@@ -0,0 +1,35 @@
+# TJAPlayer3-Develop-ReWrite
+DTXMania繧偵＞縺倥▲縺ｦtja蜀咲函繝励Ο繧ｰ繝ｩ繝縺ｫ縺励■繧縺｣縺歇TJAPlayer2fPC](https://github.com/kairera0467/TJAP2fPC)繧巽ork縺励※譛ｬ螳ｶ鬚ｨ縺ｫ謾ｹ騾縺励◆
+[TJAPlayer3](https://github.com/AioiLight/TJAPlayer3)繧定ｶ譛ｬ螳ｶ鬚ｨ縺ｫ謾ｹ騾縺励◆繧｢繝ｬ繧呈嶌縺咲峩縺励◆繧ゅｮ縲
+
+縺薙ｮ繝励Ο繧ｰ繝ｩ繝繧剃ｽｿ逕ｨ縺励◆荳榊ｷ蜷医ｻ蝠城｡後↓縺､縺縺ｦ縺ｯ雋ｬ莉ｻ繧定ｲ縺縺九ｭ縺ｾ縺吶
+
+## How 2 Build
+- VisualStudio 2017 & C# 7.3
+- VC++ toolset
+- SlimDX逕ｨ縺ｮ鄂ｲ蜷
+
+## 繝ｩ繧､繧ｻ繝ｳ繧ｹ髢｢菫
+Fork蜈繧医ｊ蠑慕畑縲
+
+> 莉･荳九ｮ繝ｩ繧､繝悶Λ繝ｪ繧剃ｽｿ逕ｨ縺励※縺縺ｾ縺吶
+> * bass
+> * Bass.Net
+> * DirectShowLib
+> * FDK21
+> * SlimDX
+> * SharpDX
+> * ReadJEnc
+> * xadec
+> * IPA繝輔か繝ｳ繝
+> * libogg
+> * libvorbis
+> 縲悟ｮ溯｡梧凾繝輔か繝ｫ繝/Licenses縲阪↓蜿朱鹸縺励※縺縺ｾ縺吶
+>
+> 縺ｾ縺溘√％縺ｮ繝励Ο繧ｰ繝ｩ繝縺ｯFROM豌上ｮ縲轡TXMania縲阪ｒ蜈縺ｫ陬ｽ菴懊＠縺ｦ縺縺ｾ縺吶
+
+## 繧ｯ繝ｬ繧ｸ繝繝
+> * [TwoPointZero/TJAPlayer3](https://github.com/twopointzero/TJAPlayer3)(@twopointzero)
+> * [KabanFriends/TJAPlayer3](https://github.com/KabanFriends/TJAPlayer3/tree/features)(@KabanFriends)
+> * [Mr-Ojii/TJAPlayer3-f](https://github.com/Mr-Ojii/TJAPlayer3-f)(@Mr-Ojii)
+> * [Akasoko/TJAPlayer3](https://github.com/Akasoko-Master/TJAPlayer3)(@AkasokoR)
diff --git a/Readme.txt b/Readme.txt
new file mode 100644
index 00000000..dd0e3356
--- /dev/null
+++ b/Readme.txt
@@ -0,0 +1,79 @@
+ｻｿ############
+TJAPlayer3 Readme.txt
+############
+蜈ｬ髢区律:2018/5/5
+譖ｴ譁ｰ譌･:2018/12/21
+
+== 縺ｯ縺倥ａ縺ｫ ==
+TJAPlayer3繧偵ム繧ｦ繝ｳ繝ｭ繝ｼ繝峨＠縺ｦ縺縺溘□縺阪√≠繧翫′縺ｨ縺縺斐＊縺縺ｾ縺吶
+縺薙ｮ繧ｷ繝溘Η繝ｬ繝ｼ繧ｿ縺ｯ縲√い繝ｼ繧ｱ繝ｼ繝/螳ｶ蠎ｭ逕ｨ繧ｲ繝ｼ繝縲悟､ｪ鮠薙ｮ驕比ｺｺ縲阪す繝ｪ繝ｼ繧ｺ縺ｮ繧ｷ繝溘Η繝ｬ繝ｼ繧ｿ縺ｧ縺吶
+縺薙ｮ繧ｷ繝溘Η繝ｬ繝ｼ繧ｿ縺ｯ縲ゝJAPlayer2 forPC縺ｨ縺縺繧ｷ繝溘Η繝ｬ繝ｼ繧ｿ繝ｼ繧呈隼騾縺励◆繧ゅｮ縺ｧ縺吶
+螟ｪ鮠薙＆繧捺ｬ｡驛弱ｻTJAPlayer遲峨〒菴ｿ繧上ｌ縺ｦ縺繧.tja繝輔ぃ繧､繝ｫ繧定ｪｭ縺ｿ霎ｼ縺ｿ縲√励Ξ繧､縺吶ｋ縺薙→縺後〒縺阪∪縺吶
+(縺吶∋縺ｦ縺ｮ.tja繝輔ぃ繧､繝ｫ縺瑚ｪｭ縺ｿ霎ｼ繧√ｋ繧上¢縺ｧ縺ｯ縺ゅｊ縺ｾ縺帙ｓ縲ゅ∪縺溘ゝJAPlayer3蛛ｴ縺ｧ霑ｽ蜉縺励◆蜻ｽ莉､繧ゅ≠繧翫∪縺吶)
+髢狗匱騾比ｸｭ縺ｮ繧ｷ繝溘Η繝ｬ繝ｼ繧ｿ縺ｮ縺溘ａ縲∽ｸ榊ｷ蜷医ｄ繝舌げ縺後≠繧句ｴ蜷医′縺ゅｊ縺ｾ縺吶ゅ＃莠謇ｿ縺上□縺輔＞縲
+(繧ゅ＠荳榊ｷ蜷医ｒ隕九▽縺代◆蝣ｴ蜷医ｯ縲；itHub縺ｮissue繧Уwitter縺ｧ騾｣邨｡縺励※縺上□縺輔ｋ縺ｨ縲∝､ｧ螟牙勧縺九ｊ縺ｾ縺吶)
+
+== 菴ｿ逕ｨ荳翫ｮ豕ｨ諢 ==
+繝ｻTJAPlayer3縺ｯ繧ｪ繝ｼ繝励Φ繧ｽ繝ｼ繧ｹ繧ｽ繝輔ヨ繧ｦ繧ｧ繧｢(MIT)縺ｧ縺吶
+繝ｻ縺薙ｮ繧ｷ繝溘Η繝ｬ繝ｼ繧ｿ繧剃ｽｿ逕ｨ縺吶ｋ蝣ｴ蜷医ｯ縲**蜈ｨ縺ｦ閾ｪ蟾ｱ雋ｬ莉ｻ**縺ｧ縺企｡倥＞縺励∪縺吶
+繝ｻ隱ｬ譏取嶌繧縲√ラ繧ｭ繝･繝｡繝ｳ繝医ｒ隕九ｌ縺ｰ隗｣豎ｺ縺ｧ縺阪ｋ雉ｪ蝠上′繧医￥譚･縺ｾ縺吶ゆｺｺ縺ｫ雉ｪ蝠上☆繧句燕縺ｫ縲√∪縺壹ｯ閾ｪ蛻縺ｧ隱ｿ縺ｹ繧九％縺ｨ繧偵＠縺ｦ縺上□縺輔＞縲
+繝ｻ繝励Ο繧ｰ繝ｩ繝縺ｮ蛻ｶ菴懆(AioiLight)縺ｯ縲ゝJAPlayer3譛ｬ菴(AioiLight.space縺九ｉ繝繧ｦ繝ｳ繝ｭ繝ｼ繝峨＠縺溘ｂ縺ｮ)縺ｨ繝繝輔か繝ｫ繝医ｮ繧ｹ繧ｭ繝ｳ縲郡impleStyle縲阪ｮ繧ｵ繝昴ｼ繝医ｮ縺ｿ陦後＞縺ｾ縺吶
+縲縺昴ｮ莉悶ｮ繧ｹ繧ｭ繝ｳ(萓:譛ｬ螳ｶ鬚ｨ繧ｹ繧ｭ繝ｳ)繧縲ゝJAPlayer3縺ｮ謾ｹ騾蜩(豢ｾ逕溘ン繝ｫ繝)縺ｮ繧ｵ繝昴ｼ繝医ｯ蜴溷援陦後＞縺ｾ縺帙ｓ縺ｮ縺ｧ縺比ｺ謇ｿ縺上□縺輔＞縲
+繝ｻ縺吶∋縺ｦ縺ｮ迺ｰ蠅縺ｧ蜍穂ｽ懃｢ｺ隱阪ｯ縺ｧ縺阪↑縺(縺ｧ縺阪ｋ縺ｯ縺壹′縺ｪ縺)縺ｮ縺ｧ縲∝虚縺縺溘ｉ驕九′縺縺縲∫ｨ句ｺｦ縺ｧ縺企｡倥＞縺励∪縺吶
+縲繝峨く繝･繝｡繝ｳ繝医ｒ隱ｭ繧薙〒繧りｧ｣豎ｺ縺励↑縺九▲縺溘ｉ縲∬ｫｦ繧√∪縺励ｇ縺縲りｫｦ繧√ｂ閧晏ｿ縺ｧ縺吶
+繝ｻ蟶ｸ譎60fps繧剃ｿ昴※縺ｪ縺ПC縺ｧ縺ｮ蜍穂ｽ懊ｯ譛溷ｾ縺ｧ縺阪∪縺帙ｓ縲
+
+== 謫堺ｽ懈婿豕輔∵峇縺ｮ霑ｽ蜉譁ｹ豕輔∵峩譁ｰ諠蝣ｱ縺ｪ縺ｩ ==
+https://aioilight.space/taiko/tjap3/
+繝峨く繝･繝｡繝ｳ繝医↓諠蝣ｱ縺碁寔繧√ｉ繧後※縺繧九ｮ縺ｧ縲√◎繧後ｒ縺願ｪｭ縺ｿ縺上□縺輔＞縲る囂譎よ峩譁ｰ縺励※縺縺ｾ縺吶
+
+== 繝繝輔か繝ｫ繝医せ繧ｭ繝ｳ(SimpleStyle)縺ｫ縺､縺縺ｦ ==
+荳驛ｨ逕ｻ蜒上ｯTJAPlayer2 forPC縺ｮ繝繝輔か繝ｫ繝医せ繧ｭ繝ｳ縺九ｉ豬∫畑縺励※縺縺ｾ縺吶
+繝ｩ繧､繧ｻ繝ｳ繧ｹ縺ｯMIT縺ｮ繧ゅ→驕狗畑縺励※縺縺ｾ縺吶MIT繝ｩ繧､繧ｻ繝ｳ繧ｹ繧貞宍螳医☆繧句ｴ蜷医∵隼螟峨驟榊ｸ遲碓K縺ｧ縺吶
+菴懈舌ヤ繝ｼ繝ｫ: Photoshop/After Effects
+
+== 蜍慕判縲驟堺ｿ｡遲峨〒縺ｮ縺泌茜逕ｨ縺ｫ縺､縺縺ｦ ==
+TJAPlayer3繧貞虚逕ｻ蜈ｱ譛峨し繧､繝医ｄ繝ｩ繧､繝夜堺ｿ｡繧ｵ繝ｼ繝薙せ縲√え繧ｧ繝悶し繧､繝医ｄ繝悶Ο繧ｰ遲峨〒縺泌茜逕ｨ縺ｫ縺ｪ繧峨ｌ繧句ｴ蜷医
+繝舌Φ繝繧､繝翫Β繧ｳ繧ｨ繝ｳ繧ｿ繝ｼ繝繧､繝ｳ繝｡繝ｳ繝亥ｬ蠑上ｮ繧ゅｮ縺ｧ縺ｪ縺縺薙→縲∽ｻ悶ｮ螟ｪ鮠薙ｮ驕比ｺｺ繧ｷ繝溘Η繝ｬ繝ｼ繧ｿ繝ｼ縺ｨ豺ｷ蜷後＠縺ｪ縺繧医≧驟肴ｮ繧偵♀鬘倥＞縺縺溘＠縺ｾ縺吶
+縺ｾ縺溘√ち繧ｰ讖溯ｽ縺ｮ縺ゅｋ繧ｵ繧､繝医ｮ蝣ｴ蜷医√卦JAPlayer3縲阪卦JAP3縲阪→縺縺｣縺溘ち繧ｰ繧剃ｻ倥¢繧九％縺ｨ縺ｧ縲
+莉悶す繝溘Η繝ｬ繝ｼ繧ｿ縺ｨ縺ｮ隱､隗｣繧帝亟縺舌→縺ｨ繧ゅ↓縲髢｢騾｣蜍慕判縺ｨ縺励※蜃ｺ繧縺吶￥縺ｪ繧九Γ繝ｪ繝繝医′縺ゅｋ縺溘ａ縲∵耳螂ｨ縺励∪縺吶
+
+== TJAPlayer3縺ｮ謾ｹ騾繝ｻ蜀埼榊ｸ(莠梧ｬ｡驟榊ｸ)繧定｡後≧蝣ｴ蜷医↓縺､縺縺ｦ ==
+TJAPlayer3縲√ョ繝輔か繝ｫ繝医せ繧ｭ繝ｳ縺ｯMIT繝ｩ繧､繧ｻ繝ｳ繧ｹ縺ｧ蛻ｶ菴懊＆繧後※縺縺ｾ縺吶
+MIT繝ｩ繧､繧ｻ繝ｳ繧ｹ縺ｮ繝ｫ繝ｼ繝ｫ縺ｮ繧ゅ→縲∵隼騾繝ｻ蜀埼榊ｸ繧定｡後≧縺薙→縺ｯ閾ｪ逕ｱ縺ｧ縺吶′縲**蜈ｨ縺ｦ閾ｪ蟾ｱ雋ｬ莉ｻ**縺ｧ縺企｡倥＞縺励∪縺吶
+縺ｾ縺溘∽ｽｿ逕ｨ縺励※縺繧九Λ繧､繝悶Λ繝ｪ縺ｮ繝ｩ繧､繧ｻ繝ｳ繧ｹ荳翫**蠢縺**縲鍬icenses縲阪ヵ繧ｩ繝ｫ繝繧貞酔譴ｱ縺ｮ荳翫∵隼騾繝ｻ蜀埼榊ｸ繧偵♀鬘倥＞縺励∪縺吶
+螟夜Κ繧ｹ繧ｭ繝ｳ繧縲∬ｭ憺擇繝代ャ繧ｱ繝ｼ繧ｸ繧貞酔譴ｱ縺吶ｋ蝣ｴ蜷医ｯ縲√◎繧後◇繧後ｮ蛻ｶ菴懆縺ｮ繝ｫ繝ｼ繝ｫ繧隕冗ｴ繧貞ｮ医▲縺ｦ縺上□縺輔＞縲
+縺薙ｌ繧峨↓TJAPlayer3縺ｮ繝ｩ繧､繧ｻ繝ｳ繧ｹ縺ｯ驕ｩ逕ｨ縺輔ｌ縺ｾ縺帙ｓ縲
+
+== 繧ｹ繝壹す繝｣繝ｫ繧ｵ繝ｳ繧ｯ繧ｹ ==
+FROM豌/yyagi豌 - DTXMania 髢狗匱閠
+kairera0467豌 - TJAPlayer2 forPC 髢狗匱閠
+繧阪∩繧ｽ橸ｼ滓ｰ - 繝舌げ蝣ｱ蜻翫∽ｸ榊ｷ蜷亥ｱ蜻
+繧ｳ繝ｼ繧ｷ繝ｼ豌 - 繝舌げ蝣ｱ蜻翫∽ｸ榊ｷ蜷亥ｱ蜻
+twopointzero豌 - 繝励Ο繧ｰ繝ｩ繝縺ｮ譛驕ｩ蛹
+
+
+== 荳榊ｷ蜷亥ｱ蜻翫騾｣邨｡蜈医↑縺ｩ ==
+
+=== 譌｢遏･縺ｮ蝠城｡檎せ ===
+繝ｻ譌･譛ｬ隱樒腸蠅縺ｧ繧ゅ励Ο繧ｰ繝ｩ繝蜀驛ｨ縺ｧ縺ｯ闍ｱ隱樒腸蠅縺ｨ隱崎ｭ倥＆繧後※繧ｷ繧ｹ繝繝繝｡繝繧ｻ繝ｼ繧ｸ縺後⊇縺ｼ闍ｱ隱槭〒縺吶 竊歎er.1.5.6縺九ｉ譌･譛ｬ隱樒腸蠅縺ｮ蝣ｴ蜷医ｯ譌･譛ｬ隱槭〒陦ｨ遉ｺ縺輔ｌ繧九ｈ縺縺ｫ縺ｪ繧翫∪縺励◆縲
+繝ｻ繝繝ｳ繧ｵ繝ｼ縲√Δ繝悶√Λ繝ｳ繝翫ｼ逕ｻ蜒上ｮ繧ｵ繧､繧ｺ縺悟､ｧ縺阪＞縺ｨ迸ｬ髢鍋噪縺ｫ繧ｫ繧ｯ縺､縺上°繧ゅ＠繧後∪縺帙ｓ縲ゅ％繧後↓縺､縺縺ｦ縺ｯ荳蠎ｦ蜀咲函縺吶ｋ縺ｨ逶ｴ繧翫∪縺吶や巽astRender繧丹N縺ｫ縺吶ｌ縺ｰ螟ｧ謚ｵ縺ｮPC縺ｧ縺ｯ繧ｫ繧ｯ縺､縺九★縺ｫ蜀咲函縺輔ｌ縺ｾ縺吶
+繝ｻ蜻ｽ莉､縺ｨ蛟､縺ｮ髢薙↓蜊願ｧ偵せ繝壹ｼ繧ｹ縺悟･縺｣縺ｦ縺ｪ縺縺ｨ豁｣蟶ｸ縺ｫ蜀咲函縺輔ｌ縺ｾ縺帙ｓ縲(e.g. #SCROLL1.5)
+繝ｻ荳譖ｲ蜀咲函蠕後ｮ譖ｲ縺ｮ繧ｽ繝ｼ繝医′縺ｧ縺阪∪縺帙ｓ縲や剃ｿｮ豁｣縺輔ｌ縺ｾ縺励◆縲
+繝ｻ繧繧顔峩縺玲凾縺ｫ縺ｵ縺縺帙ｓ縺梧ｶ医∴縺ｾ縺吶
+繝ｻ隴憺擇蛻蟯舌ｮ荳榊ｷ蜷医′縺縺上▽縺区ｮ九▲縺溘∪縺ｾ縺ｧ縺吶
+
+=== 雉ｪ蝠上ｒ縺吶ｋ蜑阪↓ ===
+雉ｪ蝠上ｒ縺吶ｋ蜑阪↓縲
+1.隱ｿ縺ｹ繧句燕縺ｫ閠縺医ｋ
+2.莠ｺ縺ｫ閨槭￥蜑阪↓隱ｿ縺ｹ繧
+3.驕主悉縺ｫ蜷後§繧医≧縺ｪ雉ｪ蝠上′縺ｪ縺九▲縺溘°隱ｿ縺ｹ繧
+4.菴ｿ逕ｨ縺励※縺繧九ヱ繧ｽ繧ｳ繝ｳ縺ｮ迺ｰ蠅縲√←縺縺縺蜍穂ｽ懊ｒ縺励◆繧我ｸ榊ｷ蜷医ｒ襍ｷ縺薙＠縺溘°縺ｮ驕守ｨ狗ｭ峨ｒ豺ｻ縺医※騾｣邨｡縺吶ｋ
+縺薙ｮ4縺､縺ｮ繝ｫ繝ｼ繝ｫ繧貞ｮ医▲縺ｦ縺縺溘□縺代ｌ縺ｰ蟷ｸ縺縺ｧ縺吶ゅ←縺縺九ｈ繧阪＠縺上♀縺ｭ縺後＞縺励∪縺吶
+
+=== 蜷騾｣邨｡蜈 ===
+荳榊ｷ蜷亥ｱ蜻翫∵眠隕乗ｩ溯ｽ霑ｽ蜉縺ｮ繝ｪ繧ｯ繧ｨ繧ｹ繝育ｭ峨∝､ｧ豁楢ｿ弱〒縺吶
+Twitter: @TJAPlayer3
+繝｡繝ｼ繝ｫ: info@aioilight.space
+Discord: AioiLight#7839
+GitHub: https://github.com/AioiLight/TJAPlayer3
diff --git a/TJAPlayer3.sln b/TJAPlayer3.sln
new file mode 100644
index 00000000..ca03a716
--- /dev/null
+++ b/TJAPlayer3.sln
@@ -0,0 +1,45 @@
+ｻｿ
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 16
+VisualStudioVersion = 16.0.30621.155
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "TJAPlayer3", "TJAPlayer3\TJAPlayer3.csproj", "{81BEC512-8074-4BD1-8A3C-AC73BC7BF846}"
+ ProjectSection(ProjectDependencies) = postProject
+ {BCD40908-F3E2-4707-BFAA-1DD99DF6357D} = {BCD40908-F3E2-4707-BFAA-1DD99DF6357D}
+ EndProjectSection
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "FDK19", "FDK19\FDK19.csproj", "{BCD40908-F3E2-4707-BFAA-1DD99DF6357D}"
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{8559AC0D-9443-4CF6-A376-B72664B2DC0B}"
+ ProjectSection(SolutionItems) = preProject
+ Readme.txt = Readme.txt
+ EndProjectSection
+EndProject
+Global
+ GlobalSection(SolutionConfigurationPlatforms) = preSolution
+ Debug|x86 = Debug|x86
+ Release|x86 = Release|x86
+ EndGlobalSection
+ GlobalSection(ProjectConfigurationPlatforms) = postSolution
+ {81BEC512-8074-4BD1-8A3C-AC73BC7BF846}.Debug|x86.ActiveCfg = Debug|x86
+ {81BEC512-8074-4BD1-8A3C-AC73BC7BF846}.Debug|x86.Build.0 = Debug|x86
+ {81BEC512-8074-4BD1-8A3C-AC73BC7BF846}.Release|x86.ActiveCfg = Release|x86
+ {81BEC512-8074-4BD1-8A3C-AC73BC7BF846}.Release|x86.Build.0 = Release|x86
+ {BCD40908-F3E2-4707-BFAA-1DD99DF6357D}.Debug|x86.ActiveCfg = Debug|x86
+ {BCD40908-F3E2-4707-BFAA-1DD99DF6357D}.Debug|x86.Build.0 = Debug|x86
+ {BCD40908-F3E2-4707-BFAA-1DD99DF6357D}.Release|x86.ActiveCfg = Release|x86
+ {BCD40908-F3E2-4707-BFAA-1DD99DF6357D}.Release|x86.Build.0 = Release|x86
+ EndGlobalSection
+ GlobalSection(SolutionProperties) = preSolution
+ HideSolutionNode = FALSE
+ EndGlobalSection
+ GlobalSection(ExtensibilityGlobals) = postSolution
+ SolutionGuid = {20D6B8F0-EEEF-4E88-BC6A-DC1FF10E5AEA}
+ EndGlobalSection
+ GlobalSection(Performance) = preSolution
+ HasPerformanceSessions = true
+ EndGlobalSection
+ GlobalSection(Performance) = preSolution
+ HasPerformanceSessions = true
+ EndGlobalSection
+EndGlobal
diff --git a/TJAPlayer3/Animations/Animator.cs b/TJAPlayer3/Animations/Animator.cs
new file mode 100644
index 00000000..995946e8
--- /dev/null
+++ b/TJAPlayer3/Animations/Animator.cs
@@ -0,0 +1,119 @@
+ｻｿusing System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using TJAPlayer3;
+using FDK;
+
+namespace TJAPlayer3.Animations
+{
+ class Animator : IAnimatable
+ {
+ public Animator(int startValue, int endValue, int tickInterval, bool isLoop)
+ {
+ Type = CounterType.Normal;
+ StartValue = startValue;
+ EndValue = endValue;
+ TickInterval = tickInterval;
+ IsLoop = isLoop;
+ Counter = new CCounter();
+ }
+ public Animator(double startValue, double endValue, double tickInterval, bool isLoop)
+ {
+ Type = CounterType.Double;
+ StartValue = startValue;
+ EndValue = endValue;
+ TickInterval = tickInterval;
+ IsLoop = isLoop;
+ Counter = new CCounter();
+ }
+ public void Start()
+ {
+ if (Counter == null) throw new NullReferenceException();
+ switch (Type)
+ {
+ case CounterType.Normal:
+ Counter.t髢句ｧ((int)StartValue, (int)EndValue, (int)TickInterval, TJAPlayer3.Timer);
+ break;
+ case CounterType.Double:
+ Counter.t髢句ｧ((double)StartValue, (double)EndValue, (double)TickInterval, CSound邂｡逅.rc貍泌･冗畑繧ｿ繧､繝);
+ break;
+ default:
+ break;
+ }
+ }
+ public void Stop()
+ {
+ if (Counter == null) throw new NullReferenceException();
+ Counter.t蛛懈ｭ｢();
+ }
+ public void Reset()
+ {
+ if (Counter == null) throw new NullReferenceException();
+ Start();
+ }
+
+ public void Tick()
+ {
+ if (Counter == null) throw new NullReferenceException();
+ switch (Type)
+ {
+ case CounterType.Normal:
+ if (IsLoop) Counter.t騾ｲ陦鍬oop(); else Counter.t騾ｲ陦();
+ if (!IsLoop && Counter.b邨ゆｺ蛟､縺ｫ驕斐＠縺) Stop();
+ break;
+ case CounterType.Double:
+ if (IsLoop) Counter.t騾ｲ陦鍬oopDb(); else Counter.t騾ｲ陦慧b();
+ if (!IsLoop && Counter.b邨ゆｺ蛟､縺ｫ驕斐＠縺) Stop();
+ break;
+ default:
+ break;
+ }
+ }
+
+ public virtual object GetAnimation()
+ {
+ throw new NotImplementedException();
+ }
+
+
+
+ // 繝励Ο繝代ユ繧｣
+ public CCounter Counter
+ {
+ get;
+ private set;
+ }
+ public CounterType Type
+ {
+ get;
+ private set;
+ }
+ public object StartValue
+ {
+ get;
+ private set;
+ }
+ public object EndValue
+ {
+ get;
+ private set;
+ }
+ public object TickInterval
+ {
+ get;
+ private set;
+ }
+ public bool IsLoop
+ {
+ get;
+ private set;
+ }
+ }
+
+ enum CounterType
+ {
+ Normal,
+ Double
+ }
+}
diff --git a/TJAPlayer3/Animations/EaseIn.cs b/TJAPlayer3/Animations/EaseIn.cs
new file mode 100644
index 00000000..a8031c32
--- /dev/null
+++ b/TJAPlayer3/Animations/EaseIn.cs
@@ -0,0 +1,38 @@
+ｻｿusing System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace TJAPlayer3.Animations
+{
+ ///
+ /// 繧､繝ｼ繧ｺ繧､繝ｳ繧定｡後≧繧ｯ繝ｩ繧ｹ縲
+ ///
+ class EaseIn : Animator
+ {
+ ///
+ /// 繧､繝ｼ繧ｺ繧､繝ｳ繧貞晄悄蛹悶＠縺ｾ縺吶
+ ///
+ /// 蟋狗せ縲
+ /// 邨らせ縲
+ /// 繧､繝ｼ繧ｸ繝ｳ繧ｰ縺ｫ縺九¢繧区凾髢薙
+ public EaseIn(int startPoint, int endPoint, int timeMs) : base(0, timeMs, 1, false)
+ {
+ StartPoint = startPoint;
+ EndPoint = endPoint;
+ Sa = EndPoint - StartPoint;
+ TimeMs = timeMs;
+ }
+
+ public override object GetAnimation()
+ {
+ var persent = Counter.n迴ｾ蝨ｨ縺ｮ蛟､ / (double)TimeMs;
+ return ((double)Sa * persent * persent * persent) + StartPoint;
+ }
+
+ private readonly int StartPoint;
+ private readonly int EndPoint;
+ private readonly int Sa;
+ private readonly int TimeMs;
+ }
+}
diff --git a/TJAPlayer3/Animations/EaseInOut.cs b/TJAPlayer3/Animations/EaseInOut.cs
new file mode 100644
index 00000000..2b077582
--- /dev/null
+++ b/TJAPlayer3/Animations/EaseInOut.cs
@@ -0,0 +1,46 @@
+ｻｿusing System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace TJAPlayer3.Animations
+{
+ ///
+ /// 繧､繝ｼ繧ｺ繧､繝ｳ繝ｻ繧｢繧ｦ繝医ｒ陦後≧繧ｯ繝ｩ繧ｹ縲
+ ///
+ class EaseInOut : Animator
+ {
+ ///
+ /// 繧､繝ｼ繧ｺ繧､繝ｳ繝ｻ繧｢繧ｦ繝医ｒ蛻晄悄蛹悶＠縺ｾ縺吶
+ ///
+ /// 蟋狗せ縲
+ /// 邨らせ縲
+ /// 繧､繝ｼ繧ｸ繝ｳ繧ｰ縺ｫ縺九¢繧区凾髢薙
+ public EaseInOut(int startPoint, int endPoint, int timeMs) : base(0, timeMs, 1, false)
+ {
+ StartPoint = startPoint;
+ EndPoint = endPoint;
+ Sa = EndPoint - StartPoint;
+ TimeMs = timeMs;
+ }
+
+ public override object GetAnimation()
+ {
+ var persent = Counter.n迴ｾ蝨ｨ縺ｮ蛟､ / (double)TimeMs * 2.0;
+ if (persent < 1)
+ {
+ return ((double)Sa / 2.0 * persent * persent * persent) + StartPoint;
+ }
+ else
+ {
+ persent -= 2;
+ return ((double)Sa / 2.0 * ((persent * persent * persent) + 2)) + StartPoint;
+ }
+ }
+
+ private readonly int StartPoint;
+ private readonly int EndPoint;
+ private readonly int Sa;
+ private readonly int TimeMs;
+ }
+}
diff --git a/TJAPlayer3/Animations/EaseOut.cs b/TJAPlayer3/Animations/EaseOut.cs
new file mode 100644
index 00000000..3e6a03f9
--- /dev/null
+++ b/TJAPlayer3/Animations/EaseOut.cs
@@ -0,0 +1,39 @@
+ｻｿusing System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace TJAPlayer3.Animations
+{
+ ///
+ /// 繧､繝ｼ繧ｺ繧｢繧ｦ繝医ｒ陦後≧繧ｯ繝ｩ繧ｹ縲
+ ///
+ class EaseOut : Animator
+ {
+ ///
+ /// 繧､繝ｼ繧ｺ繧｢繧ｦ繝医ｒ蛻晄悄蛹悶＠縺ｾ縺吶
+ ///
+ /// 蟋狗せ縲
+ /// 邨らせ縲
+ /// 繧､繝ｼ繧ｸ繝ｳ繧ｰ縺ｫ縺九¢繧区凾髢薙
+ public EaseOut(int startPoint, int endPoint, int timeMs) : base(0, timeMs, 1, false)
+ {
+ StartPoint = startPoint;
+ EndPoint = endPoint;
+ Sa = EndPoint - StartPoint;
+ TimeMs = timeMs;
+ }
+
+ public override object GetAnimation()
+ {
+ var persent = Counter.n迴ｾ蝨ｨ縺ｮ蛟､ / (double)TimeMs;
+ persent -= 1;
+ return (double)Sa * (persent * persent * persent + 1) + StartPoint;
+ }
+
+ private readonly int StartPoint;
+ private readonly int EndPoint;
+ private readonly int Sa;
+ private readonly int TimeMs;
+ }
+}
diff --git a/TJAPlayer3/Animations/FadeIn.cs b/TJAPlayer3/Animations/FadeIn.cs
new file mode 100644
index 00000000..9e4a3521
--- /dev/null
+++ b/TJAPlayer3/Animations/FadeIn.cs
@@ -0,0 +1,34 @@
+ｻｿusing System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace TJAPlayer3.Animations
+{
+ ///
+ /// 繝輔ぉ繝ｼ繝峨う繝ｳ繧定｡後≧繧ｯ繝ｩ繧ｹ縲
+ ///
+ internal class FadeIn : Animator
+ {
+ ///
+ /// 繝輔ぉ繝ｼ繝峨う繝ｳ繧貞晄悄蛹悶＠縺ｾ縺吶
+ ///
+ /// 繝輔ぉ繝ｼ繝峨う繝ｳ縺ｫ謗帙¢繧狗ｧ呈焚(繝溘Μ遘)
+ public FadeIn(int timems) : base(0, timems - 1, 1, false)
+ {
+ TimeMs = timems;
+ }
+
+ ///
+ /// 繝輔ぉ繝ｼ繝峨う繝ｳ縺ｮ荳埼乗主ｺｦ繧255谿ｵ髫弱〒霑斐＠縺ｾ縺吶
+ ///
+ /// 荳埼乗主ｺｦ縲
+ public override object GetAnimation()
+ {
+ var opacity = base.Counter.n迴ｾ蝨ｨ縺ｮ蛟､ * 255 / TimeMs;
+ return opacity;
+ }
+
+ private readonly int TimeMs;
+ }
+}
diff --git a/TJAPlayer3/Animations/FadeOut.cs b/TJAPlayer3/Animations/FadeOut.cs
new file mode 100644
index 00000000..87989cf5
--- /dev/null
+++ b/TJAPlayer3/Animations/FadeOut.cs
@@ -0,0 +1,34 @@
+ｻｿusing System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace TJAPlayer3.Animations
+{
+ ///
+ /// 繝輔ぉ繝ｼ繝峨い繧ｦ繝医ｒ陦後≧繧ｯ繝ｩ繧ｹ縲
+ ///
+ internal class FadeOut : Animator
+ {
+ ///
+ /// 繝輔ぉ繝ｼ繝峨い繧ｦ繝医ｒ蛻晄悄蛹悶＠縺ｾ縺吶
+ ///
+ /// 繝輔ぉ繝ｼ繝峨い繧ｦ繝医↓謗帙¢繧狗ｧ呈焚(繝溘Μ遘)
+ public FadeOut(int timems) : base(0, timems - 1, 1, false)
+ {
+ TimeMs = timems;
+ }
+
+ ///
+ /// 繝輔ぉ繝ｼ繝峨い繧ｦ繝医ｮ荳埼乗主ｺｦ繧255谿ｵ髫弱〒霑斐＠縺ｾ縺吶
+ ///
+ /// 荳埼乗主ｺｦ縲
+ public override object GetAnimation()
+ {
+ var opacity = (TimeMs - base.Counter.n迴ｾ蝨ｨ縺ｮ蛟､) * 255 / TimeMs;
+ return opacity;
+ }
+
+ private readonly int TimeMs;
+ }
+}
diff --git a/TJAPlayer3/Animations/IAnimatable.cs b/TJAPlayer3/Animations/IAnimatable.cs
new file mode 100644
index 00000000..4e09befa
--- /dev/null
+++ b/TJAPlayer3/Animations/IAnimatable.cs
@@ -0,0 +1,35 @@
+ｻｿusing System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace TJAPlayer3.Animations
+{
+ ///
+ /// 繧｢繝九Γ繝ｼ繧ｷ繝ｧ繝ｳ 繧､繝ｳ繧ｿ繝ｼ繝輔ぉ繧､繧ｹ縲
+ ///
+ interface IAnimatable
+ {
+ ///
+ /// 繧｢繝九Γ繝ｼ繧ｷ繝ｧ繝ｳ繧帝幕蟋九＠縺ｾ縺吶
+ ///
+ void Start();
+ ///
+ /// 繧｢繝九Γ繝ｼ繧ｷ繝ｧ繝ｳ繧貞●豁｢縺励∪縺吶
+ ///
+ void Stop();
+ ///
+ /// 繧｢繝九Γ繝ｼ繧ｷ繝ｧ繝ｳ繧偵Μ繧ｻ繝繝医＠縺ｾ縺吶
+ ///
+ void Reset();
+ ///
+ /// 繧｢繝九Γ繝ｼ繧ｷ繝ｧ繝ｳ縺ｮ騾ｲ陦後ｒ陦後＞縺ｾ縺吶
+ ///
+ void Tick();
+ ///
+ /// 繧｢繝九Γ繝ｼ繧ｷ繝ｧ繝ｳ縺ｮ繝代Λ繝｡繝ｼ繧ｿ繧定ｿ斐＠縺ｾ縺吶
+ ///
+ /// 繧｢繝九Γ繝ｼ繧ｷ繝ｧ繝ｳ縺ｮ繝代Λ繝｡繝ｼ繧ｿ繧定ｿ斐＠縺ｾ縺吶
+ object GetAnimation();
+ }
+}
diff --git a/TJAPlayer3/Animations/Linear.cs b/TJAPlayer3/Animations/Linear.cs
new file mode 100644
index 00000000..c6d0b6f9
--- /dev/null
+++ b/TJAPlayer3/Animations/Linear.cs
@@ -0,0 +1,38 @@
+ｻｿusing System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace TJAPlayer3.Animations
+{
+ ///
+ /// 繝ｪ繝九い遘ｻ蜍輔ｒ陦後≧繧ｯ繝ｩ繧ｹ縲
+ ///
+ class Linear : Animator
+ {
+ ///
+ /// 繝ｪ繝九い遘ｻ蜍輔ｒ蛻晄悄蛹悶＠縺ｾ縺吶
+ ///
+ /// 蟋狗せ縲
+ /// 邨らせ縲
+ /// 遘ｻ蜍輔↓縺九¢繧区凾髢薙
+ public Linear(int startPoint, int endPoint, int timeMs) : base(0, timeMs, 1, false)
+ {
+ StartPoint = startPoint;
+ EndPoint = endPoint;
+ Sa = EndPoint - StartPoint;
+ TimeMs = timeMs;
+ }
+
+ public override object GetAnimation()
+ {
+ var persent = Counter.n迴ｾ蝨ｨ縺ｮ蛟､ / (double)TimeMs;
+ return (Sa * persent) + StartPoint;
+ }
+
+ private readonly int StartPoint;
+ private readonly int EndPoint;
+ private readonly int Sa;
+ private readonly int TimeMs;
+ }
+}
diff --git a/TJAPlayer3/Common/CActFlushGPU.cs b/TJAPlayer3/Common/CActFlushGPU.cs
new file mode 100644
index 00000000..ee28d54b
--- /dev/null
+++ b/TJAPlayer3/Common/CActFlushGPU.cs
@@ -0,0 +1,61 @@
+ｻｿusing System;
+using System.Collections.Generic;
+using System.Text;
+using System.Diagnostics;
+using SlimDX.Direct3D9;
+using FDK;
+
+namespace TJAPlayer3
+{
+ ///
+ /// 謠冗判繝輔Ξ繝ｼ繝豈弱↓GPU繧偵ヵ繝ｩ繝繧ｷ繝･縺励※縲∵緒逕ｻ驕蟒ｶ繧帝亟縺舌
+ /// DirectX9縺ｮ縲＾cclusion Query繧堤畑縺繧九(Flush螻樊ｧ莉倥″縺ｧGetData縺吶ｋ)
+ /// Device Lost蟇ｾ遲悶ｮ縺溘ａ縲＿ueue繧辰Activitiy縺ｮManaged繝ｪ繧ｽ繝ｼ繧ｹ縺ｨ縺励※謇ｱ縺縲
+ /// On騾ｲ陦梧緒逕ｻ()繧貞他縺ｳ蜃ｺ縺吶％縺ｨ縺ｧ縲；PU繧偵ヵ繝ｩ繝繧ｷ繝･縺吶ｋ縲
+ ///
+ internal class CActFlushGPU : CActivity
+ {
+ // CActivity 螳溯｣
+
+ public override void OnManaged繝ｪ繧ｽ繝ｼ繧ｹ縺ｮ菴懈()
+ {
+ if ( !base.b豢ｻ諤ｧ蛹悶＠縺ｦ縺ｪ縺 )
+ {
+ try // #xxxxx 2012.12.31 yyagi: to prepare flush, first of all, I create q queue to the GPU.
+ {
+ IDirect3DQuery9 = new Query(TJAPlayer3.app.Device.UnderlyingDevice, QueryType.Occlusion);
+ }
+ catch ( Exception e )
+ {
+ Trace.TraceError( e.ToString() );
+ Trace.TraceError( "萓句､悶′逋ｺ逕溘＠縺ｾ縺励◆縺悟ｦ逅繧堤ｶ咏ｶ壹＠縺ｾ縺吶 (e5c7cd0b-f7bb-4bf1-9ad9-db27b43ff63d)" );
+ }
+ base.OnManaged繝ｪ繧ｽ繝ｼ繧ｹ縺ｮ菴懈();
+ }
+ }
+ public override void OnManaged繝ｪ繧ｽ繝ｼ繧ｹ縺ｮ隗｣謾ｾ()
+ {
+ IDirect3DQuery9.Dispose();
+ IDirect3DQuery9 = null;
+ base.OnManaged繝ｪ繧ｽ繝ｼ繧ｹ縺ｮ隗｣謾ｾ();
+ }
+ public override int On騾ｲ陦梧緒逕ｻ()
+ {
+ if ( !base.b豢ｻ諤ｧ蛹悶＠縺ｦ縺ｪ縺 )
+ {
+ IDirect3DQuery9.Issue( Issue.End );
+ DWM.Flush();
+ IDirect3DQuery9.GetData( true ); // flush GPU queue
+ }
+ return 0;
+ }
+
+ // 縺昴ｮ莉
+
+ #region [ private ]
+ //-----------------
+ private Query IDirect3DQuery9;
+ //-----------------
+ #endregion
+ }
+}
diff --git a/TJAPlayer3/Common/CConfigIni.cs b/TJAPlayer3/Common/CConfigIni.cs
new file mode 100644
index 00000000..57dfd006
--- /dev/null
+++ b/TJAPlayer3/Common/CConfigIni.cs
@@ -0,0 +1,3066 @@
+ｻｿusing System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Text;
+using System.Runtime.InteropServices;
+using System.IO;
+using System.Diagnostics;
+using FDK;
+using FDK.ExtensionMethods;
+
+namespace TJAPlayer3
+{
+ internal class CConfigIni : INotifyPropertyChanged
+ {
+ private const int MinimumKeyboardSoundLevelIncrement = 1;
+ private const int MaximumKeyboardSoundLevelIncrement = 20;
+ private const int DefaultKeyboardSoundLevelIncrement = 5;
+
+ // 繧ｯ繝ｩ繧ｹ
+
+ #region [ CKeyAssign ]
+ public class CKeyAssign
+ {
+ public class CKeyAssignPad
+ {
+ public CConfigIni.CKeyAssign.STKEYASSIGN[] HH
+ {
+ get
+ {
+ return this.padHH_R;
+ }
+ set
+ {
+ this.padHH_R = value;
+ }
+ }
+ public CConfigIni.CKeyAssign.STKEYASSIGN[] R
+ {
+ get
+ {
+ return this.padHH_R;
+ }
+ set
+ {
+ this.padHH_R = value;
+ }
+ }
+ public CConfigIni.CKeyAssign.STKEYASSIGN[] SD
+ {
+ get
+ {
+ return this.padSD_G;
+ }
+ set
+ {
+ this.padSD_G = value;
+ }
+ }
+ public CConfigIni.CKeyAssign.STKEYASSIGN[] G
+ {
+ get
+ {
+ return this.padSD_G;
+ }
+ set
+ {
+ this.padSD_G = value;
+ }
+ }
+ public CConfigIni.CKeyAssign.STKEYASSIGN[] BD
+ {
+ get
+ {
+ return this.padBD_B;
+ }
+ set
+ {
+ this.padBD_B = value;
+ }
+ }
+ public CConfigIni.CKeyAssign.STKEYASSIGN[] B
+ {
+ get
+ {
+ return this.padBD_B;
+ }
+ set
+ {
+ this.padBD_B = value;
+ }
+ }
+ public CConfigIni.CKeyAssign.STKEYASSIGN[] HT
+ {
+ get
+ {
+ return this.padHT_Pick;
+ }
+ set
+ {
+ this.padHT_Pick = value;
+ }
+ }
+ public CConfigIni.CKeyAssign.STKEYASSIGN[] Pick
+ {
+ get
+ {
+ return this.padHT_Pick;
+ }
+ set
+ {
+ this.padHT_Pick = value;
+ }
+ }
+ public CConfigIni.CKeyAssign.STKEYASSIGN[] LT
+ {
+ get
+ {
+ return this.padLT_Wail;
+ }
+ set
+ {
+ this.padLT_Wail = value;
+ }
+ }
+ public CConfigIni.CKeyAssign.STKEYASSIGN[] Wail
+ {
+ get
+ {
+ return this.padLT_Wail;
+ }
+ set
+ {
+ this.padLT_Wail = value;
+ }
+ }
+ public CConfigIni.CKeyAssign.STKEYASSIGN[] FT
+ {
+ get
+ {
+ return this.padFT_Cancel;
+ }
+ set
+ {
+ this.padFT_Cancel = value;
+ }
+ }
+ public CConfigIni.CKeyAssign.STKEYASSIGN[] Cancel
+ {
+ get
+ {
+ return this.padFT_Cancel;
+ }
+ set
+ {
+ this.padFT_Cancel = value;
+ }
+ }
+ public CConfigIni.CKeyAssign.STKEYASSIGN[] CY
+ {
+ get
+ {
+ return this.padCY_Decide;
+ }
+ set
+ {
+ this.padCY_Decide = value;
+ }
+ }
+ public CConfigIni.CKeyAssign.STKEYASSIGN[] Decide
+ {
+ get
+ {
+ return this.padCY_Decide;
+ }
+ set
+ {
+ this.padCY_Decide = value;
+ }
+ }
+ public CConfigIni.CKeyAssign.STKEYASSIGN[] HHO
+ {
+ get
+ {
+ return this.padHHO;
+ }
+ set
+ {
+ this.padHHO = value;
+ }
+ }
+ public CConfigIni.CKeyAssign.STKEYASSIGN[] RD
+ {
+ get
+ {
+ return this.padRD;
+ }
+ set
+ {
+ this.padRD = value;
+ }
+ }
+ public CConfigIni.CKeyAssign.STKEYASSIGN[] LC
+ {
+ get
+ {
+ return this.padLC;
+ }
+ set
+ {
+ this.padLC = value;
+ }
+ }
+ public CConfigIni.CKeyAssign.STKEYASSIGN[] LP
+ {
+ get
+ {
+ return this.padLP;
+ }
+ set
+ {
+ this.padLP = value;
+ }
+ }
+ public CConfigIni.CKeyAssign.STKEYASSIGN[] LBD
+ {
+ get
+ {
+ return this.padLBD;
+ }
+ set
+ {
+ this.padLBD = value;
+ }
+ }
+ public CConfigIni.CKeyAssign.STKEYASSIGN[] Capture
+ {
+ get
+ {
+ return this.padCapture;
+ }
+ set
+ {
+ this.padCapture = value;
+ }
+ }
+ public CConfigIni.CKeyAssign.STKEYASSIGN[] LeftRed
+ {
+ get
+ {
+ return this.padLRed;
+ }
+ set
+ {
+ this.padLRed = value;
+ }
+ }
+ public CConfigIni.CKeyAssign.STKEYASSIGN[] RightRed
+ {
+ get
+ {
+ return this.padRRed;
+ }
+ set
+ {
+ this.padRRed = value;
+ }
+ }
+ public CConfigIni.CKeyAssign.STKEYASSIGN[] LeftBlue
+ {
+ get
+ {
+ return this.padLBlue;
+ }
+ set
+ {
+ this.padLBlue = value;
+ }
+ }
+ public CConfigIni.CKeyAssign.STKEYASSIGN[] RightBlue
+ {
+ get
+ {
+ return this.padRBlue;
+ }
+ set
+ {
+ this.padRBlue = value;
+ }
+ }
+ public CConfigIni.CKeyAssign.STKEYASSIGN[] LeftRed2P
+ {
+ get
+ {
+ return this.padLRed2P;
+ }
+ set
+ {
+ this.padLRed2P = value;
+ }
+ }
+ public CConfigIni.CKeyAssign.STKEYASSIGN[] RightRed2P
+ {
+ get
+ {
+ return this.padRRed2P;
+ }
+ set
+ {
+ this.padRRed2P = value;
+ }
+ }
+ public CConfigIni.CKeyAssign.STKEYASSIGN[] LeftBlue2P
+ {
+ get
+ {
+ return this.padLBlue2P;
+ }
+ set
+ {
+ this.padLBlue2P = value;
+ }
+ }
+ public CConfigIni.CKeyAssign.STKEYASSIGN[] RightBlue2P
+ {
+ get
+ {
+ return this.padRBlue2P;
+ }
+ set
+ {
+ this.padRBlue2P = value;
+ }
+ }
+ public CConfigIni.CKeyAssign.STKEYASSIGN[] this[ int index ]
+ {
+ get
+ {
+ switch ( index )
+ {
+ case (int) EKeyConfigPad.HH:
+ return this.padHH_R;
+
+ case (int) EKeyConfigPad.SD:
+ return this.padSD_G;
+
+ case (int) EKeyConfigPad.BD:
+ return this.padBD_B;
+
+ case (int) EKeyConfigPad.HT:
+ return this.padHT_Pick;
+
+ case (int) EKeyConfigPad.LT:
+ return this.padLT_Wail;
+
+ case (int) EKeyConfigPad.FT:
+ return this.padFT_Cancel;
+
+ case (int) EKeyConfigPad.CY:
+ return this.padCY_Decide;
+
+ case (int) EKeyConfigPad.HHO:
+ return this.padHHO;
+
+ case (int) EKeyConfigPad.RD:
+ return this.padRD;
+
+ case (int) EKeyConfigPad.LC:
+ return this.padLC;
+
+ case (int) EKeyConfigPad.LP: // #27029 2012.1.4 from
+ return this.padLP; //
+
+ case (int) EKeyConfigPad.LBD: // #27029 2012.1.4 from
+ return this.padLBD; //
+
+ case (int) EKeyConfigPad.LRed:
+ return this.padLRed;
+
+ case (int) EKeyConfigPad.RRed:
+ return this.padRRed;
+
+ case (int) EKeyConfigPad.LBlue:
+ return this.padLBlue;
+
+ case (int) EKeyConfigPad.RBlue:
+ return this.padRBlue;
+
+ case (int) EKeyConfigPad.LRed2P:
+ return this.padLRed2P;
+
+ case (int) EKeyConfigPad.RRed2P:
+ return this.padRRed2P;
+
+ case (int) EKeyConfigPad.LBlue2P:
+ return this.padLBlue2P;
+
+ case (int) EKeyConfigPad.RBlue2P:
+ return this.padRBlue2P;
+
+ case (int) EKeyConfigPad.Capture:
+ return this.padCapture;
+ }
+ throw new IndexOutOfRangeException();
+ }
+ set
+ {
+ switch ( index )
+ {
+ case (int) EKeyConfigPad.HH:
+ this.padHH_R = value;
+ return;
+
+ case (int) EKeyConfigPad.SD:
+ this.padSD_G = value;
+ return;
+
+ case (int) EKeyConfigPad.BD:
+ this.padBD_B = value;
+ return;
+
+ case (int) EKeyConfigPad.Pick:
+ this.padHT_Pick = value;
+ return;
+
+ case (int) EKeyConfigPad.LT:
+ this.padLT_Wail = value;
+ return;
+
+ case (int) EKeyConfigPad.FT:
+ this.padFT_Cancel = value;
+ return;
+
+ case (int) EKeyConfigPad.CY:
+ this.padCY_Decide = value;
+ return;
+
+ case (int) EKeyConfigPad.HHO:
+ this.padHHO = value;
+ return;
+
+ case (int) EKeyConfigPad.RD:
+ this.padRD = value;
+ return;
+
+ case (int) EKeyConfigPad.LC:
+ this.padLC = value;
+ return;
+
+ case (int) EKeyConfigPad.LP:
+ this.padLP = value;
+ return;
+
+ case (int) EKeyConfigPad.LBD:
+ this.padLBD = value;
+ return;
+
+ case (int) EKeyConfigPad.LRed:
+ this.padLRed = value;
+ return;
+
+ case (int) EKeyConfigPad.RRed:
+ this.padRRed = value;
+ return;
+
+ case (int) EKeyConfigPad.LBlue:
+ this.padLBlue = value;
+ return;
+
+ case (int) EKeyConfigPad.RBlue:
+ this.padRBlue = value;
+ return;
+
+ case (int) EKeyConfigPad.LRed2P:
+ this.padLRed2P = value;
+ return;
+
+ case (int) EKeyConfigPad.RRed2P:
+ this.padRRed2P = value;
+ return;
+
+ case (int) EKeyConfigPad.LBlue2P:
+ this.padLBlue2P = value;
+ return;
+
+ case (int) EKeyConfigPad.RBlue2P:
+ this.padRBlue2P = value;
+ return;
+
+ case (int) EKeyConfigPad.Capture:
+ this.padCapture = value;
+ return;
+ }
+ throw new IndexOutOfRangeException();
+ }
+ }
+
+ #region [ private ]
+ //-----------------
+ private CConfigIni.CKeyAssign.STKEYASSIGN[] padBD_B;
+ private CConfigIni.CKeyAssign.STKEYASSIGN[] padCY_Decide;
+ private CConfigIni.CKeyAssign.STKEYASSIGN[] padFT_Cancel;
+ private CConfigIni.CKeyAssign.STKEYASSIGN[] padHH_R;
+ private CConfigIni.CKeyAssign.STKEYASSIGN[] padHHO;
+ private CConfigIni.CKeyAssign.STKEYASSIGN[] padHT_Pick;
+ private CConfigIni.CKeyAssign.STKEYASSIGN[] padLC;
+ private CConfigIni.CKeyAssign.STKEYASSIGN[] padLT_Wail;
+ private CConfigIni.CKeyAssign.STKEYASSIGN[] padRD;
+ private CConfigIni.CKeyAssign.STKEYASSIGN[] padSD_G;
+ private CConfigIni.CKeyAssign.STKEYASSIGN[] padLP;
+ private CConfigIni.CKeyAssign.STKEYASSIGN[] padLBD;
+ private CConfigIni.CKeyAssign.STKEYASSIGN[] padLRed;
+ private CConfigIni.CKeyAssign.STKEYASSIGN[] padLBlue;
+ private CConfigIni.CKeyAssign.STKEYASSIGN[] padRRed;
+ private CConfigIni.CKeyAssign.STKEYASSIGN[] padRBlue;
+ private CConfigIni.CKeyAssign.STKEYASSIGN[] padLRed2P;
+ private CConfigIni.CKeyAssign.STKEYASSIGN[] padLBlue2P;
+ private CConfigIni.CKeyAssign.STKEYASSIGN[] padRRed2P;
+ private CConfigIni.CKeyAssign.STKEYASSIGN[] padRBlue2P;
+
+ private CConfigIni.CKeyAssign.STKEYASSIGN[] padCapture;
+ //-----------------
+ #endregion
+ }
+
+ [StructLayout( LayoutKind.Sequential )]
+ public struct STKEYASSIGN
+ {
+ public E蜈･蜉帙ョ繝舌う繧ｹ 蜈･蜉帙ョ繝舌う繧ｹ;
+ public int ID;
+ public int 繧ｳ繝ｼ繝;
+ public STKEYASSIGN( E蜈･蜉帙ョ繝舌う繧ｹ DeviceType, int nID, int nCode )
+ {
+ this.蜈･蜉帙ョ繝舌う繧ｹ = DeviceType;
+ this.ID = nID;
+ this.繧ｳ繝ｼ繝 = nCode;
+ }
+ }
+
+ public CKeyAssignPad Bass = new CKeyAssignPad();
+ public CKeyAssignPad Drums = new CKeyAssignPad();
+ public CKeyAssignPad Guitar = new CKeyAssignPad();
+ public CKeyAssignPad Taiko = new CKeyAssignPad();
+ public CKeyAssignPad System = new CKeyAssignPad();
+ public CKeyAssignPad this[ int index ]
+ {
+ get
+ {
+ switch( index )
+ {
+ case (int) EKeyConfigPart.DRUMS:
+ return this.Drums;
+
+ case (int) EKeyConfigPart.GUITAR:
+ return this.Guitar;
+
+ case (int) EKeyConfigPart.BASS:
+ return this.Bass;
+
+ case (int) EKeyConfigPart.TAIKO:
+ return this.Taiko;
+
+ case (int) EKeyConfigPart.SYSTEM:
+ return this.System;
+ }
+ throw new IndexOutOfRangeException();
+ }
+ set
+ {
+ switch( index )
+ {
+ case (int) EKeyConfigPart.DRUMS:
+ this.Drums = value;
+ return;
+
+ case (int) EKeyConfigPart.GUITAR:
+ this.Guitar = value;
+ return;
+
+ case (int) EKeyConfigPart.BASS:
+ this.Bass = value;
+ return;
+
+ case (int) EKeyConfigPart.TAIKO:
+ this.Taiko = value;
+ return;
+
+ case (int) EKeyConfigPart.SYSTEM:
+ this.System = value;
+ return;
+ }
+ throw new IndexOutOfRangeException();
+ }
+ }
+ }
+ #endregion
+
+ //
+ public enum ESoundDeviceTypeForConfig
+ {
+ ACM = 0,
+ // DirectSound,
+ ASIO,
+ WASAPI,
+ Unknown=99
+ }
+ // 繝励Ο繝代ユ繧｣
+
+#if false // #23625 2011.1.11 Config.ini縺九ｉ繝繝｡繝ｼ繧ｸ/蝗槫ｾｩ蛟､縺ｮ螳壽焚螟画峩繧定｡後≧蝣ｴ蜷医ｯ縺薙％繧呈怏蜉ｹ縺ｫ縺吶ｋ 087繝ｪ繝ｪ繝ｼ繧ｹ縺ｫ蜷医ｏ縺帶ｩ溯ｽ辟｡蜉ｹ蛹
+ //----------------------------------------
+ public float[,] fGaugeFactor = new float[5,2];
+ public float[] fDamageLevelFactor = new float[3];
+ //----------------------------------------
+#endif
+ public int nBGAlpha;
+ public bool bAVI譛牙柑;
+ public bool bBGA譛牙柑;
+ public bool bBGM髻ｳ繧堤匱螢ｰ縺吶ｋ;
+ public STDGBVALUE bHidden;
+ public STDGBVALUE bLeft;
+ public STDGBVALUE bLight;
+ public bool bLogDTX隧ｳ邏ｰ繝ｭ繧ｰ蜃ｺ蜉;
+ public bool bLog譖ｲ讀懃ｴ｢繝ｭ繧ｰ蜃ｺ蜉;
+ public bool bLog菴懈占ｧ｣謾ｾ繝ｭ繧ｰ蜃ｺ蜉;
+ public STDGBVALUE bReverse;
+
+ public E蛻､螳夊｡ｨ遉ｺ蜆ｪ蜈亥ｺｦ e蛻､螳夊｡ｨ遉ｺ蜆ｪ蜈亥ｺｦ;
+ public STDGBVALUE e蛻､螳壻ｽ咲ｽｮ; // #33891 2014.6.26 yyagi
+ public bool bScoreIni繧貞ｺ蜉帙☆繧;
+ public bool bSTAGEFAILED譛牙柑;
+ public STDGBVALUE bSudden;
+ public bool bTight;
+ public STDGBVALUE bGraph; // #24074 2011.01.23 add ikanick
+ public bool bWave蜀咲函菴咲ｽｮ閾ｪ蜍戊ｪｿ謨ｴ讖溯ｽ譛牙柑;
+ public bool b繧ｹ繝医う繝繧ｯ繝｢繝ｼ繝;
+ public bool b繝ｩ繝ｳ繝繝繧ｻ繝ｬ繧ｯ繝医〒蟄殖OX繧呈､懃ｴ｢蟇ｾ雎｡縺ｨ縺吶ｋ;
+ public bool b繝ｭ繧ｰ蜃ｺ蜉;
+ public bool b貍泌･乗ュ蝣ｱ繧定｡ｨ遉ｺ縺吶ｋ;
+ public bool b蝙ら峩蟶ｰ邱壼ｾ縺｡繧定｡後≧;
+ public bool b蜈ｨ逕ｻ髱｢繝｢繝ｼ繝;
+ public int n蛻晄悄繧ｦ繧｣繝ｳ繝峨え髢句ｧ倶ｽ咲ｽｮX; // #30675 2013.02.04 ikanick add
+ public int n蛻晄悄繧ｦ繧｣繝ｳ繝峨え髢句ｧ倶ｽ咲ｽｮY;
+ public int n繧ｦ繧､繝ｳ繝峨えwidth; // #23510 2010.10.31 yyagi add
+ public int n繧ｦ繧､繝ｳ繝峨えheight; // #23510 2010.10.31 yyagi add
+ public Dictionary dicJoystick;
+ public E繝繝ｼ繧ｯ繝｢繝ｼ繝 eDark;
+ public STDGBVALUE eRandom;
+ public E繝繝｡繝ｼ繧ｸ繝ｬ繝吶Ν e繝繝｡繝ｼ繧ｸ繝ｬ繝吶Ν;
+ public CKeyAssign KeyAssign;
+ public int n髱槭ヵ繧ｩ繝ｼ繧ｫ繧ｹ譎ゅせ繝ｪ繝ｼ繝洋s; // #23568 2010.11.04 ikanick add
+ public int n繝輔Ξ繝ｼ繝豈弱せ繝ｪ繝ｼ繝洋s; // #xxxxx 2011.11.27 yyagi add
+ public int n貍泌･城溷ｺｦ;
+ public bool b貍泌･城溷ｺｦ縺御ｸ蛟埼溘〒縺ゅｋ縺ｨ縺堺ｻ･螟夜浹螢ｰ繧貞咲函縺励↑縺;
+ public int n譖ｲ縺碁∈謚槭＆繧後※縺九ｉ繝励Ξ繝薙Η繝ｼ髻ｳ縺碁ｳｴ繧九∪縺ｧ縺ｮ繧ｦ繧ｧ繧､繝ms;
+ public int n譖ｲ縺碁∈謚槭＆繧後※縺九ｉ繝励Ξ繝薙Η繝ｼ逕ｻ蜒上′陦ｨ遉ｺ髢句ｧ九＆繧後ｋ縺ｾ縺ｧ縺ｮ繧ｦ繧ｧ繧､繝ms;
+
+ private bool _applyLoudnessMetadata;
+
+ public bool ApplyLoudnessMetadata
+ {
+ get => _applyLoudnessMetadata;
+ set => SetProperty(ref _applyLoudnessMetadata, value, nameof(ApplyLoudnessMetadata));
+ }
+
+ private double _targetLoudness;
+
+ public double TargetLoudness
+ {
+ get => _targetLoudness;
+ set => SetProperty(ref _targetLoudness, value, nameof(TargetLoudness));
+ }
+
+ private bool _applySongVol;
+
+ public bool ApplySongVol
+ {
+ get => _applySongVol;
+ set => SetProperty(ref _applySongVol, value, nameof(ApplySongVol));
+ }
+
+ private int _soundEffectLevel;
+
+ public int SoundEffectLevel
+ {
+ get => _soundEffectLevel;
+ set => SetProperty(ref _soundEffectLevel, value, nameof(SoundEffectLevel));
+ }
+
+ private int _voiceLevel;
+
+ public int VoiceLevel
+ {
+ get => _voiceLevel;
+ set => SetProperty(ref _voiceLevel, value, nameof(VoiceLevel));
+ }
+
+ private int _songPreviewLevel;
+
+ public int SongPreviewLevel
+ {
+ get => _songPreviewLevel;
+ set => SetProperty(ref _songPreviewLevel, value, nameof(SongPlaybackLevel));
+ }
+
+ private int _songPlaybackLevel;
+
+ public int SongPlaybackLevel
+ {
+ get => _songPlaybackLevel;
+ set => SetProperty(ref _songPlaybackLevel, value, nameof(SongPlaybackLevel));
+ }
+
+ private int _keyboardSoundLevelIncrement;
+
+ public int KeyboardSoundLevelIncrement
+ {
+ get => _keyboardSoundLevelIncrement;
+ set => SetProperty(
+ ref _keyboardSoundLevelIncrement,
+ value.Clamp(MinimumKeyboardSoundLevelIncrement, MaximumKeyboardSoundLevelIncrement),
+ nameof(KeyboardSoundLevelIncrement));
+ }
+
+ public STDGBVALUE n陦ｨ遉ｺ蜿ｯ閭ｽ縺ｪ譛蟆上さ繝ｳ繝懈焚;
+ public STDGBVALUE n隴憺擇繧ｹ繧ｯ繝ｭ繝ｼ繝ｫ騾溷ｺｦ;
+ public string strDTXMania縺ｮ繝舌ｼ繧ｸ繝ｧ繝ｳ;
+ public string str譖ｲ繝繝ｼ繧ｿ讀懃ｴ｢繝代せ;
+ public string FontName;
+ public string BoxFontName;
+ public bool bBranchGuide;
+ public int nScoreMode;
+ public int nDefaultCourse; //2017.01.30 DD 繝繝輔か繝ｫ繝医〒繧ｫ繝ｼ繧ｽ繝ｫ繧偵≠繧上○繧矩屮譏灘ｺｦ
+
+
+ public int nPlayerCount; //2017.08.18 kairera0467 繝槭Ν繝√励Ξ繧､蟇ｾ蠢
+ public bool b螟ｪ鮠薙ヱ繝ｼ繝AutoPlay;
+ public bool b螟ｪ鮠薙ヱ繝ｼ繝AutoPlay2P; //2017.08.16 kairera0467 繝槭Ν繝√励Ξ繧､蟇ｾ蠢
+ public bool bAuto蜈育函縺ｮ騾｣謇;
+ public bool b螟ｧ髻ｳ隨ｦ蛻､螳;
+ public int n荳｡謇句愛螳壹ｮ蠕縺｡譎る俣;
+ public int nBranchAnime;
+
+ public bool bJudgeCountDisplay;
+
+ public bool bEnableCountdownTimer;
+
+ // 蜷逕ｻ蜒上ｮ陦ｨ遉ｺ繝ｻ髱櫁｡ｨ遉ｺ險ｭ螳
+ public bool ShowChara;
+ public bool ShowDancer;
+ public bool ShowRunner;
+ public bool ShowFooter;
+ public bool ShowMob;
+ public bool ShowPuchiChara; // 繝ｪ繧ｶ繝ｼ繝
+ //
+
+ public EScrollMode eScrollMode = EScrollMode.Normal;
+ public bool b繧ｹ繧ｯ繝ｭ繝ｼ繝ｫ繝｢繝ｼ繝峨ｒ荳頑嶌縺 = false;
+
+ public bool bHispeedRandom;
+ public E繧ｹ繝繝ｫ繧ｹ繝｢繝ｼ繝 eSTEALTH;
+ public bool bNoInfo;
+
+ public int nDefaultSongSort;
+
+ public EGame eGameMode;
+ public int TokkunSkipMeasures;
+ public int TokkunMashInterval;
+ public bool bSuperHard = false;
+ public bool bTokkunMode = false;
+ public bool bJust;
+
+ public bool bEndingAnime = false; // 2017.01.27 DD 縲後∪縺滄♀繧薙〒縺ｭ縲咲判髱｢縺ｮ譛牙柑/辟｡蜉ｹ繧ｪ繝励す繝ｧ繝ｳ霑ｽ蜉
+
+
+ public STDGBVALUE 蛻､螳壽枚蟄苓｡ｨ遉ｺ菴咲ｽｮ;
+// public int n繝上う繝上ャ繝亥繧頑昏縺ｦ荳矩剞Velocity;
+// public int n蛻繧頑昏縺ｦ荳矩剞Velocity; // #23857 2010.12.12 yyagi VelocityMin
+ public int nInputAdjustTimeMs;
+ public STDGBVALUE nJudgeLinePosOffset; // #31602 2013.6.23 yyagi 蛻､螳壹Λ繧､繝ｳ陦ｨ遉ｺ菴咲ｽｮ縺ｮ繧ｪ繝輔そ繝繝
+ public bool bIsAutoResultCapture; // #25399 2011.6.9 yyagi 繝ｪ繧ｶ繝ｫ繝育判蜒剰ｪ蜍穂ｿ晏ｭ俶ｩ溯ｽ縺ｮON/OFF蛻ｶ蠕｡
+ public int nPoliphonicSounds; // #28228 2012.5.1 yyagi 繝ｬ繝ｼ繝ｳ豈弱ｮ譛螟ｧ蜷梧凾逋ｺ髻ｳ謨ｰ
+ public bool b繝舌ャ繝輔ぃ蜈･蜉帙ｒ陦後≧;
+ public bool bIsEnabledSystemMenu; // #28200 2012.5.1 yyagi System Menu縺ｮ菴ｿ逕ｨ蜿ｯ蜷ｦ蛻譖ｿ
+ public string strSystemSkinSubfolderFullName; // #28195 2012.5.2 yyagi Skin蛻譖ｿ逕ｨ System/莉･荳九ｮ繧ｵ繝悶ヵ繧ｩ繝ｫ繝蜷
+ public bool bConfigIni縺後↑縺縺汽TXMania縺ｮ繝舌ｼ繧ｸ繝ｧ繝ｳ縺檎焚縺ｪ繧
+ {
+ get
+ {
+ return ( !this.bConfigIni縺悟ｭ伜惠縺励※縺繧 || !TJAPlayer3.VERSION.Equals( this.strDTXMania縺ｮ繝舌ｼ繧ｸ繝ｧ繝ｳ ) );
+ }
+ }
+ public bool bEnter縺後く繝ｼ蜑ｲ繧雁ｽ薙※縺ｮ縺ｩ縺薙↓繧ゆｽｿ逕ｨ縺輔ｌ縺ｦ縺縺ｪ縺
+ {
+ get
+ {
+ for( int i = 0; i <= (int)EKeyConfigPart.SYSTEM; i++ )
+ {
+ for( int j = 0; j <= (int)EKeyConfigPad.Capture; j++ )
+ {
+ for( int k = 0; k < 0x10; k++ )
+ {
+ if( ( this.KeyAssign[ i ][ j ][ k ].蜈･蜉帙ョ繝舌う繧ｹ == E蜈･蜉帙ョ繝舌う繧ｹ.繧ｭ繝ｼ繝懊ｼ繝 ) && ( this.KeyAssign[ i ][ j ][ k ].繧ｳ繝ｼ繝 == (int)SlimDXKeys.Key.Return ) )
+ {
+ return false;
+ }
+ }
+ }
+ }
+ return true;
+ }
+ }
+ public bool b繧ｦ繧｣繝ｳ繝峨え繝｢繝ｼ繝
+ {
+ get
+ {
+ return !this.b蜈ｨ逕ｻ髱｢繝｢繝ｼ繝;
+ }
+ set
+ {
+ this.b蜈ｨ逕ｻ髱｢繝｢繝ｼ繝 = !value;
+ }
+ }
+ public bool b貍泌･乗ュ蝣ｱ繧定｡ｨ遉ｺ縺励↑縺
+ {
+ get
+ {
+ return !this.b貍泌･乗ュ蝣ｱ繧定｡ｨ遉ｺ縺吶ｋ;
+ }
+ set
+ {
+ this.b貍泌･乗ュ蝣ｱ繧定｡ｨ遉ｺ縺吶ｋ = !value;
+ }
+ }
+ public int n閭梧勹縺ｮ騾城℃蠎ｦ
+ {
+ get
+ {
+ return this.nBGAlpha;
+ }
+ set
+ {
+ if( value < 0 )
+ {
+ this.nBGAlpha = 0;
+ }
+ else if( value > 0xff )
+ {
+ this.nBGAlpha = 0xff;
+ }
+ else
+ {
+ this.nBGAlpha = value;
+ }
+ }
+ }
+ public int nRisky; // #23559 2011.6.20 yyagi Risky縺ｧ縺ｮ谿九Α繧ｹ謨ｰ縲0縺ｧ髢牙ｺ
+ public bool bIsAllowedDoubleClickFullscreen; // #26752 2011.11.27 yyagi 繝繝悶Ν繧ｯ繝ｪ繝繧ｯ縺励※繧ゅヵ繝ｫ繧ｹ繧ｯ繝ｪ繝ｼ繝ｳ縺ｫ遘ｻ陦後＠縺ｪ縺
+ public STAUTOPLAY bAutoPlay;
+ public int nSoundDeviceType; // #24820 2012.12.23 yyagi 蜃ｺ蜉帙し繧ｦ繝ｳ繝峨ョ繝舌う繧ｹ(0=ACM(縺ｫ縺励◆縺縺瑚ｨｭ險医′縺阪▽縺昴≧縺ｪ繧吋irectShow), 1=ASIO, 2=WASAPI)
+ public int nWASAPIBufferSizeMs; // #24820 2013.1.15 yyagi WASAPI縺ｮ繝舌ャ繝輔ぃ繧ｵ繧､繧ｺ
+// public int nASIOBufferSizeMs; // #24820 2012.12.28 yyagi ASIO縺ｮ繝舌ャ繝輔ぃ繧ｵ繧､繧ｺ
+ public int nASIODevice; // #24820 2013.1.17 yyagi ASIO繝繝舌う繧ｹ
+ public bool bUseOSTimer; // #33689 2014.6.6 yyagi 貍泌･上ち繧､繝槭ｼ縺ｮ遞ｮ鬘
+ public bool bDynamicBassMixerManagement; // #24820
+ public bool bTimeStretch; // #23664 2013.2.24 yyagi 繝斐ャ繝∝､画峩辟｡縺励〒蜀咲函騾溷ｺｦ繧貞､画峩縺吶ｋ縺九←縺縺
+ public STDGBVALUE eInvisible; // #32072 2013.9.20 yyagi 繝√ャ繝励ｒ髱櫁｡ｨ遉ｺ縺ｫ縺吶ｋ
+ public int nDisplayTimesMs, nFadeoutTimeMs;
+
+ public STDGBVALUE nViewerScrollSpeed;
+ public bool bViewerVSyncWait;
+ public bool bViewerShowDebugStatus;
+ public bool bViewerTimeStretch;
+ public bool bViewerDrums譛牙柑, bViewerGuitar譛牙柑;
+ //public bool bNoMP3Streaming; // 2014.4.14 yyagi; mp3縺ｮ繧ｷ繝ｼ繧ｯ菴咲ｽｮ縺後♀縺九＠縺上↑繧句ｴ蜷医ｯ縲√％繧後ｒtrue縺ｫ縺吶ｋ縺薙→縺ｧ縲『av縺ｫ繝繧ｳ繝ｼ繝峨＠縺ｦ縺九ｉ繧ｪ繝ｳ繝｡繝｢繝ｪ蜀咲函縺吶ｋ
+ public int nMasterVolume;
+ public bool ShinuchiMode; // 逵滓遠繝｢繝ｼ繝
+ public bool FastRender; // 莠句燕逕ｻ蜒乗緒逕ｻ繝｢繝ｼ繝
+ public int MusicPreTimeMs; // 髻ｳ貅仙咲函蜑阪ｮ蠕讖滓凾髢杜s
+ ///
+ /// Discord縺ｮRitch Presence縺ｫ蜀咲函荳ｭ縺ｮ.tja繝輔ぃ繧､繝ｫ縺ｮ諠蝣ｱ繧帝∽ｿ｡縺吶ｋ縺九←縺縺九
+ ///
+ public bool SendDiscordPlayingInformation;
+#if false
+ [StructLayout( LayoutKind.Sequential )]
+ public struct STAUTOPLAY // C螳壽焚縺ｮE繝ｬ繝ｼ繝ｳ縺ｨindex繧剃ｸ閾ｴ縺輔○繧九％縺ｨ
+ {
+ public bool LC; // 0
+ public bool HH; // 1
+ public bool SD; // 2
+ public bool BD; // 3
+ public bool HT; // 4
+ public bool LT; // 5
+ public bool FT; // 6
+ public bool CY; // 7
+ public bool RD; // 8
+ public bool Guitar; // 9 (not used)
+ public bool Bass; // 10 (not used)
+ public bool GtR; // 11
+ public bool GtG; // 12
+ public bool GtB; // 13
+ public bool GtPick; // 14
+ public bool GtW; // 15
+ public bool BsR; // 16
+ public bool BsG; // 17
+ public bool BsB; // 18
+ public bool BsPick; // 19
+ public bool BsW; // 20
+ public bool this[ int index ]
+ {
+ get
+ {
+ switch ( index )
+ {
+ case (int) E繝ｬ繝ｼ繝ｳ.LC:
+ return this.LC;
+ case (int) E繝ｬ繝ｼ繝ｳ.HH:
+ return this.HH;
+ case (int) E繝ｬ繝ｼ繝ｳ.SD:
+ return this.SD;
+ case (int) E繝ｬ繝ｼ繝ｳ.BD:
+ return this.BD;
+ case (int) E繝ｬ繝ｼ繝ｳ.HT:
+ return this.HT;
+ case (int) E繝ｬ繝ｼ繝ｳ.LT:
+ return this.LT;
+ case (int) E繝ｬ繝ｼ繝ｳ.FT:
+ return this.FT;
+ case (int) E繝ｬ繝ｼ繝ｳ.CY:
+ return this.CY;
+ case (int) E繝ｬ繝ｼ繝ｳ.RD:
+ return this.RD;
+ case (int) E繝ｬ繝ｼ繝ｳ.Guitar:
+ return this.Guitar;
+ case (int) E繝ｬ繝ｼ繝ｳ.Bass:
+ return this.Bass;
+ case (int) E繝ｬ繝ｼ繝ｳ.GtR:
+ return this.GtR;
+ case (int) E繝ｬ繝ｼ繝ｳ.GtG:
+ return this.GtG;
+ case (int) E繝ｬ繝ｼ繝ｳ.GtB:
+ return this.GtB;
+ case (int) E繝ｬ繝ｼ繝ｳ.GtPick:
+ return this.GtPick;
+ case (int) E繝ｬ繝ｼ繝ｳ.GtW:
+ return this.GtW;
+ case (int) E繝ｬ繝ｼ繝ｳ.BsR:
+ return this.BsR;
+ case (int) E繝ｬ繝ｼ繝ｳ.BsG:
+ return this.BsG;
+ case (int) E繝ｬ繝ｼ繝ｳ.BsB:
+ return this.BsB;
+ case (int) E繝ｬ繝ｼ繝ｳ.BsPick:
+ return this.BsPick;
+ case (int) E繝ｬ繝ｼ繝ｳ.BsW:
+ return this.BsW;
+ }
+ throw new IndexOutOfRangeException();
+ }
+ set
+ {
+ switch ( index )
+ {
+ case (int) E繝ｬ繝ｼ繝ｳ.LC:
+ this.LC = value;
+ return;
+ case (int) E繝ｬ繝ｼ繝ｳ.HH:
+ this.HH = value;
+ return;
+ case (int) E繝ｬ繝ｼ繝ｳ.SD:
+ this.SD = value;
+ return;
+ case (int) E繝ｬ繝ｼ繝ｳ.BD:
+ this.BD = value;
+ return;
+ case (int) E繝ｬ繝ｼ繝ｳ.HT:
+ this.HT = value;
+ return;
+ case (int) E繝ｬ繝ｼ繝ｳ.LT:
+ this.LT = value;
+ return;
+ case (int) E繝ｬ繝ｼ繝ｳ.FT:
+ this.FT = value;
+ return;
+ case (int) E繝ｬ繝ｼ繝ｳ.CY:
+ this.CY = value;
+ return;
+ case (int) E繝ｬ繝ｼ繝ｳ.RD:
+ this.RD = value;
+ return;
+ case (int) E繝ｬ繝ｼ繝ｳ.Guitar:
+ this.Guitar = value;
+ return;
+ case (int) E繝ｬ繝ｼ繝ｳ.Bass:
+ this.Bass = value;
+ return;
+ case (int) E繝ｬ繝ｼ繝ｳ.GtR:
+ this.GtR = value;
+ return;
+ case (int) E繝ｬ繝ｼ繝ｳ.GtG:
+ this.GtG = value;
+ return;
+ case (int) E繝ｬ繝ｼ繝ｳ.GtB:
+ this.GtB = value;
+ return;
+ case (int) E繝ｬ繝ｼ繝ｳ.GtPick:
+ this.GtPick = value;
+ return;
+ case (int) E繝ｬ繝ｼ繝ｳ.GtW:
+ this.GtW = value;
+ return;
+ case (int) E繝ｬ繝ｼ繝ｳ.BsR:
+ this.BsR = value;
+ return;
+ case (int) E繝ｬ繝ｼ繝ｳ.BsG:
+ this.BsG = value;
+ return;
+ case (int) E繝ｬ繝ｼ繝ｳ.BsB:
+ this.BsB = value;
+ return;
+ case (int) E繝ｬ繝ｼ繝ｳ.BsPick:
+ this.BsPick = value;
+ return;
+ case (int) E繝ｬ繝ｼ繝ｳ.BsW:
+ this.BsW = value;
+ return;
+ }
+ throw new IndexOutOfRangeException();
+ }
+ }
+ }
+#endif
+ #region [ STRANGE ]
+ public STRANGE n繝偵ャ繝育ｯ蝗ｲms;
+ [StructLayout( LayoutKind.Sequential )]
+ public struct STRANGE
+ {
+ public int Perfect;
+ public int Great;
+ public int Good;
+ public int Poor;
+ public int this[ int index ]
+ {
+ get
+ {
+ switch( index )
+ {
+ case 0:
+ return this.Perfect;
+
+ case 1:
+ return this.Great;
+
+ case 2:
+ return this.Good;
+
+ case 3:
+ return this.Poor;
+ }
+ throw new IndexOutOfRangeException();
+ }
+ set
+ {
+ switch( index )
+ {
+ case 0:
+ this.Perfect = value;
+ return;
+
+ case 1:
+ this.Great = value;
+ return;
+
+ case 2:
+ this.Good = value;
+ return;
+
+ case 3:
+ this.Poor = value;
+ return;
+ }
+ throw new IndexOutOfRangeException();
+ }
+ }
+ }
+ #endregion
+ #region [ STLANEVALUE ]
+ public STLANEVALUE nVelocityMin;
+ [StructLayout( LayoutKind.Sequential )]
+ public struct STLANEVALUE
+ {
+ public int LC;
+ public int HH;
+ public int SD;
+ public int BD;
+ public int HT;
+ public int LT;
+ public int FT;
+ public int CY;
+ public int RD;
+ public int LP;
+ public int LBD;
+ public int Guitar;
+ public int Bass;
+ public int this[ int index ]
+ {
+ get
+ {
+ switch( index )
+ {
+ case 0:
+ return this.LC;
+
+ case 1:
+ return this.HH;
+
+ case 2:
+ return this.SD;
+
+ case 3:
+ return this.BD;
+
+ case 4:
+ return this.HT;
+
+ case 5:
+ return this.LT;
+
+ case 6:
+ return this.FT;
+
+ case 7:
+ return this.CY;
+
+ case 8:
+ return this.RD;
+
+ case 9:
+ return this.LP;
+
+ case 10:
+ return this.LBD;
+
+ case 11:
+ return this.Guitar;
+
+ case 12:
+ return this.Bass;
+ }
+ throw new IndexOutOfRangeException();
+ }
+ set
+ {
+ switch( index )
+ {
+ case 0:
+ this.LC = value;
+ return;
+
+ case 1:
+ this.HH = value;
+ return;
+
+ case 2:
+ this.SD = value;
+ return;
+
+ case 3:
+ this.BD = value;
+ return;
+
+ case 4:
+ this.HT = value;
+ return;
+
+ case 5:
+ this.LT = value;
+ return;
+
+ case 6:
+ this.FT = value;
+ return;
+
+ case 7:
+ this.CY = value;
+ return;
+
+ case 8:
+ this.RD = value;
+ return;
+
+ case 9:
+ this.LP = value;
+ return;
+
+ case 10:
+ this.LBD = value;
+ return;
+
+ case 11:
+ this.Guitar = value;
+ return;
+
+ case 12:
+ this.Bass = value;
+ return;
+ }
+ throw new IndexOutOfRangeException();
+ }
+ }
+ }
+ #endregion
+
+
+ #region[Ver.K霑ｽ蜉繧ｪ繝励す繝ｧ繝ｳ]
+ //--------------------------
+ //繧ｲ繝ｼ繝蜀縺ｮ繧ｪ繝励す繝ｧ繝ｳ縺ｫ蜉縺医※縲
+ //繧ｷ繧ｹ繝繝蜻ｨ繧翫ｮ繧ｪ繝励す繝ｧ繝ｳ繧ゅ％縺ｮ繝悶Ο繝繧ｯ縺ｧ險倩ｿｰ縺励※縺繧九
+ #region[Display]
+ //--------------------------
+ public EClipDispType eClipDispType;
+ #endregion
+
+ #region[Position]
+ public E繝ｬ繝ｼ繝ｳ繧ｿ繧､繝 eLaneType;
+ public E繝溘Λ繝ｼ eMirror;
+
+ #endregion
+ #region[System]
+ public bool bDirectShowMode;
+ #endregion
+
+ //--------------------------
+ #endregion
+
+
+ // 繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ
+
+ public CConfigIni()
+ {
+#if false // #23625 2011.1.11 Config.ini縺九ｉ繝繝｡繝ｼ繧ｸ/蝗槫ｾｩ蛟､縺ｮ螳壽焚螟画峩繧定｡後≧蝣ｴ蜷医ｯ縺薙％繧呈怏蜉ｹ縺ｫ縺吶ｋ 087繝ｪ繝ｪ繝ｼ繧ｹ縺ｫ蜷医ｏ縺帶ｩ溯ｽ辟｡蜉ｹ蛹
+ //----------------------------------------
+ this.fGaugeFactor[0,0] = 0.004f;
+ this.fGaugeFactor[0,1] = 0.006f;
+ this.fGaugeFactor[1,0] = 0.002f;
+ this.fGaugeFactor[1,1] = 0.003f;
+ this.fGaugeFactor[2,0] = 0.000f;
+ this.fGaugeFactor[2,1] = 0.000f;
+ this.fGaugeFactor[3,0] = -0.020f;
+ this.fGaugeFactor[3,1] = -0.030f;
+ this.fGaugeFactor[4,0] = -0.050f;
+ this.fGaugeFactor[4,1] = -0.050f;
+
+ this.fDamageLevelFactor[0] = 0.5f;
+ this.fDamageLevelFactor[1] = 1.0f;
+ this.fDamageLevelFactor[2] = 1.5f;
+ //----------------------------------------
+#endif
+ this.strDTXMania縺ｮ繝舌ｼ繧ｸ繝ｧ繝ｳ = "Unknown";
+ this.str譖ｲ繝繝ｼ繧ｿ讀懃ｴ｢繝代せ = @".\";
+ this.b蜈ｨ逕ｻ髱｢繝｢繝ｼ繝 = false;
+ this.b蝙ら峩蟶ｰ邱壼ｾ縺｡繧定｡後≧ = true;
+ this.n蛻晄悄繧ｦ繧｣繝ｳ繝峨え髢句ｧ倶ｽ咲ｽｮX = 0; // #30675 2013.02.04 ikanick add
+ this.n蛻晄悄繧ｦ繧｣繝ｳ繝峨え髢句ｧ倶ｽ咲ｽｮY = 0;
+ this.n繧ｦ繧､繝ｳ繝峨えwidth = SampleFramework.GameWindowSize.Width; // #23510 2010.10.31 yyagi add
+ this.n繧ｦ繧､繝ｳ繝峨えheight = SampleFramework.GameWindowSize.Height; //
+ this.n繝輔Ξ繝ｼ繝豈弱せ繝ｪ繝ｼ繝洋s = -1; // #xxxxx 2011.11.27 yyagi add
+ this.n髱槭ヵ繧ｩ繝ｼ繧ｫ繧ｹ譎ゅせ繝ｪ繝ｼ繝洋s = 1; // #23568 2010.11.04 ikanick add
+ this._bGuitar譛牙柑 = true;
+ this._bDrums譛牙柑 = true;
+ this.nBGAlpha = 100;
+ this.e繝繝｡繝ｼ繧ｸ繝ｬ繝吶Ν = E繝繝｡繝ｼ繧ｸ繝ｬ繝吶Ν.譎ｮ騾;
+ this.bSTAGEFAILED譛牙柑 = true;
+ this.bAVI譛牙柑 = false;
+ this.bBGA譛牙柑 = true;
+ this.n譖ｲ縺碁∈謚槭＆繧後※縺九ｉ繝励Ξ繝薙Η繝ｼ髻ｳ縺碁ｳｴ繧九∪縺ｧ縺ｮ繧ｦ繧ｧ繧､繝ms = 1000;
+ this.n譖ｲ縺碁∈謚槭＆繧後※縺九ｉ繝励Ξ繝薙Η繝ｼ逕ｻ蜒上′陦ｨ遉ｺ髢句ｧ九＆繧後ｋ縺ｾ縺ｧ縺ｮ繧ｦ繧ｧ繧､繝ms = 100;
+ //this.bWave蜀咲函菴咲ｽｮ閾ｪ蜍戊ｪｿ謨ｴ讖溯ｽ譛牙柑 = true;
+ this.bWave蜀咲函菴咲ｽｮ閾ｪ蜍戊ｪｿ謨ｴ讖溯ｽ譛牙柑 = false;
+ this.bBGM髻ｳ繧堤匱螢ｰ縺吶ｋ = true;
+ this.bScoreIni繧貞ｺ蜉帙☆繧 = true;
+ this.b繝ｩ繝ｳ繝繝繧ｻ繝ｬ繧ｯ繝医〒蟄殖OX繧呈､懃ｴ｢蟇ｾ雎｡縺ｨ縺吶ｋ = true;
+ this.n陦ｨ遉ｺ蜿ｯ閭ｽ縺ｪ譛蟆上さ繝ｳ繝懈焚 = new STDGBVALUE();
+ this.n陦ｨ遉ｺ蜿ｯ閭ｽ縺ｪ譛蟆上さ繝ｳ繝懈焚.Drums = 10;
+ this.n陦ｨ遉ｺ蜿ｯ閭ｽ縺ｪ譛蟆上さ繝ｳ繝懈焚.Guitar = 10;
+ this.n陦ｨ遉ｺ蜿ｯ閭ｽ縺ｪ譛蟆上さ繝ｳ繝懈焚.Bass = 10;
+ this.n陦ｨ遉ｺ蜿ｯ閭ｽ縺ｪ譛蟆上さ繝ｳ繝懈焚.Taiko = 10;
+ this.FontName = "MS UI Gothic";
+ this.BoxFontName = "MS UI Gothic";
+ this.ApplyLoudnessMetadata = true;
+ this.bEnableCountdownTimer = true;
+
+ // 2018-08-28 twopointzero:
+ // There exists a particular large, well-known, well-curated, and
+ // regularly-updated collection of content for use with Taiko no
+ // Tatsujin simulators. A statistical analysis was performed on the
+ // the integrated loudness and true peak loudness of the thousands
+ // of songs within this collection as of late August 2018.
+ //
+ // The analysis allows us to select a target loudness which
+ // results in the smallest total amount of loudness adjustment
+ // applied to the songs of that collection. The selected target
+ // loudness should result in the least-noticeable average
+ // adjustment for the most users, assuming their collection is
+ // similar to the exemplar.
+ //
+ // The target loudness which achieves this is -7.4 LUFS.
+ this.TargetLoudness = -7.4;
+
+ this.ApplySongVol = false;
+ this.SoundEffectLevel = CSound.DefaultSoundEffectLevel;
+ this.VoiceLevel = CSound.DefaultVoiceLevel;
+ this.SongPreviewLevel = CSound.DefaultSongPlaybackLevel;
+ this.SongPlaybackLevel = CSound.DefaultSongPlaybackLevel;
+ this.KeyboardSoundLevelIncrement = DefaultKeyboardSoundLevelIncrement;
+ this.b繝ｭ繧ｰ蜃ｺ蜉 = true;
+ this.bSudden = new STDGBVALUE();
+ this.bHidden = new STDGBVALUE();
+ this.bReverse = new STDGBVALUE();
+ this.eRandom = new STDGBVALUE();
+ this.bLight = new STDGBVALUE();
+ this.bLeft = new STDGBVALUE();
+ this.e蛻､螳壻ｽ咲ｽｮ = new STDGBVALUE(); // #33891 2014.6.26 yyagi
+ this.蛻､螳壽枚蟄苓｡ｨ遉ｺ菴咲ｽｮ = new STDGBVALUE();
+ this.n隴憺擇繧ｹ繧ｯ繝ｭ繝ｼ繝ｫ騾溷ｺｦ = new STDGBVALUE();
+ this.nInputAdjustTimeMs = 0;
+ this.nJudgeLinePosOffset = new STDGBVALUE(); // #31602 2013.6.23 yyagi
+ this.e蛻､螳夊｡ｨ遉ｺ蜆ｪ蜈亥ｺｦ = E蛻､螳夊｡ｨ遉ｺ蜆ｪ蜈亥ｺｦ.Chip繧医ｊ荳;
+ for ( int i = 0; i < 3; i++ )
+ {
+ this.bSudden[ i ] = false;
+ this.bHidden[ i ] = false;
+ this.bReverse[ i ] = false;
+ this.eRandom[ i ] = E繝ｩ繝ｳ繝繝繝｢繝ｼ繝.OFF;
+ this.bLight[ i ] = false;
+ this.bLeft[ i ] = false;
+ this.蛻､螳壽枚蟄苓｡ｨ遉ｺ菴咲ｽｮ[ i ] = E蛻､螳壽枚蟄苓｡ｨ遉ｺ菴咲ｽｮ.繝ｬ繝ｼ繝ｳ荳;
+ this.n隴憺擇繧ｹ繧ｯ繝ｭ繝ｼ繝ｫ騾溷ｺｦ[ i ] = 9;
+ this.nJudgeLinePosOffset[ i ] = 0;
+ this.eInvisible[ i ] = EInvisible.OFF;
+ this.nViewerScrollSpeed[ i ] = 1;
+ this.e蛻､螳壻ｽ咲ｽｮ[ i ] = E蛻､螳壻ｽ咲ｽｮ.讓呎ｺ;
+ //this.e蛻､螳夊｡ｨ遉ｺ蜆ｪ蜈亥ｺｦ[ i ] = E蛻､螳夊｡ｨ遉ｺ蜆ｪ蜈亥ｺｦ.Chip繧医ｊ荳;
+ }
+ this.n貍泌･城溷ｺｦ = 20;
+ this.b貍泌･城溷ｺｦ縺御ｸ蛟埼溘〒縺ゅｋ縺ｨ縺堺ｻ･螟夜浹螢ｰ繧貞咲函縺励↑縺 = false;
+ #region [ AutoPlay ]
+ this.bAutoPlay = new STAUTOPLAY();
+
+ this.b螟ｪ鮠薙ヱ繝ｼ繝AutoPlay = true;
+ this.b螟ｪ鮠薙ヱ繝ｼ繝AutoPlay2P = true;
+ this.bAuto蜈育函縺ｮ騾｣謇 = true;
+ #endregion
+ this.n繝偵ャ繝育ｯ蝗ｲms = new STRANGE();
+ this.n繝偵ャ繝育ｯ蝗ｲms.Perfect = 30;
+ this.n繝偵ャ繝育ｯ蝗ｲms.Great = -1; //菴ｿ逕ｨ縺励∪縺帙ｓ縲
+ this.n繝偵ャ繝育ｯ蝗ｲms.Good = 100;
+ this.n繝偵ャ繝育ｯ蝗ｲms.Poor = 130;
+ this.ConfigIni繝輔ぃ繧､繝ｫ蜷 = "";
+ this.dicJoystick = new Dictionary( 10 );
+ this.t繝繝輔か繝ｫ繝医ｮ繧ｭ繝ｼ繧｢繧ｵ繧､繝ｳ縺ｫ險ｭ螳壹☆繧();
+ #region [ velocityMin ]
+ this.nVelocityMin.LC = 0; // #23857 2011.1.31 yyagi VelocityMin
+ this.nVelocityMin.HH = 20;
+ this.nVelocityMin.SD = 0;
+ this.nVelocityMin.BD = 0;
+ this.nVelocityMin.HT = 0;
+ this.nVelocityMin.LT = 0;
+ this.nVelocityMin.FT = 0;
+ this.nVelocityMin.CY = 0;
+ this.nVelocityMin.RD = 0;
+ this.nVelocityMin.LP = 0;
+ this.nVelocityMin.LBD = 0;
+ #endregion
+ this.nRisky = 0; // #23539 2011.7.26 yyagi RISKY繝｢繝ｼ繝
+ this.bIsAutoResultCapture = false; // #25399 2011.6.9 yyagi 繝ｪ繧ｶ繝ｫ繝育判蜒剰ｪ蜍穂ｿ晏ｭ俶ｩ溯ｽON/OFF
+
+ this.b繝舌ャ繝輔ぃ蜈･蜉帙ｒ陦後≧ = true;
+ this.bIsAllowedDoubleClickFullscreen = true; // #26752 2011.11.26 繝繝悶Ν繧ｯ繝ｪ繝繧ｯ縺ｧ縺ｮ繝輔Ν繧ｹ繧ｯ繝ｪ繝ｼ繝ｳ繝｢繝ｼ繝臥ｧｻ陦後ｒ險ｱ蜿ｯ
+ this.nPoliphonicSounds = 4; // #28228 2012.5.1 yyagi 繝ｬ繝ｼ繝ｳ豈弱ｮ譛螟ｧ蜷梧凾逋ｺ髻ｳ謨ｰ
+ // #24820 2013.1.15 yyagi 蛻晄悄蛟､繧4縺九ｉ2縺ｫ螟画峩縲BASS.net菴ｿ逕ｨ譎ゅｮ雋闕ｷ霆ｽ貂帙ｮ縺溘ａ縲
+ // #24820 2013.1.17 yyagi 蛻晄悄蛟､繧4縺ｫ謌ｻ縺励◆縲ょ虚逧縺ｪ繝溘く繧ｵ繝ｼ蛻ｶ蠕｡縺後≧縺ｾ縺丞虚菴懊＠縺ｦ縺繧九◆繧√
+ this.bIsEnabledSystemMenu = true; // #28200 2012.5.1 yyagi System Menu縺ｮ蛻ｩ逕ｨ蜿ｯ蜷ｦ蛻譖ｿ(菴ｿ逕ｨ蜿ｯ)
+ this.strSystemSkinSubfolderFullName = ""; // #28195 2012.5.2 yyagi 菴ｿ逕ｨ荳ｭ縺ｮSkin繧ｵ繝悶ヵ繧ｩ繝ｫ繝蜷
+ this.bTight = false; // #29500 2012.9.11 kairera0467 TIGHT繝｢繝ｼ繝
+ #region [ WASAPI/ASIO ]
+ this.nSoundDeviceType = FDK.COS.bIsVistaOrLater ?
+ (int) ESoundDeviceTypeForConfig.WASAPI : (int) ESoundDeviceTypeForConfig.ACM; // #24820 2012.12.23 yyagi 蛻晄悄蛟､縺ｯACM | #31927 2013.8.25 yyagi OS縺ｫ繧医ｊ蛻晄悄蛟､螟画峩
+ this.nWASAPIBufferSizeMs = 50; // #24820 2013.1.15 yyagi 蛻晄悄蛟､縺ｯ50(0縺ｧ閾ｪ蜍戊ｨｭ螳)
+ this.nASIODevice = 0; // #24820 2013.1.17 yyagi
+// this.nASIOBufferSizeMs = 0; // #24820 2012.12.25 yyagi 蛻晄悄蛟､縺ｯ0(閾ｪ蜍戊ｨｭ螳)
+ #endregion
+ this.bUseOSTimer = false;; // #33689 2014.6.6 yyagi 蛻晄悄蛟､縺ｯfalse (FDK縺ｮ繧ｿ繧､繝槭ｼ縲ゑｼｦｼｲｼｯｼｭ豌剰譯医ｮ迢ｬ閾ｪ繧ｿ繧､繝槭ｼ)
+ this.bDynamicBassMixerManagement = true; //
+ this.bTimeStretch = false; // #23664 2013.2.24 yyagi 蛻晄悄蛟､縺ｯfalse (蜀咲函騾溷ｺｦ螟画峩繧偵√ヴ繝繝∝､画峩縺ｫ縺ｦ陦後≧)
+ this.nDisplayTimesMs = 3000; // #32072 2013.10.24 yyagi Semi-Invisible縺ｧ縺ｮ縲√メ繝繝怜崎｡ｨ遉ｺ譛滄俣
+ this.nFadeoutTimeMs = 2000; // #32072 2013.10.24 yyagi Semi-Invisible縺ｧ縺ｮ縲√メ繝繝励ヵ繧ｧ繝ｼ繝峨い繧ｦ繝域凾髢
+
+ bViewerVSyncWait = true;
+ bViewerShowDebugStatus = true;
+ bViewerTimeStretch = false;
+ bViewerDrums譛牙柑 = true;
+ bViewerGuitar譛牙柑 = true;
+
+
+
+ this.bBranchGuide = false;
+ this.nScoreMode = 2;
+ this.nDefaultCourse = 3;
+ this.nBranchAnime = 1;
+
+ this.b螟ｧ髻ｳ隨ｦ蛻､螳 = false;
+ this.n荳｡謇句愛螳壹ｮ蠕縺｡譎る俣 = 50;
+
+ this.bJudgeCountDisplay = false;
+
+ ShowChara = true;
+ ShowDancer = true;
+ ShowRunner = true;
+ ShowFooter = true;
+ ShowMob = true;
+ ShowPuchiChara = true;
+
+ this.eSTEALTH = E繧ｹ繝繝ｫ繧ｹ繝｢繝ｼ繝.OFF;
+ this.bNoInfo = false;
+
+ //this.bNoMP3Streaming = false;
+ this.nMasterVolume = 100; // #33700 2014.4.26 yyagi 繝槭せ繧ｿ繝ｼ繝懊Μ繝･繝ｼ繝縺ｮ險ｭ螳(WASAPI/ASIO逕ｨ)
+ this.bHispeedRandom = false;
+ this.nDefaultSongSort = 2;
+ this.eGameMode = EGame.OFF;
+ this.TokkunMashInterval = 750;
+ this.bEndingAnime = false;
+ this.nPlayerCount = 1; //2017.08.18 kairera0467 繝槭Ν繝√励Ξ繧､蟇ｾ蠢
+ ShinuchiMode = false;
+ FastRender = true;
+ MusicPreTimeMs = 1000; // 荳遘
+ SendDiscordPlayingInformation = true;
+ #region[ Ver.K霑ｽ蜉 ]
+ this.eLaneType = E繝ｬ繝ｼ繝ｳ繧ｿ繧､繝.TypeA;
+ this.bDirectShowMode = false;
+ #endregion
+ }
+ public CConfigIni( string ini繝輔ぃ繧､繝ｫ蜷 )
+ : this()
+ {
+ this.t繝輔ぃ繧､繝ｫ縺九ｉ隱ｭ縺ｿ霎ｼ縺ｿ( ini繝輔ぃ繧､繝ｫ蜷 );
+ }
+
+
+ // 繝｡繧ｽ繝繝
+
+ public void t謖螳壹＠縺溷･蜉帙′譌｢縺ｫ繧｢繧ｵ繧､繝ｳ貂医∩縺ｧ縺ゅｋ蝣ｴ蜷医ｯ縺昴ｌ繧貞ｨ蜑企勁縺吶ｋ( E蜈･蜉帙ョ繝舌う繧ｹ DeviceType, int nID, int nCode )
+ {
+ for( int i = 0; i <= (int)EKeyConfigPart.SYSTEM; i++ )
+ {
+ for( int j = 0; j <= (int)EKeyConfigPad.Capture; j++ )
+ {
+ for( int k = 0; k < 0x10; k++ )
+ {
+ if( ( ( this.KeyAssign[ i ][ j ][ k ].蜈･蜉帙ョ繝舌う繧ｹ == DeviceType ) && ( this.KeyAssign[ i ][ j ][ k ].ID == nID ) ) && ( this.KeyAssign[ i ][ j ][ k ].繧ｳ繝ｼ繝 == nCode ) )
+ {
+ for( int m = k; m < 15; m++ )
+ {
+ this.KeyAssign[ i ][ j ][ m ] = this.KeyAssign[ i ][ j ][ m + 1 ];
+ }
+ this.KeyAssign[ i ][ j ][ 15 ].蜈･蜉帙ョ繝舌う繧ｹ = E蜈･蜉帙ョ繝舌う繧ｹ.荳肴;
+ this.KeyAssign[ i ][ j ][ 15 ].ID = 0;
+ this.KeyAssign[ i ][ j ][ 15 ].繧ｳ繝ｼ繝 = 0;
+ k--;
+ }
+ }
+ }
+ }
+ }
+ public void t譖ｸ縺榊ｺ縺( string ini繝輔ぃ繧､繝ｫ蜷 )
+ {
+ StreamWriter sw = new StreamWriter( ini繝輔ぃ繧､繝ｫ蜷, false, Encoding.GetEncoding( "Shift_JIS" ) );
+ sw.WriteLine( ";-------------------" );
+
+ #region [ System ]
+ sw.WriteLine( "[System]" );
+ sw.WriteLine();
+
+#if false // #23625 2011.1.11 Config.ini縺九ｉ繝繝｡繝ｼ繧ｸ/蝗槫ｾｩ蛟､縺ｮ螳壽焚螟画峩繧定｡後≧蝣ｴ蜷医ｯ縺薙％繧呈怏蜉ｹ縺ｫ縺吶ｋ 087繝ｪ繝ｪ繝ｼ繧ｹ縺ｫ蜷医ｏ縺帶ｩ溯ｽ辟｡蜉ｹ蛹
+ //------------------------------
+ sw.WriteLine("; 繝ｩ繧､繝輔ご繝ｼ繧ｸ縺ｮ繝代Λ繝｡繝ｼ繧ｿ隱ｿ謨ｴ(隱ｿ謨ｴ螳御ｺ蠕悟炎髯､莠亥ｮ)");
+ sw.WriteLine("; GaugeFactorD: 繝峨Λ繝縺ｮPerfect, Great,... 縺ｮ蝗槫ｾｩ驥(繝ｩ繧､繝筆AX繧1.0縺ｨ縺励◆縺ｨ縺阪ｮ蛟､繧呈欠螳)");
+ sw.WriteLine("; GaugeFactorG: Gt/Bs縺ｮPerfect, Great,... 縺ｮ蝗槫ｾｩ驥(繝ｩ繧､繝筆AX繧1.0縺ｨ縺励◆縺ｨ縺阪ｮ蛟､繧呈欠螳)");
+ sw.WriteLine("; DamageFactorD: DamageLevel縺郡mall, Normal, Large縺ｮ譎ゅ↓蟇ｾ縺吶ｋ繝繝｡繝ｼ繧ｸ菫よ焚");
+ sw.WriteLine("GaugeFactorD={0}, {1}, {2}, {3}, {4}", this.fGaugeFactor[0, 0], this.fGaugeFactor[1, 0], this.fGaugeFactor[2, 0], this.fGaugeFactor[3, 0], this.fGaugeFactor[4, 0]);
+ sw.WriteLine("GaugeFactorG={0}, {1}, {2}, {3}, {4}", this.fGaugeFactor[0, 1], this.fGaugeFactor[1, 1], this.fGaugeFactor[2, 1], this.fGaugeFactor[3, 1], this.fGaugeFactor[4, 1]);
+ sw.WriteLine("DamageFactor={0}, {1}, {2}", this.fDamageLevelFactor[0], this.fDamageLevelFactor[1], fDamageLevelFactor[2]);
+ sw.WriteLine();
+ //------------------------------
+#endif
+ #region [ Version ]
+ sw.WriteLine( "; 繝ｪ繝ｪ繝ｼ繧ｹ繝舌ｼ繧ｸ繝ｧ繝ｳ" );
+ sw.WriteLine( "; Release Version." );
+ sw.WriteLine( "Version={0}", TJAPlayer3.VERSION );
+ sw.WriteLine();
+ #endregion
+ #region [ TJAPath ]
+ sw.WriteLine( "; 隴憺擇繝輔ぃ繧､繝ｫ縺梧ｼ邏阪＆繧後※縺繧九ヵ繧ｩ繝ｫ繝縺ｸ縺ｮ繝代せ縲" );
+ sw.WriteLine( @"; 繧ｻ繝溘さ繝ｭ繝ｳ(;)縺ｧ蛹ｺ蛻繧九％縺ｨ縺ｫ繧医ｊ隍謨ｰ縺ｮ繝代せ繧呈欠螳壹〒縺阪∪縺吶ゑｼ井ｾ: d:\tja\;e:\tja2\ｼ" );
+ sw.WriteLine( "; Pathes for TJA data." );
+ sw.WriteLine( @"; You can specify many pathes separated with semicolon(;). (e.g. d:\tja\;e:\tja2\)" );
+ sw.WriteLine( "TJAPath={0}", this.str譖ｲ繝繝ｼ繧ｿ讀懃ｴ｢繝代せ );
+ sw.WriteLine();
+ #endregion
+ #region [ 繧ｹ繧ｭ繝ｳ髢｢騾｣ ]
+ #region [ Skin繝代せ縺ｮ邨ｶ蟇ｾ繝代せ竊堤嶌蟇ｾ繝代せ螟画鋤 ]
+ Uri uriRoot = new Uri( System.IO.Path.Combine( TJAPlayer3.strEXE縺ｮ縺ゅｋ繝輔か繝ｫ繝, "System" + System.IO.Path.DirectorySeparatorChar ) );
+ if ( strSystemSkinSubfolderFullName != null && strSystemSkinSubfolderFullName.Length == 0 )
+ {
+ // Config.ini縺檎ｩｺ縺ｮ迥ｶ諷九〒DTXMania繧歎iewer縺ｨ縺励※襍ｷ蜍廟邨ゆｺ縺吶ｋ縺ｨ縲《trSystemSkinSubfolderFullName 縺檎ｩｺ縺ｮ迥ｶ諷九〒縺薙％縺ｫ譚･繧九
+ // 竊 蛻晄悄蛟､縺ｨ縺励※ Default/ 繧定ｨｭ螳壹☆繧九
+ strSystemSkinSubfolderFullName = System.IO.Path.Combine( TJAPlayer3.strEXE縺ｮ縺ゅｋ繝輔か繝ｫ繝, "System" + System.IO.Path.DirectorySeparatorChar + "Default" + System.IO.Path.DirectorySeparatorChar );
+ }
+ Uri uriPath = new Uri( System.IO.Path.Combine( this.strSystemSkinSubfolderFullName, "." + System.IO.Path.DirectorySeparatorChar ) );
+ string relPath = uriRoot.MakeRelativeUri( uriPath ).ToString(); // 逶ｸ蟇ｾ繝代せ繧貞叙蠕
+ relPath = System.Web.HttpUtility.UrlDecode( relPath ); // 繝繧ｳ繝ｼ繝峨☆繧
+ relPath = relPath.Replace( '/', System.IO.Path.DirectorySeparatorChar ); // 蛹ｺ蛻繧頑枚蟄励′\縺ｧ縺ｯ縺ｪ縺/縺ｪ縺ｮ縺ｧ鄂ｮ謠帙☆繧
+ #endregion
+ sw.WriteLine( "; 菴ｿ逕ｨ縺吶ｋSkin縺ｮ繝輔か繝ｫ繝蜷阪" );
+ sw.WriteLine( "; 萓九∴縺ｰ System\\Default\\Graphics\\... 縺ｪ縺ｩ縺ｮ蝣ｴ蜷医ｯ縲ヾkinPath=.\\Default\\ 繧呈欠螳壹＠縺ｾ縺吶" );
+ sw.WriteLine( "; Skin folder path." );
+ sw.WriteLine( "; e.g. System\\Default\\Graphics\\... -> Set SkinPath=.\\Default\\" );
+ sw.WriteLine( "SkinPath={0}", relPath );
+ sw.WriteLine();
+ sw.WriteLine("; 莠句燕逕ｻ蜒乗緒逕ｻ讖溯ｽ繧剃ｽｿ縺縺九←縺縺九(0: OFF, 1: ON)");
+ sw.WriteLine("; Use pre-textures render.");
+ sw.WriteLine("{0}={1}", nameof(FastRender), FastRender ? 1 : 0);
+ sw.WriteLine();
+ #endregion
+ #region [ Window髢｢騾｣ ]
+ sw.WriteLine( "; 逕ｻ髱｢繝｢繝ｼ繝(0:繧ｦ繧｣繝ｳ繝峨え, 1:蜈ｨ逕ｻ髱｢)" );
+ sw.WriteLine( "; Screen mode. (0:Window, 1:Fullscreen)" );
+ sw.WriteLine( "FullScreen={0}", this.b蜈ｨ逕ｻ髱｢繝｢繝ｼ繝 ? 1 : 0 );
+ sw.WriteLine();
+ sw.WriteLine("; 繧ｦ繧､繝ｳ繝峨え繝｢繝ｼ繝画凾縺ｮ逕ｻ髱｢蟷"); // #23510 2010.10.31 yyagi add
+ sw.WriteLine("; A width size in the window mode."); //
+ sw.WriteLine("WindowWidth={0}", this.n繧ｦ繧､繝ｳ繝峨えwidth); //
+ sw.WriteLine(); //
+ sw.WriteLine("; 繧ｦ繧､繝ｳ繝峨え繝｢繝ｼ繝画凾縺ｮ逕ｻ髱｢鬮倥＆"); //
+ sw.WriteLine("; A height size in the window mode."); //
+ sw.WriteLine("WindowHeight={0}", this.n繧ｦ繧､繝ｳ繝峨えheight); //
+ sw.WriteLine(); //
+ sw.WriteLine( "; 繧ｦ繧｣繝ｳ繝峨え繝｢繝ｼ繝画凾縺ｮ菴咲ｽｮX" ); // #30675 2013.02.04 ikanick add
+ sw.WriteLine( "; X position in the window mode." ); //
+ sw.WriteLine( "WindowX={0}", this.n蛻晄悄繧ｦ繧｣繝ｳ繝峨え髢句ｧ倶ｽ咲ｽｮX ); //
+ sw.WriteLine(); //
+ sw.WriteLine( "; 繧ｦ繧｣繝ｳ繝峨え繝｢繝ｼ繝画凾縺ｮ菴咲ｽｮY" ); //
+ sw.WriteLine( "; Y position in the window mode." ); //
+ sw.WriteLine( "WindowY={0}", this.n蛻晄悄繧ｦ繧｣繝ｳ繝峨え髢句ｧ倶ｽ咲ｽｮY ); //
+ sw.WriteLine(); //
+
+ sw.WriteLine( "; 繧ｦ繧､繝ｳ繝峨え繧偵ム繝悶Ν繧ｯ繝ｪ繝繧ｯ縺励◆譎ゅ↓繝輔Ν繧ｹ繧ｯ繝ｪ繝ｼ繝ｳ縺ｫ遘ｻ陦後☆繧九°(0:遘ｻ陦後＠縺ｪ縺,1:遘ｻ陦後☆繧)" ); // #26752 2011.11.27 yyagi
+ sw.WriteLine( "; Whether double click to go full screen mode or not.(0:No, 1:Yes)" ); //
+ sw.WriteLine( "DoubleClickFullScreen={0}", this.bIsAllowedDoubleClickFullscreen? 1 : 0); //
+ sw.WriteLine(); //
+ sw.WriteLine( "; ALT+SPACE縺ｮ繝｡繝九Η繝ｼ陦ｨ遉ｺ繧呈椛蛻ｶ縺吶ｋ縺九←縺縺(0:謚大宛縺吶ｋ 1:謚大宛縺励↑縺)" ); // #28200 2012.5.1 yyagi
+ sw.WriteLine( "; Whether ALT+SPACE menu would be masked or not.(0=masked 1=not masked)" ); //
+ sw.WriteLine( "EnableSystemMenu={0}", this.bIsEnabledSystemMenu? 1 : 0 ); //
+ sw.WriteLine(); //
+ sw.WriteLine( "; 髱槭ヵ繧ｩ繝ｼ繧ｫ繧ｹ譎ゅｮsleep蛟､[ms]" ); // #23568 2011.11.04 ikanick add
+ sw.WriteLine( "; A sleep time[ms] while the window is inactive." ); //
+ sw.WriteLine( "BackSleep={0}", this.n髱槭ヵ繧ｩ繝ｼ繧ｫ繧ｹ譎ゅせ繝ｪ繝ｼ繝洋s ); // 縺昴ｮ縺ｾ縺ｾ蠑慕畑ｼ郁協隨托ｼ
+ sw.WriteLine(); //
+ #endregion
+ #region [ 繝輔か繝ｳ繝 ]
+ sw.WriteLine("; 繝輔か繝ｳ繝医Ξ繝ｳ繝繝ｪ繝ｳ繧ｰ縺ｫ菴ｿ逕ｨ縺吶ｋ繝輔か繝ｳ繝亥錐");
+ sw.WriteLine("; Font name used for font rendering.");
+ sw.WriteLine("FontName={0}", this.FontName);
+ sw.WriteLine();
+ sw.WriteLine("; Box縺ｮ隱ｬ譏取枚縺ｮ繝輔か繝ｳ繝医Ξ繝ｳ繝繝ｪ繝ｳ繧ｰ縺ｫ菴ｿ逕ｨ縺吶ｋ繝輔か繝ｳ繝亥錐");
+ sw.WriteLine("; Font name used for font rendering.");
+ sw.WriteLine("BoxFontName={0}", this.BoxFontName);
+ sw.WriteLine();
+ #endregion
+ #region [ 繝輔Ξ繝ｼ繝蜃ｦ逅髢｢騾｣(VSync, 繝輔Ξ繝ｼ繝豈弱ｮsleep) ]
+ sw.WriteLine("; 蝙ら峩蟶ｰ邱壼酔譛(0:OFF,1:ON)");
+ sw.WriteLine( "VSyncWait={0}", this.b蝙ら峩蟶ｰ邱壼ｾ縺｡繧定｡後≧ ? 1 : 0 );
+ sw.WriteLine();
+ sw.WriteLine( "; 繝輔Ξ繝ｼ繝豈弱ｮsleep蛟､[ms] (-1縺ｧ繧ｹ繝ｪ繝ｼ繝礼┌縺, 0莉･荳翫〒豈弱ヵ繝ｬ繝ｼ繝繧ｹ繝ｪ繝ｼ繝励ょ虚逕ｻ繧ｭ繝｣繝励メ繝｣遲峨〒豢ｻ逕ｨ荳九＆縺)" ); // #xxxxx 2011.11.27 yyagi add
+ sw.WriteLine( "; A sleep time[ms] per frame." ); //
+ sw.WriteLine( "SleepTimePerFrame={0}", this.n繝輔Ξ繝ｼ繝豈弱せ繝ｪ繝ｼ繝洋s ); //
+ sw.WriteLine(); //
+ #endregion
+
+ #region [ WASAPI/ASIO髢｢騾｣ ]
+ sw.WriteLine( "; 繧ｵ繧ｦ繝ｳ繝牙ｺ蜉帶婿蠑(0=ACM(縺｣縺ｦ莉翫ｯ縺ｾ縺DirectSound縺ｧ縺吶′), 1=ASIO, 2=WASAPI)" );
+ sw.WriteLine( "; WASAPI縺ｯVista莉･髯阪ｮOS縺ｧ菴ｿ逕ｨ蜿ｯ閭ｽ縲よ耳螂ｨ譁ｹ蠑上ｯWASAPI縲" );
+ sw.WriteLine( "; 縺ｪ縺翫仝ASAPI縺御ｽｿ逕ｨ荳榊庄縺ｪ繧陰SIO繧偵、SIO縺御ｽｿ逕ｨ荳榊庄縺ｪ繧陰CM繧剃ｽｿ逕ｨ縺励∪縺吶" );
+ sw.WriteLine( "; Sound device type(0=ACM, 1=ASIO, 2=WASAPI)" );
+ sw.WriteLine( "; WASAPI can use on Vista or later OSs." );
+ sw.WriteLine( "; If WASAPI is not available, DTXMania try to use ASIO. If ASIO can't be used, ACM is used." );
+ sw.WriteLine( "SoundDeviceType={0}", (int) this.nSoundDeviceType );
+ sw.WriteLine();
+
+ sw.WriteLine( "; WASAPI菴ｿ逕ｨ譎ゅｮ繧ｵ繧ｦ繝ｳ繝峨ヰ繝繝輔ぃ繧ｵ繧､繧ｺ" );
+ sw.WriteLine( "; (0=繝繝舌う繧ｹ縺ｫ險ｭ螳壹＆繧後※縺繧句､繧剃ｽｿ逕ｨ, 1ｽ9999=繝舌ャ繝輔ぃ繧ｵ繧､繧ｺ(蜊倅ｽ:ms)縺ｮ謇句虚謖螳" );
+ sw.WriteLine( "; WASAPI Sound Buffer Size." );
+ sw.WriteLine( "; (0=Use system default buffer size, 1-9999=specify the buffer size(ms) by yourself)" );
+ sw.WriteLine( "WASAPIBufferSizeMs={0}", (int) this.nWASAPIBufferSizeMs );
+ sw.WriteLine();
+
+ sw.WriteLine( "; ASIO菴ｿ逕ｨ譎ゅｮ繧ｵ繧ｦ繝ｳ繝峨ョ繝舌う繧ｹ" );
+ sw.WriteLine( "; 蟄伜惠縺励↑縺繝繝舌う繧ｹ繧呈欠螳壹☆繧九→縲．TXMania縺瑚ｵｷ蜍輔＠縺ｪ縺縺薙→縺後≠繧翫∪縺吶" );
+ sw.WriteLine( "; Sound device used by ASIO." );
+ sw.WriteLine( "; Don't specify unconnected device, as the DTXMania may not bootup." );
+ string[] asiodev = CEnumerateAllAsioDevices.GetAllASIODevices();
+ for ( int i = 0; i < asiodev.Length; i++ )
+ {
+ sw.WriteLine( "; {0}: {1}", i, asiodev[ i ] );
+ }
+ sw.WriteLine( "ASIODevice={0}", (int) this.nASIODevice );
+ sw.WriteLine();
+
+ //sw.WriteLine( "; ASIO菴ｿ逕ｨ譎ゅｮ繧ｵ繧ｦ繝ｳ繝峨ヰ繝繝輔ぃ繧ｵ繧､繧ｺ" );
+ //sw.WriteLine( "; (0=繝繝舌う繧ｹ縺ｫ險ｭ螳壹＆繧後※縺繧句､繧剃ｽｿ逕ｨ, 1ｽ9999=繝舌ャ繝輔ぃ繧ｵ繧､繧ｺ(蜊倅ｽ:ms)縺ｮ謇句虚謖螳" );
+ //sw.WriteLine( "; ASIO Sound Buffer Size." );
+ //sw.WriteLine( "; (0=Use the value specified to the device, 1-9999=specify the buffer size(ms) by yourself)" );
+ //sw.WriteLine( "ASIOBufferSizeMs={0}", (int) this.nASIOBufferSizeMs );
+ //sw.WriteLine();
+
+ //sw.WriteLine( "; Bass.Mix縺ｮ蛻ｶ蠕｡繧貞虚逧縺ｫ陦後≧縺句凄縺九" );
+ //sw.WriteLine( "; ON縺ｫ縺吶ｋ縺ｨ縲√ぐ繧ｿ繝ｼ譖ｲ縺ｪ縺ｩ繝√ャ繝鈴浹縺ｮ螟壹＞譖ｲ繧ょ咲函縺ｧ縺阪∪縺吶′縲∫判髱｢縺悟ｰ代＠縺後◆縺､縺阪∪縺吶" );
+ //sw.WriteLine( "; (0=陦後ｏ縺ｪ縺, 1=陦後≧)" );
+ //sw.WriteLine( "DynamicBassMixerManagement={0}", this.bDynamicBassMixerManagement ? 1 : 0 );
+ //sw.WriteLine();
+
+ sw.WriteLine( "; WASAPI/ASIO譎ゅ↓菴ｿ逕ｨ縺吶ｋ貍泌･上ち繧､繝槭ｼ縺ｮ遞ｮ鬘" );
+ sw.WriteLine( "; Playback timer used for WASAPI/ASIO" );
+ sw.WriteLine( "; (0=FDK Timer, 1=System Timer)" );
+ sw.WriteLine( "SoundTimerType={0}", this.bUseOSTimer ? 1 : 0 );
+ sw.WriteLine();
+
+ //sw.WriteLine( "; 蜈ｨ菴薙懊Μ繝･繝ｼ繝縺ｮ險ｭ螳" );
+ //sw.WriteLine( "; (0=辟｡髻ｳ ｽ 100=譛螟ｧ縲８ASAPI/ASIO譎ゅｮ縺ｿ譛牙柑)" );
+ //sw.WriteLine( "; Master volume settings" );
+ //sw.WriteLine( "; (0=Silent - 100=Max)" );
+ //sw.WriteLine( "MasterVolume={0}", this.nMasterVolume );
+ //sw.WriteLine();
+
+ #endregion
+ sw.WriteLine( "; 閭梧勹逕ｻ蜒上ｮ蜊企乗主牡蜷(0:騾乗趣ｽ255:荳埼乗)" );
+ sw.WriteLine( "; Transparency for background image in playing screen.(0:tranaparent - 255:no transparent)" );
+ sw.WriteLine( "BGAlpha={0}", this.nBGAlpha );
+ sw.WriteLine();
+ sw.WriteLine( "; 繧ｲ繝ｼ繧ｸ繧ｼ繝ｭ縺ｧSTAGE FAILED (0:OFF, 1:ON)" );
+ sw.WriteLine( "StageFailed={0}", this.bSTAGEFAILED譛牙柑 ? 1 : 0 );
+ sw.WriteLine();
+ #region [ AVI/BGA ]
+ sw.WriteLine( "; AVI縺ｮ陦ｨ遉ｺ(0:OFF, 1:ON)" );
+ sw.WriteLine( "AVI={0}", this.bAVI譛牙柑 ? 1 : 0 );
+ sw.WriteLine();
+ sw.WriteLine( "; BGA縺ｮ陦ｨ遉ｺ(0:OFF, 1:ON)" );
+ sw.WriteLine( "BGA={0}", this.bBGA譛牙柑 ? 1 : 0 );
+ sw.WriteLine();
+ sw.WriteLine( "; 蜍慕判陦ｨ遉ｺ繝｢繝ｼ繝( 0:陦ｨ遉ｺ縺励↑縺, 1:閭梧勹縺ｮ縺ｿ, 2:遯楢｡ｨ遉ｺ縺ｮ縺ｿ, 3:荳｡譁ｹ)" );
+ sw.WriteLine( "ClipDispType={0}", (int) this.eClipDispType );
+ sw.WriteLine();
+ #endregion
+ #region [ 繝励Ξ繝薙Η繝ｼ髻ｳ ]
+ sw.WriteLine( "; 譖ｲ驕ｸ謚槭°繧峨励Ξ繝薙Η繝ｼ髻ｳ縺ｮ蜀咲函縺ｾ縺ｧ縺ｮ繧ｦ繧ｧ繧､繝[ms]" );
+ sw.WriteLine( "PreviewSoundWait={0}", this.n譖ｲ縺碁∈謚槭＆繧後※縺九ｉ繝励Ξ繝薙Η繝ｼ髻ｳ縺碁ｳｴ繧九∪縺ｧ縺ｮ繧ｦ繧ｧ繧､繝ms );
+ sw.WriteLine();
+ sw.WriteLine( "; 譖ｲ驕ｸ謚槭°繧峨励Ξ繝薙Η繝ｼ逕ｻ蜒剰｡ｨ遉ｺ縺ｾ縺ｧ縺ｮ繧ｦ繧ｧ繧､繝[ms]" );
+ sw.WriteLine( "PreviewImageWait={0}", this.n譖ｲ縺碁∈謚槭＆繧後※縺九ｉ繝励Ξ繝薙Η繝ｼ逕ｻ蜒上′陦ｨ遉ｺ髢句ｧ九＆繧後ｋ縺ｾ縺ｧ縺ｮ繧ｦ繧ｧ繧､繝ms );
+ sw.WriteLine();
+ #endregion
+ //sw.WriteLine( "; Wave縺ｮ蜀咲函菴咲ｽｮ閾ｪ蜍戊｣懈ｭ｣(0:OFF, 1:ON)" );
+ //sw.WriteLine( "AdjustWaves={0}", this.bWave蜀咲函菴咲ｽｮ閾ｪ蜍戊ｪｿ謨ｴ讖溯ｽ譛牙柑 ? 1 : 0 );
+ #region [ BGM/繝峨Λ繝繝偵ャ繝磯浹縺ｮ蜀咲函 ]
+ sw.WriteLine( "; BGM 縺ｮ蜀咲函(0:OFF, 1:ON)" );
+ sw.WriteLine( "BGMSound={0}", this.bBGM髻ｳ繧堤匱螢ｰ縺吶ｋ ? 1 : 0 );
+ sw.WriteLine();
+ #endregion
+ sw.WriteLine( "; 貍泌･剰ｨ倬鹸ｼ茨ｽ.score.iniｼ峨ｮ蜃ｺ蜉 (0:OFF, 1:ON)" );
+ sw.WriteLine( "SaveScoreIni={0}", this.bScoreIni繧貞ｺ蜉帙☆繧 ? 1 : 0 );
+ sw.WriteLine();
+ sw.WriteLine("; 譛蟆剰｡ｨ遉ｺ繧ｳ繝ｳ繝懈焚");
+ sw.WriteLine("MinComboDrums={0}", this.n陦ｨ遉ｺ蜿ｯ閭ｽ縺ｪ譛蟆上さ繝ｳ繝懈焚.Drums);
+ sw.WriteLine();
+ sw.WriteLine( "; RANDOM SELECT 縺ｧ蟄殖OX繧呈､懃ｴ｢蟇ｾ雎｡縺ｫ蜷ｫ繧√ｋ (0:OFF, 1:ON)" );
+ sw.WriteLine( "RandomFromSubBox={0}", this.b繝ｩ繝ｳ繝繝繧ｻ繝ｬ繧ｯ繝医〒蟄殖OX繧呈､懃ｴ｢蟇ｾ雎｡縺ｨ縺吶ｋ ? 1 : 0 );
+ sw.WriteLine();
+ sw.WriteLine( "; 貍泌･乗ュ蝣ｱ繧定｡ｨ遉ｺ縺吶ｋ (0:OFF, 1:ON)" );
+ sw.WriteLine( "; Showing playing info on the playing screen. (0:OFF, 1:ON)" );
+ sw.WriteLine( "ShowDebugStatus={0}", this.b貍泌･乗ュ蝣ｱ繧定｡ｨ遉ｺ縺吶ｋ ? 1 : 0 );
+ sw.WriteLine();
+ sw.WriteLine("; BS1770GAIN 縺ｫ繧医ｋ繝ｩ繧ｦ繝峨ロ繧ｹ繝｡繝ｼ繧ｿ縺ｮ貂ｬ驥上ｒ驕ｩ逕ｨ縺吶ｋ (0:OFF, 1:ON)");
+ sw.WriteLine( "; Apply BS1770GAIN loudness metadata (0:OFF, 1:ON)" );
+ sw.WriteLine( "{0}={1}", nameof(ApplyLoudnessMetadata), this.ApplyLoudnessMetadata ? 1 : 0 );
+ sw.WriteLine();
+ sw.WriteLine( $"; BS1770GAIN 縺ｫ繧医ｋ繝ｩ繧ｦ繝峨ロ繧ｹ繝｡繝ｼ繧ｿ縺ｮ逶ｮ讓吝､ (0). ({CSound.MinimumLufs}-{CSound.MaximumLufs})" );
+ sw.WriteLine( $"; Loudness Target in dB (decibels) relative to full scale (0). ({CSound.MinimumLufs}-{CSound.MaximumLufs})" );
+ sw.WriteLine( "{0}={1}", nameof(TargetLoudness), TargetLoudness );
+ sw.WriteLine();
+ sw.WriteLine("; .tja繝輔ぃ繧､繝ｫ縺ｮSONGVOL繝倥ャ繝繧帝浹貅舌ｮ髻ｳ驥上↓驕ｩ逕ｨ縺吶ｋ (0:OFF, 1:ON)");
+ sw.WriteLine( "; Apply SONGVOL (0:OFF, 1:ON)" );
+ sw.WriteLine( "{0}={1}", nameof(ApplySongVol), this.ApplySongVol ? 1 : 0 );
+ sw.WriteLine();
+ sw.WriteLine( $"; 蜉ｹ譫憺浹縺ｮ髻ｳ驥 ({CSound.MinimumGroupLevel}-{CSound.MaximumGroupLevel}%)" );
+ sw.WriteLine( $"; Sound effect level ({CSound.MinimumGroupLevel}-{CSound.MaximumGroupLevel}%)" );
+ sw.WriteLine( "{0}={1}", nameof(SoundEffectLevel), SoundEffectLevel );
+ sw.WriteLine();
+ sw.WriteLine( $"; 蜷繝懊う繧ｹ縲√さ繝ｳ繝懊懊う繧ｹ縺ｮ髻ｳ驥 ({CSound.MinimumGroupLevel}-{CSound.MaximumGroupLevel}%)" );
+ sw.WriteLine( $"; Voice level ({CSound.MinimumGroupLevel}-{CSound.MaximumGroupLevel}%)" );
+ sw.WriteLine( "{0}={1}", nameof(VoiceLevel), VoiceLevel );
+ sw.WriteLine();
+ sw.WriteLine( $"; 繧ｲ繝ｼ繝荳ｭ縺ｮ髻ｳ貅舌ｮ髻ｳ驥 ({CSound.MinimumGroupLevel}-{CSound.MaximumGroupLevel}%)" );
+ sw.WriteLine( $"; Song playback level ({CSound.MinimumGroupLevel}-{CSound.MaximumGroupLevel}%)" );
+ sw.WriteLine( "{0}={1}", nameof(SongPlaybackLevel), SongPlaybackLevel );
+ sw.WriteLine();
+ sw.WriteLine( $"; 繧ｭ繝ｼ繝懊ｼ繝峨↓繧医ｋ髻ｳ驥丞､画峩縺ｮ蠅怜刈驥上∵ｸ帛ｰ鷹 ({MinimumKeyboardSoundLevelIncrement}-{MaximumKeyboardSoundLevelIncrement})" );
+ sw.WriteLine( $"; Keyboard sound level increment ({MinimumKeyboardSoundLevelIncrement}-{MaximumKeyboardSoundLevelIncrement})" );
+ sw.WriteLine( "{0}={1}", nameof(KeyboardSoundLevelIncrement), KeyboardSoundLevelIncrement );
+ sw.WriteLine($"; 髻ｳ貅仙咲函蜑阪ｮ遨ｺ逋ｽ譎る俣 (ms)");
+ sw.WriteLine($"; Blank time before music source to play. (ms)");
+ sw.WriteLine("{0}={1}", nameof(MusicPreTimeMs), MusicPreTimeMs);
+ sw.WriteLine();
+ sw.WriteLine( "; 繧ｹ繝医う繝繧ｯ繝｢繝ｼ繝(0:OFF, 1:ON)" );
+ sw.WriteLine( "; Stoic mode. (0:OFF, 1:ON)" );
+ sw.WriteLine( "StoicMode={0}", this.b繧ｹ繝医う繝繧ｯ繝｢繝ｼ繝 ? 1 : 0 );
+ sw.WriteLine();
+ sw.WriteLine( "; 繝舌ャ繝輔ぃ蜈･蜉帙Δ繝ｼ繝(0:OFF, 1:ON)" );
+ sw.WriteLine( "; Using Buffered input (0:OFF, 1:ON)" );
+ sw.WriteLine( "BufferedInput={0}", this.b繝舌ャ繝輔ぃ蜈･蜉帙ｒ陦後≧ ? 1 : 0 );
+ sw.WriteLine();
+ sw.WriteLine( "; 繝ｪ繧ｶ繝ｫ繝育判蜒剰ｪ蜍穂ｿ晏ｭ俶ｩ溯ｽ(0:OFF, 1:ON)" ); // #25399 2011.6.9 yyagi
+ sw.WriteLine( "; Set \"1\" if you'd like to save result screen image automatically"); //
+ sw.WriteLine( "; when you get hiscore/hiskill."); //
+ sw.WriteLine( "AutoResultCapture={0}", this.bIsAutoResultCapture? 1 : 0 ); //
+ sw.WriteLine();
+ sw.WriteLine("; Discord縺ｫ蜀咲函荳ｭ縺ｮ隴憺擇諠蝣ｱ繧帝∽ｿ｡縺吶ｋ(0:OFF, 1:ON)"); // #25399 2011.6.9 yyagi
+ sw.WriteLine("; Share Playing .tja file infomation on Discord."); //
+ sw.WriteLine("{0}={1}", nameof(SendDiscordPlayingInformation), SendDiscordPlayingInformation ? 1 : 0); //
+ sw.WriteLine();
+ sw.WriteLine( "; 蜀咲函騾溷ｺｦ螟画峩繧偵√ヴ繝繝∝､画峩縺ｧ陦後≧縺九←縺縺(0:繝斐ャ繝∝､画峩, 1:繧ｿ繧､繝繧ｹ繝医Ξ繝繝" ); // #23664 2013.2.24 yyagi
+ sw.WriteLine( "; (WASAPI/ASIO菴ｿ逕ｨ譎ゅｮ縺ｿ譛牙柑) " );
+ sw.WriteLine( "; Set \"0\" if you'd like to use pitch shift with PlaySpeed." ); //
+ sw.WriteLine( "; Set \"1\" for time stretch." ); //
+ sw.WriteLine( "; (Only available when you're using using WASAPI or ASIO)" ); //
+ sw.WriteLine( "TimeStretch={0}", this.bTimeStretch ? 1 : 0 ); //
+ sw.WriteLine();
+ //sw.WriteLine( "; WASAPI/ASIO菴ｿ逕ｨ譎ゅ↓縲｀P3繧偵せ繝医Μ繝ｼ繝蜀咲函縺吶ｋ縺九←縺縺(0:繧ｹ繝医Μ繝ｼ繝蜀咲函縺吶ｋ, 1:縺励↑縺)" ); //
+ //sw.WriteLine( "; (mp3縺ｮ繧ｷ繝ｼ繧ｯ縺後♀縺九＠縺上↑繧句ｴ蜷医ｯ縲√％繧後ｒ1縺ｫ縺励※縺上□縺輔＞) " ); //
+ //sw.WriteLine( "; Set \"0\" if you'd like to use mp3 streaming playback on WASAPI/ASIO." ); //
+ //sw.WriteLine( "; Set \"1\" not to use streaming playback for mp3." ); //
+ //sw.WriteLine( "; (If you feel illegal seek with mp3, please set it to 1.)" ); //
+ //sw.WriteLine( "NoMP3Streaming={0}", this.bNoMP3Streaming ? 1 : 0 ); //
+ //sw.WriteLine();
+ sw.WriteLine( "; 蜍慕判蜀咲函縺ｫDirectShow繧剃ｽｿ逕ｨ縺吶ｋ(0:OFF, 1:ON)" );
+ sw.WriteLine( "; 蜍慕判蜀咲函縺ｫDirectShow繧剃ｽｿ縺縺薙→縺ｫ繧医▲縺ｦ縲∝咲函譎ゅｮ雋諡繧定ｻｽ貂帙〒縺阪∪縺吶");
+ sw.WriteLine( "; 縺溘□縺嶺ｽｿ逕ｨ譎ゅ↓縺ｯ繧ｻ繝繝医い繝繝励′蠢隕√↓縺ｪ繧九ｮ縺ｧ縺疲ｳｨ諢上￥縺縺輔＞縲");
+ sw.WriteLine( "DirectShowMode={0}", this.bDirectShowMode ? 1 : 0 );
+ sw.WriteLine();
+
+ #region [ Adjust ]
+ sw.WriteLine( "; 蛻､螳壹ち繧､繝溘Φ繧ｰ隱ｿ謨ｴ(-99ｽ99)[ms]" );
+ sw.WriteLine("; Revision value to adjust judgment timing."); //
+ sw.WriteLine("InputAdjustTime={0}", this.nInputAdjustTimeMs); //
+ sw.WriteLine();
+
+ sw.WriteLine( "; 蛻､螳壹Λ繧､繝ｳ縺ｮ陦ｨ遉ｺ菴咲ｽｮ隱ｿ謨ｴ(繝峨Λ繝, 繧ｮ繧ｿ繝ｼ, 繝吶ｼ繧ｹ)(-99ｽ99)[px]" ); // #31602 2013.6.23 yyagi 蛻､螳壹Λ繧､繝ｳ縺ｮ陦ｨ遉ｺ菴咲ｽｮ繧ｪ繝輔そ繝繝
+ sw.WriteLine( "; Offset value to adjust displaying judgement line for the drums, guitar and bass." ); //
+ sw.WriteLine( "JudgeLinePosOffsetDrums={0}", this.nJudgeLinePosOffset.Drums ); //
+ sw.WriteLine();
+ #endregion
+ sw.WriteLine( "; 縲後∪縺滄♀繧薙〒縺ｭ縲咲判髱｢(0:OFF, 1:ON)" );
+ sw.WriteLine( "EndingAnime={0}", this.bEndingAnime ? 1 : 0 );
+ sw.WriteLine();
+ sw.WriteLine( ";-------------------" );
+ #endregion
+
+ #region [ AutoPlay ]
+ sw.WriteLine("[AutoPlay]");
+ sw.WriteLine();
+ sw.WriteLine("; 閾ｪ蜍墓ｼ泌･(0:OFF, 1:ON)");
+ sw.WriteLine("Taiko={0}", this.b螟ｪ鮠薙ヱ繝ｼ繝AutoPlay ? 1 : 0);
+ sw.WriteLine("Taiko2P={0}", this.b螟ｪ鮠薙ヱ繝ｼ繝AutoPlay2P ? 1 : 0);
+ sw.WriteLine("TaikoAutoRoll={0}", this.bAuto蜈育函縺ｮ騾｣謇 ? 1 : 0);
+ sw.WriteLine();
+ sw.WriteLine(";-------------------");
+ #endregion
+
+ #region [ HitRange ]
+ sw.WriteLine("[HitRange]");
+ sw.WriteLine();
+ sw.WriteLine("; Perfectｽ霸oor 縺ｨ縺ｿ縺ｪ縺輔ｌ繧狗ｯ蝗ｲ[ms]");
+ sw.WriteLine("Perfect={0}", this.n繝偵ャ繝育ｯ蝗ｲms.Perfect);
+ sw.WriteLine("Good={0}", this.n繝偵ャ繝育ｯ蝗ｲms.Good);
+ sw.WriteLine("Poor={0}", this.n繝偵ャ繝育ｯ蝗ｲms.Poor);
+ sw.WriteLine();
+ sw.WriteLine(";-------------------");
+ #endregion
+
+ #region [ Log ]
+ sw.WriteLine( "[Log]" );
+ sw.WriteLine();
+ sw.WriteLine( "; Log蜃ｺ蜉(0:OFF, 1:ON)" );
+ sw.WriteLine( "OutputLog={0}", this.b繝ｭ繧ｰ蜃ｺ蜉 ? 1 : 0 );
+ sw.WriteLine();
+ sw.WriteLine( "; 譖ｲ繝繝ｼ繧ｿ讀懃ｴ｢縺ｫ髢｢縺吶ｋLog蜃ｺ蜉(0:OFF, 1:ON)" );
+ sw.WriteLine( "TraceSongSearch={0}", this.bLog譖ｲ讀懃ｴ｢繝ｭ繧ｰ蜃ｺ蜉 ? 1 : 0 );
+ sw.WriteLine();
+ sw.WriteLine( "; 逕ｻ蜒上ｄ繧ｵ繧ｦ繝ｳ繝峨ｮ菴懈神隗｣謾ｾ縺ｫ髢｢縺吶ｋLog蜃ｺ蜉(0:OFF, 1:ON)" );
+ sw.WriteLine( "TraceCreatedDisposed={0}", this.bLog菴懈占ｧ｣謾ｾ繝ｭ繧ｰ蜃ｺ蜉 ? 1 : 0 );
+ sw.WriteLine();
+ sw.WriteLine( "; DTX隱ｭ縺ｿ霎ｼ縺ｿ隧ｳ邏ｰ縺ｫ髢｢縺吶ｋLog蜃ｺ蜉(0:OFF, 1:ON)" );
+ sw.WriteLine( "TraceDTXDetails={0}", this.bLogDTX隧ｳ邏ｰ繝ｭ繧ｰ蜃ｺ蜉 ? 1 : 0 );
+ sw.WriteLine();
+ sw.WriteLine( ";-------------------" );
+ #endregion
+
+ #region [ PlayOption ]
+ sw.WriteLine( "[PlayOption]" );
+ sw.WriteLine();
+ sw.WriteLine("; 蜷逕ｻ蜒上ｮ陦ｨ遉ｺ險ｭ螳");
+ sw.WriteLine("; 繧ｭ繝｣繝ｩ繧ｯ繧ｿ繝ｼ逕ｻ蜒上ｒ陦ｨ遉ｺ縺吶ｋ (0:OFF, 1:ON)");
+ sw.WriteLine("ShowChara={0}", ShowChara ? 1 : 0);
+ sw.WriteLine("; 繝繝ｳ繧ｵ繝ｼ逕ｻ蜒上ｒ陦ｨ遉ｺ縺吶ｋ (0:OFF, 1:ON)");
+ sw.WriteLine("ShowDancer={0}", ShowDancer ? 1 : 0);
+ sw.WriteLine("; 繝ｩ繝ｳ繝翫ｼ逕ｻ蜒上ｒ陦ｨ遉ｺ縺吶ｋ (0:OFF, 1:ON)");
+ sw.WriteLine("ShowRunner={0}", ShowRunner ? 1 : 0);
+ sw.WriteLine("; 繝｢繝也判蜒上ｒ陦ｨ遉ｺ縺吶ｋ (0:OFF, 1:ON)");
+ sw.WriteLine("ShowMob={0}", ShowMob ? 1 : 0);
+ sw.WriteLine("; 繝輔ャ繧ｿ繝ｼ逕ｻ蜒 (0:OFF, 1:ON)");
+ sw.WriteLine("ShowFooter={0}", ShowFooter ? 1 : 0);
+ sw.WriteLine("; 縺ｷ縺｡繧ｭ繝｣繝ｩ逕ｻ蜒 (0:OFF, 1:ON)");
+ sw.WriteLine("ShowPuchiChara={0}", ShowPuchiChara ? 1 : 0);
+ sw.WriteLine();
+ sw.WriteLine( "; DARK繝｢繝ｼ繝(0:OFF, 1:HALF, 2:FULL)" );
+ sw.WriteLine( "Dark={0}", (int) this.eDark );
+ sw.WriteLine();
+ sw.WriteLine();
+ sw.WriteLine("; 驕ｸ譖ｲ逕ｻ髱｢縺ｧ縺ｮ繧ｿ繧､繝槭ｼ繧呈怏蜉ｹ縺ｫ縺吶ｋ縺九←縺縺(0:辟｡蜉ｹ,1:譛牙柑)");
+ sw.WriteLine("; Enable countdown in songselect.(0:No, 1:Yes)");
+ sw.WriteLine("EnableCountDownTimer={0}", this.bEnableCountdownTimer ? 1 : 0);
+ sw.WriteLine();
+ #region [ SUDDEN ]
+ sw.WriteLine( "; 繝峨Λ繝SUDDEN繝｢繝ｼ繝(0:OFF, 1:ON)" );
+ sw.WriteLine( "DrumsSudden={0}", this.bSudden.Drums ? 1 : 0 );
+ sw.WriteLine();
+ #endregion
+ #region [ HIDDEN ]
+ sw.WriteLine( "; 繝峨Λ繝HIDDEN繝｢繝ｼ繝(0:OFF, 1:ON)" );
+ sw.WriteLine( "DrumsHidden={0}", this.bHidden.Drums ? 1 : 0 );
+ sw.WriteLine();
+ #endregion
+ #region [ Invisible ]
+ sw.WriteLine( "; 繝峨Λ繝繝√ャ繝鈴撼陦ｨ遉ｺ繝｢繝ｼ繝 (0:OFF, 1=SEMI, 2:FULL)" );
+ sw.WriteLine( "; Drums chip invisible mode" );
+ sw.WriteLine( "DrumsInvisible={0}", (int) this.eInvisible.Drums );
+ sw.WriteLine();
+ //sw.WriteLine( "; Semi-Invisible縺ｧMiss縺｣縺滓凾縺ｮ繝√ャ繝怜崎｡ｨ遉ｺ譎る俣(ms)" );
+ //sw.WriteLine( "InvisibleDisplayTimeMs={0}", (int) this.nDisplayTimesMs );
+ //sw.WriteLine();
+ //sw.WriteLine( "; Semi-Invisible縺ｧMiss縺｣縺ｦ繝√ャ繝怜崎｡ｨ遉ｺ譎る俣邨ゆｺ蠕後ｮ繝輔ぉ繝ｼ繝峨い繧ｦ繝域凾髢(ms)" );
+ //sw.WriteLine( "InvisibleFadeoutTimeMs={0}", (int) this.nFadeoutTimeMs );
+ //sw.WriteLine();
+ #endregion
+ sw.WriteLine( "; 繝峨Λ繝REVERSE繝｢繝ｼ繝(0:OFF, 1:ON)" );
+ sw.WriteLine( "DrumsReverse={0}", this.bReverse.Drums ? 1 : 0 );
+ sw.WriteLine();
+ sw.WriteLine( "; RISKY繝｢繝ｼ繝(0:OFF, 1-10)" ); // #23559 2011.6.23 yyagi
+ sw.WriteLine( "; RISKY mode. 0=OFF, 1-10 is the times of misses to be Failed." ); //
+ sw.WriteLine( "Risky={0}", this.nRisky ); //
+ sw.WriteLine();
+ sw.WriteLine( "; TIGHT繝｢繝ｼ繝(0:OFF, 1:ON)" ); // #29500 2012.9.11 kairera0467
+ sw.WriteLine( "; TIGHT mode. 0=OFF, 1=ON " );
+ sw.WriteLine( "DrumsTight={0}", this.bTight ? 1 : 0 );
+ sw.WriteLine();
+ sw.WriteLine("; 繝峨Λ繝隴憺擇繧ｹ繧ｯ繝ｭ繝ｼ繝ｫ騾溷ｺｦ(0:x0.1, 9:x1.0, 14:x1.5,窶ｦ,1999:x200.0)");
+ sw.WriteLine( "DrumsScrollSpeed={0}", this.n隴憺擇繧ｹ繧ｯ繝ｭ繝ｼ繝ｫ騾溷ｺｦ.Drums );
+ sw.WriteLine();
+ sw.WriteLine( "; 貍泌･城溷ｺｦ(5ｽ40)(竊遅5/20ｽ栞40/20)" );
+ sw.WriteLine( "PlaySpeed={0}", this.n貍泌･城溷ｺｦ );
+ sw.WriteLine();
+
+ sw.WriteLine("; 貍泌･城溷ｺｦ縺御ｸ蛟埼溘〒縺ゅｋ縺ｨ縺阪ｮ縺ｿBGM繧貞咲函縺吶ｋ(0:OFF, 1:ON)");
+ sw.WriteLine("PlaySpeedNotEqualOneNoSound={0}", this.b貍泌･城溷ｺｦ縺御ｸ蛟埼溘〒縺ゅｋ縺ｨ縺堺ｻ･螟夜浹螢ｰ繧貞咲函縺励↑縺 ? 1 : 0);
+ sw.WriteLine();
+ sw.WriteLine("; 繝繝輔か繝ｫ繝医〒驕ｸ謚槭＆繧後ｋ髮｣譏灘ｺｦ");
+ sw.WriteLine("DefaultCourse={0}", this.nDefaultCourse);
+ sw.WriteLine();
+ sw.WriteLine( "; 隴憺擇蛻蟯舌ｮ繧ｬ繧､繝芽｡ｨ遉ｺ(0:OFF, 1:ON)" );
+ sw.WriteLine( "BranchGuide={0}", this.bGraph.Drums ? 1 : 0 );
+ sw.WriteLine();
+ sw.WriteLine( "; 繧ｹ繧ｳ繧｢險育ｮ玲婿豕(0:譌ｧ驟咲せ, 1:譌ｧ遲蝉ｽ馴咲せ, 2:譁ｰ驟咲せ)" );
+ sw.WriteLine( "ScoreMode={0}", this.nScoreMode );
+ sw.WriteLine();
+ sw.WriteLine("; 逵滓遠繝｢繝ｼ繝 (0:OFF, 1:ON)");
+ sw.WriteLine("; Fixed score mode (0:OFF, 1:ON)");
+ sw.WriteLine("{0}={1}", nameof(ShinuchiMode), ShinuchiMode ? 1 : 0);
+ //sw.WriteLine( "; 1繝弱ｼ繝縺斐→縺ｮ繧ｹ繧ｯ繝ｭ繝ｼ繝ｫ騾溷ｺｦ繧偵Λ繝ｳ繝繝縺ｧ螟画峩縺励∪縺吶(0:OFF, 1:ON)" );
+ //sw.WriteLine( "HispeedRandom={0}", this.bHispeedRandom ? 1 : 0 );
+ //sw.WriteLine();
+ sw.WriteLine( "; 螟ｧ髻ｳ隨ｦ縺ｮ荳｡謇句･蜉帛ｾ讖滓凾髢(ms)" );
+ sw.WriteLine( "BigNotesWaitTime={0}", this.n荳｡謇句愛螳壹ｮ蠕縺｡譎る俣 );
+ sw.WriteLine();
+ sw.WriteLine( "; 螟ｧ髻ｳ隨ｦ縺ｮ荳｡謇句愛螳(0:OFF, 1:ON)" );
+ sw.WriteLine( "BigNotesJudge={0}", this.b螟ｧ髻ｳ隨ｦ蛻､螳 ? 1 : 0 );
+ sw.WriteLine();
+ sw.WriteLine( "; NoInfo(0:OFF, 1:ON)" );
+ sw.WriteLine( "NoInfo={0}", this.bNoInfo ? 1 : 0 );
+ sw.WriteLine();
+ sw.WriteLine( "; 隴憺擇蛻蟯舌ｮ繧｢繝九Γ繝ｼ繧ｷ繝ｧ繝ｳ(0:7ｽ14, 1:15)" );
+ sw.WriteLine( "BranchAnime={0}", this.nBranchAnime );
+ sw.WriteLine();
+ sw.WriteLine( "; 繝繝輔か繝ｫ繝医ｮ譖ｲ繧ｽ繝ｼ繝(0:邨ｶ蟇ｾ繝代せ鬆, 1:繧ｸ繝｣繝ｳ繝ｫ蜷阪た繝ｼ繝OLD, 2:繧ｸ繝｣繝ｳ繝ｫ蜷阪た繝ｼ繝NEW )" );
+ sw.WriteLine( "0:Path, 1:GenreName(AC8ｽ暸C14), 2GenreName(AC15ｽ)" );
+ sw.WriteLine( "DefaultSongSort={0}", this.nDefaultSongSort );
+ sw.WriteLine();
+ sw.WriteLine( "; RANDOM繝｢繝ｼ繝(0:OFF, 1:Random, 2:Mirorr 3:SuperRandom, 4:HyperRandom)" );
+ sw.WriteLine( "TaikoRandom={0}", (int) this.eRandom.Taiko );
+ sw.WriteLine();
+ sw.WriteLine( "; STEALTH繝｢繝ｼ繝(0:OFF, 1:繝峨Ο繝ｳ, 2:繧ｹ繝繝ｫ繧ｹ)" );
+ sw.WriteLine( "TaikoStealth={0}", (int) this.eSTEALTH );
+ sw.WriteLine();
+ sw.WriteLine( "; 繧ｲ繝ｼ繝(0:OFF, 1:螳瑚ｵｰ!蜿ｩ縺阪″繧翫∪繧ｷ繝ｧ繝ｼ!, 2:螳瑚ｵｰ!蜿ｩ縺阪″繧翫∪繧ｷ繝ｧ繝ｼ!(豼霎) )" );
+ sw.WriteLine( "GameMode={0}", (int) this.eGameMode );
+ sw.WriteLine();
+ sw.WriteLine();
+ sw.WriteLine("; 迚ｹ險薙Δ繝ｼ繝画凾縺ｫPgUp/PgDn縺ｧ菴募ｰ冗ｯ鬟帙ｰ縺吶°");
+ sw.WriteLine("TokkunSkipMeasures={0}", this.TokkunSkipMeasures);
+ sw.WriteLine();
+ sw.WriteLine("; 迚ｹ險薙Δ繝ｼ繝画凾縺ｫ繧ｸ繝｣繝ｳ繝励昴う繝ｳ繝医↓鬟帙ｰ縺吶◆繧√ｮ譎る俣(ms)");
+ sw.WriteLine("; 謖螳嗄s莉･蜀縺ｫ5蝗樒ｸ√ｒ蜿ｩ縺阪∪縺励ｇ縺");
+ sw.WriteLine("{1}={0}", this.TokkunMashInterval, nameof(this.TokkunMashInterval));
+ sw.WriteLine();
+ sw.WriteLine( "; JUST(0:OFF, 1:ON)" );
+ sw.WriteLine( "Just={0}", this.bJust ? 1 : 0 );
+ sw.WriteLine();
+ sw.WriteLine( "; 蛻､螳壽焚縺ｮ陦ｨ遉ｺ(0:OFF, 1:ON)" );
+ sw.WriteLine( "JudgeCountDisplay={0}", this.bJudgeCountDisplay ? 1 : 0 );
+ sw.WriteLine();
+ sw.WriteLine( "; 繝励Ξ繧､莠ｺ謨ｰ" );
+ sw.WriteLine( "PlayerCount={0}", this.nPlayerCount );
+ sw.WriteLine();
+ //sw.WriteLine( "; 驕ｸ譖ｲ逕ｻ髱｢縺ｮ蛻晄悄驕ｸ謚樣屮譏灘ｺｦ(繝吶ｼ繧ｿ迚)" );
+ //sw.WriteLine( "DifficultPriority={0}", this.bJudgeCountDisplay ? 1 : 0 );
+ //sw.WriteLine();
+
+ sw.WriteLine( ";-------------------" );
+ #endregion
+ #region [ GUID ]
+ sw.WriteLine( "[GUID]" );
+ sw.WriteLine();
+ foreach( KeyValuePair pair in this.dicJoystick )
+ {
+ sw.WriteLine( "JoystickID={0},{1}", pair.Key, pair.Value );
+ }
+ #endregion
+ #region [ DrumsKeyAssign ]
+ sw.WriteLine();
+ sw.WriteLine( ";-------------------" );
+ sw.WriteLine( "; 繧ｭ繝ｼ繧｢繧ｵ繧､繝ｳ" );
+ sw.WriteLine( "; 鬆縲逶ｮｼ哮eyboard 竊 'K'ｼ'0'ｼ九く繝ｼ繧ｳ繝ｼ繝(10騾ｲ謨ｰ)" );
+ sw.WriteLine( "; Mouse 竊 'N'ｼ'0'ｼ九懊ち繝ｳ逡ｪ蜿ｷ(0ｽ7)" );
+ sw.WriteLine( "; MIDI In 竊 'M'ｼ九ョ繝舌う繧ｹ逡ｪ蜿ｷ1譯(0ｽ9,Aｽ杙)ｼ九ヮ繝ｼ繝育分蜿ｷ(10騾ｲ謨ｰ)" );
+ sw.WriteLine( "; Joystick 竊 'J'ｼ九ョ繝舌う繧ｹ逡ｪ蜿ｷ1譯(0ｽ9,Aｽ杙)ｼ 0 ...... ｼｸ貂帛ｰ(蟾ｦ)繝懊ち繝ｳ" );
+ sw.WriteLine( "; 1 ...... ｼｸ蠅怜刈(蜿ｳ)繝懊ち繝ｳ" );
+ sw.WriteLine( "; 2 ...... ｼｹ貂帛ｰ(荳)繝懊ち繝ｳ" );
+ sw.WriteLine( "; 3 ...... ｼｹ蠅怜刈(荳)繝懊ち繝ｳ" );
+ sw.WriteLine( "; 4 ...... ｼｺ貂帛ｰ(蜑)繝懊ち繝ｳ" );
+ sw.WriteLine( "; 5 ...... ｼｺ蠅怜刈(蠕)繝懊ち繝ｳ" );
+ sw.WriteLine( "; 6ｽ133.. 繝懊ち繝ｳ1ｽ128" );
+ sw.WriteLine( "; 縺薙ｌ繧峨ｮ鬆逶ｮ繧 16 蛟九∪縺ｧ謖螳壼庄閭ｽ(',' 縺ｧ蛹ｺ蛻縺｣縺ｦ險倩ｿｰｼ峨" );
+ sw.WriteLine( ";" );
+ sw.WriteLine( "; 陦ｨ險倅ｾ具ｼ唏H=K044,M042,J16" );
+ sw.WriteLine( "; 竊 HiHat 繧 Keyboard 縺ｮ 44 ('Z'), MidiIn#0 縺ｮ 42, JoyPad#1 縺ｮ 6(繝懊ち繝ｳ1) 縺ｫ蜑ｲ蠖薙※" );
+ sw.WriteLine( ";" );
+ sw.WriteLine( "; 窶ｻJoystick 縺ｮ繝繝舌う繧ｹ逡ｪ蜿ｷ縺ｨ繝繝舌う繧ｹ縺ｨ縺ｮ髢｢菫ゅｯ [GUID] 繧ｻ繧ｯ繧ｷ繝ｧ繝ｳ縺ｫ險倥＠縺ｦ縺ゅｋ繧ゅｮ縺梧怏蜉ｹ縲" );
+ sw.WriteLine( ";" );
+ sw.WriteLine();
+ sw.WriteLine( "[DrumsKeyAssign]" );
+ sw.WriteLine();
+ sw.Write( "LeftRed=" );
+ this.t繧ｭ繝ｼ縺ｮ譖ｸ縺榊ｺ縺( sw, this.KeyAssign.Drums.LeftRed );
+ sw.WriteLine();
+ sw.Write( "RightRed=" );
+ this.t繧ｭ繝ｼ縺ｮ譖ｸ縺榊ｺ縺( sw, this.KeyAssign.Drums.RightRed );
+ sw.WriteLine();
+ sw.Write( "LeftBlue=" ); // #27029 2012.1.4 from
+ this.t繧ｭ繝ｼ縺ｮ譖ｸ縺榊ｺ縺( sw, this.KeyAssign.Drums.LeftBlue ); //
+ sw.WriteLine(); //
+ sw.Write( "RightBlue=" ); // #27029 2012.1.4 from
+ this.t繧ｭ繝ｼ縺ｮ譖ｸ縺榊ｺ縺( sw, this.KeyAssign.Drums.RightBlue ); //
+ sw.WriteLine();
+ sw.Write( "LeftRed2P=" );
+ this.t繧ｭ繝ｼ縺ｮ譖ｸ縺榊ｺ縺( sw, this.KeyAssign.Drums.LeftRed2P );
+ sw.WriteLine();
+ sw.Write( "RightRed2P=" );
+ this.t繧ｭ繝ｼ縺ｮ譖ｸ縺榊ｺ縺( sw, this.KeyAssign.Drums.RightRed2P );
+ sw.WriteLine();
+ sw.Write( "LeftBlue2P=" ); // #27029 2012.1.4 from
+ this.t繧ｭ繝ｼ縺ｮ譖ｸ縺榊ｺ縺( sw, this.KeyAssign.Drums.LeftBlue2P ); //
+ sw.WriteLine(); //
+ sw.Write( "RightBlue2P=" ); // #27029 2012.1.4 from
+ this.t繧ｭ繝ｼ縺ｮ譖ｸ縺榊ｺ縺( sw, this.KeyAssign.Drums.RightBlue2P ); //
+ sw.WriteLine();
+ sw.WriteLine();
+ #endregion
+ #region [ SystemkeyAssign ]
+ sw.WriteLine( "[SystemKeyAssign]" );
+ sw.WriteLine();
+ sw.Write( "Capture=" );
+ this.t繧ｭ繝ｼ縺ｮ譖ｸ縺榊ｺ縺( sw, this.KeyAssign.System.Capture );
+ sw.WriteLine();
+ sw.WriteLine();
+ #endregion
+
+ sw.Close();
+ }
+ public void t繝輔ぃ繧､繝ｫ縺九ｉ隱ｭ縺ｿ霎ｼ縺ｿ( string ini繝輔ぃ繧､繝ｫ蜷 )
+ {
+ this.ConfigIni繝輔ぃ繧､繝ｫ蜷 = ini繝輔ぃ繧､繝ｫ蜷;
+ this.bConfigIni縺悟ｭ伜惠縺励※縺繧 = File.Exists( this.ConfigIni繝輔ぃ繧､繝ｫ蜷 );
+ if( this.bConfigIni縺悟ｭ伜惠縺励※縺繧 )
+ {
+ string str;
+ this.t繧ｭ繝ｼ繧｢繧ｵ繧､繝ｳ繧貞ｨ驛ｨ繧ｯ繝ｪ繧｢縺吶ｋ();
+ using ( StreamReader reader = new StreamReader( this.ConfigIni繝輔ぃ繧､繝ｫ蜷, Encoding.GetEncoding( "Shift_JIS" ) ) )
+ {
+ str = reader.ReadToEnd();
+ }
+ t譁蟄怜励°繧芽ｪｭ縺ｿ霎ｼ縺ｿ( str );
+ CDTXVersion version = new CDTXVersion( this.strDTXMania縺ｮ繝舌ｼ繧ｸ繝ｧ繝ｳ );
+ //if( version.n謨ｴ謨ｰ驛ｨ <= 69 )
+ //{
+ // this.t繝繝輔か繝ｫ繝医ｮ繧ｭ繝ｼ繧｢繧ｵ繧､繝ｳ縺ｫ險ｭ螳壹☆繧();
+ //}
+ }
+ }
+
+ private void t譁蟄怜励°繧芽ｪｭ縺ｿ霎ｼ縺ｿ( string strAllSettings ) // 2011.4.13 yyagi; refactored to make initial KeyConfig easier.
+ {
+ E繧ｻ繧ｯ繧ｷ繝ｧ繝ｳ遞ｮ蛻･ unknown = E繧ｻ繧ｯ繧ｷ繝ｧ繝ｳ遞ｮ蛻･.Unknown;
+ string[] delimiter = { "\n" };
+ string[] strSingleLine = strAllSettings.Split( delimiter, StringSplitOptions.RemoveEmptyEntries );
+ foreach ( string s in strSingleLine )
+ {
+ string str = s.Replace( '\t', ' ' ).TrimStart( new char[] { '\t', ' ' } );
+ if ( ( str.Length != 0 ) && ( str[ 0 ] != ';' ) )
+ {
+ try
+ {
+ string str3;
+ string str4;
+ if ( str[ 0 ] == '[' )
+ {
+ #region [ 繧ｻ繧ｯ繧ｷ繝ｧ繝ｳ縺ｮ螟画峩 ]
+ //-----------------------------
+ StringBuilder builder = new StringBuilder( 0x20 );
+ int num = 1;
+ while ( ( num < str.Length ) && ( str[ num ] != ']' ) )
+ {
+ builder.Append( str[ num++ ] );
+ }
+ string str2 = builder.ToString();
+ if ( str2.Equals( "System" ) )
+ {
+ unknown = E繧ｻ繧ｯ繧ｷ繝ｧ繝ｳ遞ｮ蛻･.System;
+ }
+ else if (str2.Equals("AutoPlay"))
+ {
+ unknown = E繧ｻ繧ｯ繧ｷ繝ｧ繝ｳ遞ｮ蛻･.AutoPlay;
+ }
+ else if (str2.Equals("HitRange"))
+ {
+ unknown = E繧ｻ繧ｯ繧ｷ繝ｧ繝ｳ遞ｮ蛻･.HitRange;
+ }
+ else if ( str2.Equals( "Log" ) )
+ {
+ unknown = E繧ｻ繧ｯ繧ｷ繝ｧ繝ｳ遞ｮ蛻･.Log;
+ }
+ else if ( str2.Equals( "PlayOption" ) )
+ {
+ unknown = E繧ｻ繧ｯ繧ｷ繝ｧ繝ｳ遞ｮ蛻･.PlayOption;
+ }
+ else if ( str2.Equals( "ViewerOption" ) )
+ {
+ unknown = E繧ｻ繧ｯ繧ｷ繝ｧ繝ｳ遞ｮ蛻･.ViewerOption;
+ }
+ else if ( str2.Equals( "GUID" ) )
+ {
+ unknown = E繧ｻ繧ｯ繧ｷ繝ｧ繝ｳ遞ｮ蛻･.GUID;
+ }
+ else if ( str2.Equals( "DrumsKeyAssign" ) )
+ {
+ unknown = E繧ｻ繧ｯ繧ｷ繝ｧ繝ｳ遞ｮ蛻･.DrumsKeyAssign;
+ }
+ else if ( str2.Equals( "SystemKeyAssign" ) )
+ {
+ unknown = E繧ｻ繧ｯ繧ｷ繝ｧ繝ｳ遞ｮ蛻･.SystemKeyAssign;
+ }
+ else if( str2.Equals( "Temp" ) )
+ {
+ unknown = E繧ｻ繧ｯ繧ｷ繝ｧ繝ｳ遞ｮ蛻･.Temp;
+ }
+ else
+ {
+ unknown = E繧ｻ繧ｯ繧ｷ繝ｧ繝ｳ遞ｮ蛻･.Unknown;
+ }
+ //-----------------------------
+ #endregion
+ }
+ else
+ {
+ string[] strArray = str.Split( new char[] { '=' } );
+ if( strArray.Length == 2 )
+ {
+ str3 = strArray[ 0 ].Trim();
+ str4 = strArray[ 1 ].Trim();
+ switch( unknown )
+ {
+ #region [ [System] ]
+ //-----------------------------
+ case E繧ｻ繧ｯ繧ｷ繝ｧ繝ｳ遞ｮ蛻･.System:
+ {
+#if false // #23625 2011.1.11 Config.ini縺九ｉ繝繝｡繝ｼ繧ｸ/蝗槫ｾｩ蛟､縺ｮ螳壽焚螟画峩繧定｡後≧蝣ｴ蜷医ｯ縺薙％繧呈怏蜉ｹ縺ｫ縺吶ｋ 087繝ｪ繝ｪ繝ｼ繧ｹ縺ｫ蜷医ｏ縺帶ｩ溯ｽ辟｡蜉ｹ蛹
+ //----------------------------------------
+ if (str3.Equals("GaugeFactorD"))
+ {
+ int p = 0;
+ string[] splittedFactor = str4.Split(',');
+ foreach (string s in splittedFactor) {
+ this.fGaugeFactor[p++, 0] = Convert.ToSingle(s);
+ }
+ } else
+ if (str3.Equals("GaugeFactorG"))
+ {
+ int p = 0;
+ string[] splittedFactor = str4.Split(',');
+ foreach (string s in splittedFactor)
+ {
+ this.fGaugeFactor[p++, 1] = Convert.ToSingle(s);
+ }
+ }
+ else
+ if (str3.Equals("DamageFactor"))
+ {
+ int p = 0;
+ string[] splittedFactor = str4.Split(',');
+ foreach (string s in splittedFactor)
+ {
+ this.fDamageLevelFactor[p++] = Convert.ToSingle(s);
+ }
+ }
+ else
+ //----------------------------------------
+#endif
+ #region [ Version ]
+ if ( str3.Equals( "Version" ) )
+ {
+ this.strDTXMania縺ｮ繝舌ｼ繧ｸ繝ｧ繝ｳ = str4;
+ }
+ #endregion
+ #region [ TJAPath ]
+ else if( str3.Equals( "TJAPath" ) )
+ {
+ this.str譖ｲ繝繝ｼ繧ｿ讀懃ｴ｢繝代せ = str4;
+ }
+ #endregion
+ #region [ skin髢｢菫 ]
+ else if ( str3.Equals( "SkinPath" ) )
+ {
+ string absSkinPath = str4;
+ if ( !System.IO.Path.IsPathRooted( str4 ) )
+ {
+ absSkinPath = System.IO.Path.Combine( TJAPlayer3.strEXE縺ｮ縺ゅｋ繝輔か繝ｫ繝, "System" );
+ absSkinPath = System.IO.Path.Combine( absSkinPath, str4 );
+ Uri u = new Uri( absSkinPath );
+ absSkinPath = u.AbsolutePath.ToString(); // str4蜀縺ｫ逶ｸ蟇ｾ繝代せ縺後≠繧句ｴ蜷医↓蛯吶∴繧
+ absSkinPath = System.Web.HttpUtility.UrlDecode( absSkinPath ); // 繝繧ｳ繝ｼ繝峨☆繧
+ absSkinPath = absSkinPath.Replace( '/', System.IO.Path.DirectorySeparatorChar ); // 蛹ｺ蛻繧頑枚蟄励′\縺ｧ縺ｯ縺ｪ縺/縺ｪ縺ｮ縺ｧ鄂ｮ謠帙☆繧
+ }
+ if ( absSkinPath[ absSkinPath.Length - 1 ] != System.IO.Path.DirectorySeparatorChar ) // 繝輔か繝ｫ繝蜷肴忰蟆ｾ縺ｫ\繧貞ｿ縺壹▽縺代※縲，Skin蛛ｴ縺ｨ陦ｨ險倥ｒ邨ｱ荳縺吶ｋ
+ {
+ absSkinPath += System.IO.Path.DirectorySeparatorChar;
+ }
+ this.strSystemSkinSubfolderFullName = absSkinPath;
+ }
+ else if (str3.Equals(nameof(FastRender)))
+ {
+ FastRender = C螟画鋤.bONorOFF(str4[0]);
+ }
+ #endregion
+ #region [ Window髢｢菫 ]
+ else if (str3.Equals("FullScreen"))
+ {
+ this.b蜈ｨ逕ｻ髱｢繝｢繝ｼ繝 = C螟画鋤.bONorOFF(str4[0]);
+ }
+ else if ( str3.Equals( "WindowX" ) ) // #30675 2013.02.04 ikanick add
+ {
+ this.n蛻晄悄繧ｦ繧｣繝ｳ繝峨え髢句ｧ倶ｽ咲ｽｮX = C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ遽蝗ｲ蜀縺ｫ荳ｸ繧√※霑斐☆(
+ str4, 0, System.Windows.Forms.Screen.PrimaryScreen.Bounds.Width - 1 , this.n蛻晄悄繧ｦ繧｣繝ｳ繝峨え髢句ｧ倶ｽ咲ｽｮX );
+ }
+ else if ( str3.Equals( "WindowY" ) ) // #30675 2013.02.04 ikanick add
+ {
+ this.n蛻晄悄繧ｦ繧｣繝ｳ繝峨え髢句ｧ倶ｽ咲ｽｮY = C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ遽蝗ｲ蜀縺ｫ荳ｸ繧√※霑斐☆(
+ str4, 0, System.Windows.Forms.Screen.PrimaryScreen.Bounds.Height - 1 , this.n蛻晄悄繧ｦ繧｣繝ｳ繝峨え髢句ｧ倶ｽ咲ｽｮY );
+ }
+ else if ( str3.Equals( "WindowWidth" ) ) // #23510 2010.10.31 yyagi add
+ {
+ this.n繧ｦ繧､繝ｳ繝峨えwidth = C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ遽蝗ｲ蜀縺ｫ荳ｸ繧√※霑斐☆( str4, 1, 65535, this.n繧ｦ繧､繝ｳ繝峨えwidth );
+ if( this.n繧ｦ繧､繝ｳ繝峨えwidth <= 0 )
+ {
+ this.n繧ｦ繧､繝ｳ繝峨えwidth = SampleFramework.GameWindowSize.Width;
+ }
+ }
+ else if( str3.Equals( "WindowHeight" ) ) // #23510 2010.10.31 yyagi add
+ {
+ this.n繧ｦ繧､繝ｳ繝峨えheight = C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ遽蝗ｲ蜀縺ｫ荳ｸ繧√※霑斐☆( str4, 1, 65535, this.n繧ｦ繧､繝ｳ繝峨えheight );
+ if( this.n繧ｦ繧､繝ｳ繝峨えheight <= 0 )
+ {
+ this.n繧ｦ繧､繝ｳ繝峨えheight = SampleFramework.GameWindowSize.Height;
+ }
+ }
+ else if ( str3.Equals( "DoubleClickFullScreen" ) ) // #26752 2011.11.27 yyagi
+ {
+ this.bIsAllowedDoubleClickFullscreen = C螟画鋤.bONorOFF( str4[ 0 ] );
+ }
+ else if ( str3.Equals( "EnableSystemMenu" ) ) // #28200 2012.5.1 yyagi
+ {
+ this.bIsEnabledSystemMenu = C螟画鋤.bONorOFF( str4[ 0 ] );
+ }
+ else if ( str3.Equals( "BackSleep" ) ) // #23568 2010.11.04 ikanick add
+ {
+ this.n髱槭ヵ繧ｩ繝ｼ繧ｫ繧ｹ譎ゅせ繝ｪ繝ｼ繝洋s = C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ遽蝗ｲ蜀縺ｫ縺｡繧繧薙→荳ｸ繧√※霑斐☆( str4, 0, 50, this.n髱槭ヵ繧ｩ繝ｼ繧ｫ繧ｹ譎ゅせ繝ｪ繝ｼ繝洋s );
+ }
+ #endregion
+
+ #region [ WASAPI/ASIO髢｢菫 ]
+ else if ( str3.Equals( "SoundDeviceType" ) )
+ {
+ this.nSoundDeviceType = C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ遽蝗ｲ蜀縺ｫ荳ｸ繧√※霑斐☆( str4, 0, 2, this.nSoundDeviceType );
+ }
+ else if ( str3.Equals( "WASAPIBufferSizeMs" ) )
+ {
+ this.nWASAPIBufferSizeMs = C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ遽蝗ｲ蜀縺ｫ荳ｸ繧√※霑斐☆( str4, 0, 9999, this.nWASAPIBufferSizeMs );
+ }
+ else if ( str3.Equals( "ASIODevice" ) )
+ {
+ string[] asiodev = CEnumerateAllAsioDevices.GetAllASIODevices();
+ this.nASIODevice = C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ遽蝗ｲ蜀縺ｫ荳ｸ繧√※霑斐☆( str4, 0, asiodev.Length - 1, this.nASIODevice );
+ }
+ //else if ( str3.Equals( "ASIOBufferSizeMs" ) )
+ //{
+ // this.nASIOBufferSizeMs = C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ遽蝗ｲ蜀縺ｫ荳ｸ繧√※霑斐☆( str4, 0, 9999, this.nASIOBufferSizeMs );
+ //}
+ //else if ( str3.Equals( "DynamicBassMixerManagement" ) )
+ //{
+ // this.bDynamicBassMixerManagement = C螟画鋤.bONorOFF( str4[ 0 ] );
+ //}
+ else if ( str3.Equals( "SoundTimerType" ) ) // #33689 2014.6.6 yyagi
+ {
+ this.bUseOSTimer = C螟画鋤.bONorOFF( str4[ 0 ] );
+ }
+ //else if ( str3.Equals( "MasterVolume" ) )
+ //{
+ // this.nMasterVolume = C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ遽蝗ｲ蜀縺ｫ荳ｸ繧√※霑斐☆( str4, 0, 100, this.nMasterVolume );
+ //}
+ #endregion
+
+ #region [ 繝輔か繝ｳ繝 ]
+ else if (str3.Equals("FontName"))
+ {
+ this.FontName = str4;
+ }
+ else if (str3.Equals("BoxFontName"))
+ {
+ this.BoxFontName = str4;
+ }
+ #endregion
+
+ else if ( str3.Equals( "VSyncWait" ) )
+ {
+ this.b蝙ら峩蟶ｰ邱壼ｾ縺｡繧定｡後≧ = C螟画鋤.bONorOFF( str4[ 0 ] );
+ }
+ else if( str3.Equals( "SleepTimePerFrame" ) ) // #23568 2011.11.27 yyagi
+ {
+ this.n繝輔Ξ繝ｼ繝豈弱せ繝ｪ繝ｼ繝洋s = C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ遽蝗ｲ蜀縺ｫ縺｡繧繧薙→荳ｸ繧√※霑斐☆( str4, -1, 50, this.n繝輔Ξ繝ｼ繝豈弱せ繝ｪ繝ｼ繝洋s );
+ }
+ else if( str3.Equals( "BGAlpha" ) )
+ {
+ this.n閭梧勹縺ｮ騾城℃蠎ｦ = C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ遽蝗ｲ蜀縺ｫ荳ｸ繧√※霑斐☆( str4, 0, 0xff, this.n閭梧勹縺ｮ騾城℃蠎ｦ );
+ }
+ else if( str3.Equals( "DamageLevel" ) )
+ {
+ this.e繝繝｡繝ｼ繧ｸ繝ｬ繝吶Ν = (E繝繝｡繝ｼ繧ｸ繝ｬ繝吶Ν) C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ遽蝗ｲ蜀縺ｫ荳ｸ繧√※霑斐☆( str4, 0, 2, (int) this.e繝繝｡繝ｼ繧ｸ繝ｬ繝吶Ν );
+ }
+ else if ( str3.Equals( "StageFailed" ) )
+ {
+ this.bSTAGEFAILED譛牙柑 = C螟画鋤.bONorOFF( str4[ 0 ] );
+ }
+ #region [ AVI/BGA ]
+ else if( str3.Equals( "AVI" ) )
+ {
+ this.bAVI譛牙柑 = C螟画鋤.bONorOFF( str4[ 0 ] );
+ }
+ else if( str3.Equals( "BGA" ) )
+ {
+ this.bBGA譛牙柑 = C螟画鋤.bONorOFF( str4[ 0 ] );
+ }
+ else if( str3.Equals( "ClipDispType" ) )
+ {
+ this.eClipDispType = (EClipDispType)C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ遽蝗ｲ蜀縺ｫ荳ｸ繧√※霑斐☆( str4, 0, 3, (int) this.eClipDispType );
+ }
+ #endregion
+ #region [ 繝励Ξ繝薙Η繝ｼ髻ｳ ]
+ else if( str3.Equals( "PreviewSoundWait" ) )
+ {
+ this.n譖ｲ縺碁∈謚槭＆繧後※縺九ｉ繝励Ξ繝薙Η繝ｼ髻ｳ縺碁ｳｴ繧九∪縺ｧ縺ｮ繧ｦ繧ｧ繧､繝ms = C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ遽蝗ｲ蜀縺ｫ荳ｸ繧√※霑斐☆( str4, 0, 0x5f5e0ff, this.n譖ｲ縺碁∈謚槭＆繧後※縺九ｉ繝励Ξ繝薙Η繝ｼ髻ｳ縺碁ｳｴ繧九∪縺ｧ縺ｮ繧ｦ繧ｧ繧､繝ms );
+ }
+ else if( str3.Equals( "PreviewImageWait" ) )
+ {
+ this.n譖ｲ縺碁∈謚槭＆繧後※縺九ｉ繝励Ξ繝薙Η繝ｼ逕ｻ蜒上′陦ｨ遉ｺ髢句ｧ九＆繧後ｋ縺ｾ縺ｧ縺ｮ繧ｦ繧ｧ繧､繝ms = C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ遽蝗ｲ蜀縺ｫ荳ｸ繧√※霑斐☆( str4, 0, 0x5f5e0ff, this.n譖ｲ縺碁∈謚槭＆繧後※縺九ｉ繝励Ξ繝薙Η繝ｼ逕ｻ蜒上′陦ｨ遉ｺ髢句ｧ九＆繧後ｋ縺ｾ縺ｧ縺ｮ繧ｦ繧ｧ繧､繝ms );
+ }
+ #endregion
+ //else if( str3.Equals( "AdjustWaves" ) )
+ //{
+ // this.bWave蜀咲函菴咲ｽｮ閾ｪ蜍戊ｪｿ謨ｴ讖溯ｽ譛牙柑 = C螟画鋤.bONorOFF( str4[ 0 ] );
+ //}
+ #region [ BGM/繝峨Λ繝縺ｮ繝偵ャ繝磯浹 ]
+ else if( str3.Equals( "BGMSound" ) )
+ {
+ this.bBGM髻ｳ繧堤匱螢ｰ縺吶ｋ = C螟画鋤.bONorOFF( str4[ 0 ] );
+ }
+ #endregion
+ else if( str3.Equals( "SaveScoreIni" ) )
+ {
+ this.bScoreIni繧貞ｺ蜉帙☆繧 = C螟画鋤.bONorOFF( str4[ 0 ] );
+ }
+ else if( str3.Equals( "RandomFromSubBox" ) )
+ {
+ this.b繝ｩ繝ｳ繝繝繧ｻ繝ｬ繧ｯ繝医〒蟄殖OX繧呈､懃ｴ｢蟇ｾ雎｡縺ｨ縺吶ｋ = C螟画鋤.bONorOFF( str4[ 0 ] );
+ }
+ #region [ 繧ｳ繝ｳ繝懈焚 ]
+ else if( str3.Equals( "MinComboDrums" ) )
+ {
+ this.n陦ｨ遉ｺ蜿ｯ閭ｽ縺ｪ譛蟆上さ繝ｳ繝懈焚.Drums = C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ遽蝗ｲ蜀縺ｫ荳ｸ繧√※霑斐☆( str4, 1, 0x1869f, this.n陦ｨ遉ｺ蜿ｯ閭ｽ縺ｪ譛蟆上さ繝ｳ繝懈焚.Drums );
+ }
+ #endregion
+ else if( str3.Equals( "ShowDebugStatus" ) )
+ {
+ this.b貍泌･乗ュ蝣ｱ繧定｡ｨ遉ｺ縺吶ｋ = C螟画鋤.bONorOFF( str4[ 0 ] );
+ }
+ else if( str3.Equals( nameof(ApplyLoudnessMetadata) ) )
+ {
+ this.ApplyLoudnessMetadata = C螟画鋤.bONorOFF( str4[ 0 ] );
+ }
+ else if( str3.Equals( nameof(TargetLoudness) ) )
+ {
+ this.TargetLoudness = C螟画鋤.db蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ遽蝗ｲ蜀縺ｫ荳ｸ繧√※霑斐☆( str4, CSound.MinimumLufs.ToDouble(), CSound.MaximumLufs.ToDouble(), this.TargetLoudness );
+ }
+ else if( str3.Equals( nameof(ApplySongVol) ) )
+ {
+ this.ApplySongVol = C螟画鋤.bONorOFF( str4[ 0 ] );
+ }
+ else if( str3.Equals( nameof(SoundEffectLevel) ) )
+ {
+ this.SoundEffectLevel = C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ遽蝗ｲ蜀縺ｫ荳ｸ繧√※霑斐☆( str4, CSound.MinimumGroupLevel, CSound.MaximumGroupLevel, this.SoundEffectLevel );
+ }
+ else if( str3.Equals( nameof(VoiceLevel) ) )
+ {
+ this.VoiceLevel = C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ遽蝗ｲ蜀縺ｫ荳ｸ繧√※霑斐☆( str4, CSound.MinimumGroupLevel, CSound.MaximumGroupLevel, this.VoiceLevel );
+ }
+ else if( str3.Equals( nameof(SongPreviewLevel) ) )
+ {
+ this.SongPreviewLevel = C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ遽蝗ｲ蜀縺ｫ荳ｸ繧√※霑斐☆( str4, CSound.MinimumGroupLevel, CSound.MaximumGroupLevel, this.SongPreviewLevel );
+ }
+ else if( str3.Equals( nameof(KeyboardSoundLevelIncrement) ) )
+ {
+ this.KeyboardSoundLevelIncrement = C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ遽蝗ｲ蜀縺ｫ荳ｸ繧√※霑斐☆( str4, MinimumKeyboardSoundLevelIncrement, MaximumKeyboardSoundLevelIncrement, this.KeyboardSoundLevelIncrement );
+ }
+ else if( str3.Equals(nameof(MusicPreTimeMs)))
+ {
+ MusicPreTimeMs = int.Parse(str4);
+ }
+ else if( str3.Equals( "StoicMode" ) )
+ {
+ this.b繧ｹ繝医う繝繧ｯ繝｢繝ｼ繝 = C螟画鋤.bONorOFF( str4[ 0 ] );
+ }
+ else if ( str3.Equals( "JudgeDispPriority" ) )
+ {
+ this.e蛻､螳夊｡ｨ遉ｺ蜆ｪ蜈亥ｺｦ = (E蛻､螳夊｡ｨ遉ｺ蜆ｪ蜈亥ｺｦ) C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ遽蝗ｲ蜀縺ｫ荳ｸ繧√※霑斐☆( str4, 0, 1, (int) this.e蛻､螳夊｡ｨ遉ｺ蜆ｪ蜈亥ｺｦ );
+ }
+ else if ( str3.Equals( "AutoResultCapture" ) ) // #25399 2011.6.9 yyagi
+ {
+ this.bIsAutoResultCapture = C螟画鋤.bONorOFF( str4[ 0 ] );
+ }
+ else if (str3.Equals(nameof(SendDiscordPlayingInformation)))
+ {
+ SendDiscordPlayingInformation = C螟画鋤.bONorOFF(str4[0]);
+ }
+ else if ( str3.Equals( "TimeStretch" ) ) // #23664 2013.2.24 yyagi
+ {
+ this.bTimeStretch = C螟画鋤.bONorOFF( str4[ 0 ] );
+ }
+ #region [ AdjustTime ]
+ else if( str3.Equals( "InputAdjustTime" ) )
+ {
+ this.nInputAdjustTimeMs = C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ遽蝗ｲ蜀縺ｫ荳ｸ繧√※霑斐☆( str4, -99, 99, this.nInputAdjustTimeMs );
+ }
+ else if ( str3.Equals( "JudgeLinePosOffsetDrums" ) ) // #31602 2013.6.23 yyagi
+ {
+ this.nJudgeLinePosOffset.Drums = C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ遽蝗ｲ蜀縺ｫ荳ｸ繧√※霑斐☆( str4, -99, 99, this.nJudgeLinePosOffset.Drums );
+ }
+ else if ( str3.Equals( "JudgeLinePosOffsetGuitar" ) ) // #31602 2013.6.23 yyagi
+ {
+ this.nJudgeLinePosOffset.Guitar = C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ遽蝗ｲ蜀縺ｫ荳ｸ繧√※霑斐☆( str4, -99, 99, this.nJudgeLinePosOffset.Guitar );
+ }
+ else if ( str3.Equals( "JudgeLinePosOffsetBass" ) ) // #31602 2013.6.23 yyagi
+ {
+ this.nJudgeLinePosOffset.Bass = C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ遽蝗ｲ蜀縺ｫ荳ｸ繧√※霑斐☆( str4, -99, 99, this.nJudgeLinePosOffset.Bass );
+ }
+ else if ( str3.Equals( "JudgeLinePosModeGuitar" ) ) // #33891 2014.6.26 yyagi
+ {
+ this.e蛻､螳壻ｽ咲ｽｮ.Guitar = (E蛻､螳壻ｽ咲ｽｮ) C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ遽蝗ｲ蜀縺ｫ荳ｸ繧√※霑斐☆( str4, 0, 2, (int) this.e蛻､螳壻ｽ咲ｽｮ.Guitar );
+ }
+ else if ( str3.Equals( "JudgeLinePosModeBass" ) ) // #33891 2014.6.26 yyagi
+ {
+ this.e蛻､螳壻ｽ咲ｽｮ.Bass = (E蛻､螳壻ｽ咲ｽｮ) C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ遽蝗ｲ蜀縺ｫ荳ｸ繧√※霑斐☆( str4, 0, 2, (int) this.e蛻､螳壻ｽ咲ｽｮ.Bass );
+ }
+ #endregion
+ else if( str3.Equals( "BufferedInput" ) )
+ {
+ this.b繝舌ャ繝輔ぃ蜈･蜉帙ｒ陦後≧ = C螟画鋤.bONorOFF( str4[ 0 ] );
+ }
+ else if ( str3.Equals( "PolyphonicSounds" ) ) // #28228 2012.5.1 yyagi
+ {
+ this.nPoliphonicSounds = C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ遽蝗ｲ蜀縺ｫ荳ｸ繧√※霑斐☆( str4, 1, 8, this.nPoliphonicSounds );
+ }
+ #region [ VelocityMin ]
+ else if ( str3.Equals( "LCVelocityMin" ) ) // #23857 2010.12.12 yyagi
+ {
+ this.nVelocityMin.LC = C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ遽蝗ｲ蜀縺ｫ荳ｸ繧√※霑斐☆( str4, 0, 127, this.nVelocityMin.LC );
+ }
+ else if( str3.Equals( "HHVelocityMin" ) )
+ {
+ this.nVelocityMin.HH = C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ遽蝗ｲ蜀縺ｫ荳ｸ繧√※霑斐☆( str4, 0, 127, this.nVelocityMin.HH );
+ }
+ else if( str3.Equals( "SDVelocityMin" ) ) // #23857 2011.1.31 yyagi
+ {
+ this.nVelocityMin.SD = C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ遽蝗ｲ蜀縺ｫ荳ｸ繧√※霑斐☆( str4, 0, 127, this.nVelocityMin.SD );
+ }
+ else if( str3.Equals( "BDVelocityMin" ) ) // #23857 2011.1.31 yyagi
+ {
+ this.nVelocityMin.BD = C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ遽蝗ｲ蜀縺ｫ荳ｸ繧√※霑斐☆( str4, 0, 127, this.nVelocityMin.BD );
+ }
+ else if( str3.Equals( "HTVelocityMin" ) ) // #23857 2011.1.31 yyagi
+ {
+ this.nVelocityMin.HT = C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ遽蝗ｲ蜀縺ｫ荳ｸ繧√※霑斐☆( str4, 0, 127, this.nVelocityMin.HT );
+ }
+ else if( str3.Equals( "LTVelocityMin" ) ) // #23857 2011.1.31 yyagi
+ {
+ this.nVelocityMin.LT = C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ遽蝗ｲ蜀縺ｫ荳ｸ繧√※霑斐☆( str4, 0, 127, this.nVelocityMin.LT );
+ }
+ else if( str3.Equals( "FTVelocityMin" ) ) // #23857 2011.1.31 yyagi
+ {
+ this.nVelocityMin.FT = C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ遽蝗ｲ蜀縺ｫ荳ｸ繧√※霑斐☆( str4, 0, 127, this.nVelocityMin.FT );
+ }
+ else if( str3.Equals( "CYVelocityMin" ) ) // #23857 2011.1.31 yyagi
+ {
+ this.nVelocityMin.CY = C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ遽蝗ｲ蜀縺ｫ荳ｸ繧√※霑斐☆( str4, 0, 127, this.nVelocityMin.CY );
+ }
+ else if( str3.Equals( "RDVelocityMin" ) ) // #23857 2011.1.31 yyagi
+ {
+ this.nVelocityMin.RD = C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ遽蝗ｲ蜀縺ｫ荳ｸ繧√※霑斐☆( str4, 0, 127, this.nVelocityMin.RD );
+ }
+ #endregion
+ //else if ( str3.Equals( "NoMP3Streaming" ) )
+ //{
+ // this.bNoMP3Streaming = C螟画鋤.bONorOFF( str4[ 0 ] );
+ //}
+ #region[ Ver.K霑ｽ蜉 ]
+ else if ( str3.Equals( "DirectShowMode" ) ) // #28228 2012.5.1 yyagi
+ {
+ this.bDirectShowMode = C螟画鋤.bONorOFF( str4[ 0 ] ); ;
+ }
+ #endregion
+ else if( str3.Equals( "EndingAnime" ) )
+ {
+ this.bEndingAnime = C螟画鋤.bONorOFF( str4[ 0 ] );
+ }
+
+ continue;
+ }
+ //-----------------------------
+ #endregion
+
+ #region [ [AutoPlay] ]
+ //-----------------------------
+ case E繧ｻ繧ｯ繧ｷ繝ｧ繝ｳ遞ｮ蛻･.AutoPlay:
+ if (str3.Equals("Taiko"))
+ {
+ this.b螟ｪ鮠薙ヱ繝ｼ繝AutoPlay = C螟画鋤.bONorOFF(str4[0]);
+ }
+ else if (str3.Equals("Taiko2P"))
+ {
+ this.b螟ｪ鮠薙ヱ繝ｼ繝AutoPlay2P = C螟画鋤.bONorOFF(str4[0]);
+ }
+ else if (str3.Equals("TaikoAutoRoll"))
+ {
+ this.bAuto蜈育函縺ｮ騾｣謇 = C螟画鋤.bONorOFF(str4[0]);
+ }
+ continue;
+ //-----------------------------
+ #endregion
+
+ #region [ [HitRange] ]
+ //-----------------------------
+ case E繧ｻ繧ｯ繧ｷ繝ｧ繝ｳ遞ｮ蛻･.HitRange:
+ if (str3.Equals("Perfect"))
+ {
+ this.n繝偵ャ繝育ｯ蝗ｲms.Perfect = C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ遽蝗ｲ蜀縺ｫ荳ｸ繧√※霑斐☆(str4, 0, 0x3e7, this.n繝偵ャ繝育ｯ蝗ｲms.Perfect);
+ }
+ else if (str3.Equals("Great"))
+ {
+ this.n繝偵ャ繝育ｯ蝗ｲms.Great = C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ遽蝗ｲ蜀縺ｫ荳ｸ繧√※霑斐☆(str4, 0, 0x3e7, this.n繝偵ャ繝育ｯ蝗ｲms.Great);
+ }
+ else if (str3.Equals("Good"))
+ {
+ this.n繝偵ャ繝育ｯ蝗ｲms.Good = C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ遽蝗ｲ蜀縺ｫ荳ｸ繧√※霑斐☆(str4, 0, 0x3e7, this.n繝偵ャ繝育ｯ蝗ｲms.Good);
+ }
+ else if (str3.Equals("Poor"))
+ {
+ this.n繝偵ャ繝育ｯ蝗ｲms.Poor = C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ遽蝗ｲ蜀縺ｫ荳ｸ繧√※霑斐☆(str4, 0, 0x3e7, this.n繝偵ャ繝育ｯ蝗ｲms.Poor);
+ }
+ continue;
+ //-----------------------------
+ #endregion
+
+
+
+ #region [ [Log] ]
+ //-----------------------------
+ case E繧ｻ繧ｯ繧ｷ繝ｧ繝ｳ遞ｮ蛻･.Log:
+ {
+ if( str3.Equals( "OutputLog" ) )
+ {
+ this.b繝ｭ繧ｰ蜃ｺ蜉 = C螟画鋤.bONorOFF( str4[ 0 ] );
+ }
+ else if( str3.Equals( "TraceCreatedDisposed" ) )
+ {
+ this.bLog菴懈占ｧ｣謾ｾ繝ｭ繧ｰ蜃ｺ蜉 = C螟画鋤.bONorOFF( str4[ 0 ] );
+ }
+ else if( str3.Equals( "TraceDTXDetails" ) )
+ {
+ this.bLogDTX隧ｳ邏ｰ繝ｭ繧ｰ蜃ｺ蜉 = C螟画鋤.bONorOFF( str4[ 0 ] );
+ }
+ else if( str3.Equals( "TraceSongSearch" ) )
+ {
+ this.bLog譖ｲ讀懃ｴ｢繝ｭ繧ｰ蜃ｺ蜉 = C螟画鋤.bONorOFF( str4[ 0 ] );
+ }
+ continue;
+ }
+ //-----------------------------
+ #endregion
+
+ #region [ [PlayOption] ]
+ //-----------------------------
+ case E繧ｻ繧ｯ繧ｷ繝ｧ繝ｳ遞ｮ蛻･.PlayOption:
+ {
+ if (str3.Equals("ShowChara"))
+ {
+ ShowChara = C螟画鋤.bONorOFF(str4[0]);
+ }
+ else if( str3.Equals("ShowDancer"))
+ {
+ ShowDancer = C螟画鋤.bONorOFF(str4[0]);
+ }
+ else if (str3.Equals("ShowRunner"))
+ {
+ ShowRunner = C螟画鋤.bONorOFF(str4[0]);
+ }
+ else if (str3.Equals("ShowMob"))
+ {
+ ShowMob = C螟画鋤.bONorOFF(str4[0]);
+ }
+ else if (str3.Equals("ShowFooter"))
+ {
+ ShowFooter = C螟画鋤.bONorOFF(str4[0]);
+ }
+ else if (str3.Equals("ShowPuchiChara"))
+ {
+ ShowPuchiChara = C螟画鋤.bONorOFF(str4[0]);
+ }
+ else if( str3.Equals( "Dark" ) )
+ {
+ this.eDark = (E繝繝ｼ繧ｯ繝｢繝ｼ繝) C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ遽蝗ｲ蜀縺ｫ荳ｸ繧√※霑斐☆( str4, 0, 2, (int) this.eDark );
+ }
+ else if( str3.Equals( "ScrollMode" ) )
+ {
+ this.eScrollMode = ( EScrollMode )C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ遽蝗ｲ蜀縺ｫ荳ｸ繧√※霑斐☆( str4, 0, 2, 0 );
+ }
+ else if (str3.Equals("EnableCountDownTimer"))
+ {
+ this.bEnableCountdownTimer = C螟画鋤.bONorOFF(str4[0]);
+ }
+ #region [ Sudden ]
+ else if( str3.Equals( "DrumsSudden" ) )
+ {
+ this.bSudden.Drums = C螟画鋤.bONorOFF( str4[ 0 ] );
+ }
+ #endregion
+ #region [ Hidden ]
+ else if( str3.Equals( "DrumsHidden" ) )
+ {
+ this.bHidden.Drums = C螟画鋤.bONorOFF( str4[ 0 ] );
+ }
+ #endregion
+ #region [ Invisible ]
+ else if ( str3.Equals( "DrumsInvisible" ) )
+ {
+ this.eInvisible.Drums = (EInvisible) C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ遽蝗ｲ蜀縺ｫ荳ｸ繧√※霑斐☆( str4, 0, 2, (int) this.eInvisible.Drums );
+ }
+ //else if ( str3.Equals( "InvisibleDisplayTimeMs" ) )
+ //{
+ // this.nDisplayTimesMs = C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ遽蝗ｲ蜀縺ｫ荳ｸ繧√※霑斐☆( str4, 0, 9999999, (int) this.nDisplayTimesMs );
+ //}
+ //else if ( str3.Equals( "InvisibleFadeoutTimeMs" ) )
+ //{
+ // this.nFadeoutTimeMs = C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ遽蝗ｲ蜀縺ｫ荳ｸ繧√※霑斐☆( str4, 0, 9999999, (int) this.nFadeoutTimeMs );
+ //}
+ #endregion
+ else if ( str3.Equals( "DrumsReverse" ) )
+ {
+ this.bReverse.Drums = C螟画鋤.bONorOFF( str4[ 0 ] );
+ }
+ else if( str3.Equals( "DrumsPosition" ) )
+ {
+ this.蛻､螳壽枚蟄苓｡ｨ遉ｺ菴咲ｽｮ.Drums = (E蛻､螳壽枚蟄苓｡ｨ遉ｺ菴咲ｽｮ) C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ遽蝗ｲ蜀縺ｫ荳ｸ繧√※霑斐☆( str4, 0, 2, (int) this.蛻､螳壽枚蟄苓｡ｨ遉ｺ菴咲ｽｮ.Drums );
+ }
+ else if( str3.Equals( "DrumsScrollSpeed" ) )
+ {
+ this.n隴憺擇繧ｹ繧ｯ繝ｭ繝ｼ繝ｫ騾溷ｺｦ.Drums = C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ遽蝗ｲ蜀縺ｫ荳ｸ繧√※霑斐☆( str4, 0, 0x7cf, this.n隴憺擇繧ｹ繧ｯ繝ｭ繝ｼ繝ｫ騾溷ｺｦ.Drums );
+ }
+ else if( str3.Equals( "PlaySpeed" ) )
+ {
+ this.n貍泌･城溷ｺｦ = C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ遽蝗ｲ蜀縺ｫ荳ｸ繧√※霑斐☆( str4, 5, 400, this.n貍泌･城溷ｺｦ );
+ }
+ else if (str3.Equals("PlaySpeedNotEqualOneNoSound"))
+ {
+ this.b貍泌･城溷ｺｦ縺御ｸ蛟埼溘〒縺ゅｋ縺ｨ縺堺ｻ･螟夜浹螢ｰ繧貞咲函縺励↑縺 = C螟画鋤.bONorOFF(str4[0]);
+ }
+ //else if ( str3.Equals( "JudgeDispPriorityDrums" ) )
+ //{
+ // this.e蛻､螳夊｡ｨ遉ｺ蜆ｪ蜈亥ｺｦ.Drums = (E蛻､螳夊｡ｨ遉ｺ蜆ｪ蜈亥ｺｦ) C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ遽蝗ｲ蜀縺ｫ荳ｸ繧√※霑斐☆( str4, 0, 1, (int) this.e蛻､螳夊｡ｨ遉ｺ蜆ｪ蜈亥ｺｦ.Drums );
+ //}
+ //else if ( str3.Equals( "JudgeDispPriorityGuitar" ) )
+ //{
+ // this.e蛻､螳夊｡ｨ遉ｺ蜆ｪ蜈亥ｺｦ.Guitar = (E蛻､螳夊｡ｨ遉ｺ蜆ｪ蜈亥ｺｦ) C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ遽蝗ｲ蜀縺ｫ荳ｸ繧√※霑斐☆( str4, 0, 1, (int) this.e蛻､螳夊｡ｨ遉ｺ蜆ｪ蜈亥ｺｦ.Guitar );
+ //}
+ //else if ( str3.Equals( "JudgeDispPriorityBass" ) )
+ //{
+ // this.e蛻､螳夊｡ｨ遉ｺ蜆ｪ蜈亥ｺｦ.Bass = (E蛻､螳夊｡ｨ遉ｺ蜆ｪ蜈亥ｺｦ) C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ遽蝗ｲ蜀縺ｫ荳ｸ繧√※霑斐☆( str4, 0, 1, (int) this.e蛻､螳夊｡ｨ遉ｺ蜆ｪ蜈亥ｺｦ.Bass );
+ //}
+ else if ( str3.Equals( "Risky" ) ) // #23559 2011.6.23 yyagi
+ {
+ this.nRisky = C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ遽蝗ｲ蜀縺ｫ荳ｸ繧√※霑斐☆( str4, 0, 10, this.nRisky );
+ }
+ else if ( str3.Equals( "DrumsTight" ) )
+ {
+ this.bTight = C螟画鋤.bONorOFF( str4[ 0 ] );
+ }
+ else if ( str3.Equals( "BranchGuide" ) )
+ {
+ this.bBranchGuide = C螟画鋤.bONorOFF( str4[ 0 ] );
+ }
+ else if ( str3.Equals( "DefaultCourse" ) ) //2017.01.30 DD
+ {
+ this.nDefaultCourse = C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ遽蝗ｲ蜀縺ｫ荳ｸ繧√※霑斐☆( str4, 0, 4, this.nDefaultCourse );
+ }
+ else if ( str3.Equals( "ScoreMode" ) )
+ {
+ this.nScoreMode = C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ遽蝗ｲ蜀縺ｫ荳ｸ繧√※霑斐☆( str4, 0, 3, this.nScoreMode );
+ }
+ else if ( str3.Equals( "HispeedRandom" ) )
+ {
+ this.bHispeedRandom = C螟画鋤.bONorOFF( str4[ 0 ] );
+ }
+ else if ( str3.Equals( "BigNotesWaitTime" ) )
+ {
+ this.n荳｡謇句愛螳壹ｮ蠕縺｡譎る俣 = C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ遽蝗ｲ蜀縺ｫ荳ｸ繧√※霑斐☆( str4, 1, 100, this.n荳｡謇句愛螳壹ｮ蠕縺｡譎る俣 );
+ }
+ else if ( str3.Equals( "BigNotesJudge" ) )
+ {
+ this.b螟ｧ髻ｳ隨ｦ蛻､螳 = C螟画鋤.bONorOFF( str4[ 0 ] );
+ }
+ else if ( str3.Equals( "BranchAnime" ) )
+ {
+ this.nBranchAnime = C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ遽蝗ｲ蜀縺ｫ荳ｸ繧√※霑斐☆( str4, 0, 1, this.nBranchAnime );
+ }
+ else if ( str3.Equals( "NoInfo" ) )
+ {
+ this.bNoInfo = C螟画鋤.bONorOFF( str4[ 0 ] );
+ }
+ else if ( str3.Equals( "DefaultSongSort" ) )
+ {
+ this.nDefaultSongSort = C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ遽蝗ｲ蜀縺ｫ荳ｸ繧√※霑斐☆( str4, 0, 2, this.nDefaultSongSort );
+ }
+ else if( str3.Equals( "TaikoRandom" ) )
+ {
+ this.eRandom.Taiko = (E繝ｩ繝ｳ繝繝繝｢繝ｼ繝) C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ遽蝗ｲ蜀縺ｫ荳ｸ繧√※霑斐☆( str4, 0, 4, (int) this.eRandom.Taiko );
+ }
+ else if( str3.Equals( "TaikoStealth" ) )
+ {
+ this.eSTEALTH = (E繧ｹ繝繝ｫ繧ｹ繝｢繝ｼ繝) C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ遽蝗ｲ蜀縺ｫ荳ｸ繧√※霑斐☆( str4, 0, 3, (int) this.eSTEALTH );
+ }
+ else if( str3.Equals( "GameMode" ) )
+ {
+ this.eGameMode = (EGame) C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ遽蝗ｲ蜀縺ｫ荳ｸ繧√※霑斐☆( str4, 0, 2, (int) this.eGameMode );
+ }
+ else if (str3.Equals("TokkunSkipMeasures"))
+ {
+ this.TokkunSkipMeasures = C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ遽蝗ｲ蜀縺ｫ荳ｸ繧√※霑斐☆(str4, 0, 9999, this.TokkunSkipMeasures);
+ }
+ else if (str3.Equals(nameof(TokkunMashInterval)))
+ {
+ this.TokkunMashInterval = C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ遽蝗ｲ蜀縺ｫ荳ｸ繧√※霑斐☆(str4, 0, 9999, this.TokkunMashInterval);
+ }
+ else if( str3.Equals( "JudgeCountDisplay" ) )
+ {
+ this.bJudgeCountDisplay = C螟画鋤.bONorOFF( str4[ 0 ] );
+ }
+ else if( str3.Equals( "Just" ) )
+ {
+ this.bJust = C螟画鋤.bONorOFF( str4[ 0 ] );
+ }
+ else if( str3.Equals( "PlayerCount" ) )
+ {
+ this.nPlayerCount = C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ遽蝗ｲ蜀縺ｫ荳ｸ繧√※霑斐☆( str4, 1, 2, this.nPlayerCount );
+ }
+ else if(str3.Equals(nameof(ShinuchiMode)))
+ {
+ ShinuchiMode = C螟画鋤.bONorOFF(str4[0]);
+ }
+ continue;
+ }
+ //-----------------------------
+ #endregion
+
+ #region [ [ViewerOption] ]
+ //-----------------------------
+ case E繧ｻ繧ｯ繧ｷ繝ｧ繝ｳ遞ｮ蛻･.ViewerOption:
+ {
+ if ( str3.Equals( "ViewerDrumsScrollSpeed" ) )
+ {
+ this.nViewerScrollSpeed.Drums = C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ遽蝗ｲ蜀縺ｫ荳ｸ繧√※霑斐☆( str4, 0, 1999, this.nViewerScrollSpeed.Drums );
+ }
+ else if ( str3.Equals( "ViewerGuitarScrollSpeed" ) )
+ {
+ this.nViewerScrollSpeed.Guitar = C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ遽蝗ｲ蜀縺ｫ荳ｸ繧√※霑斐☆( str4, 0, 1999, this.nViewerScrollSpeed.Guitar );
+ }
+ else if ( str3.Equals( "ViewerBassScrollSpeed" ) )
+ {
+ this.nViewerScrollSpeed.Bass = C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ遽蝗ｲ蜀縺ｫ荳ｸ繧√※霑斐☆( str4, 0, 1999, this.nViewerScrollSpeed.Bass );
+ }
+ else if ( str3.Equals( "ViewerVSyncWait" ) )
+ {
+ this.bViewerVSyncWait = C螟画鋤.bONorOFF( str4[ 0 ] );
+ }
+ else if ( str3.Equals( "ViewerShowDebugStatus" ) )
+ {
+ this.bViewerShowDebugStatus = C螟画鋤.bONorOFF( str4[ 0 ] );
+ }
+ else if ( str3.Equals( "ViewerTimeStretch" ) )
+ {
+ this.bViewerTimeStretch = C螟画鋤.bONorOFF( str4[ 0 ] );
+ }
+ else if ( str3.Equals( "ViewerGuitar" ) )
+ {
+ this.bViewerGuitar譛牙柑 = C螟画鋤.bONorOFF( str4[ 0 ] );
+ }
+ else if ( str3.Equals( "ViewerDrums" ) )
+ {
+ this.bViewerDrums譛牙柑 = C螟画鋤.bONorOFF( str4[ 0 ] );
+ }
+ continue;
+ }
+ //-----------------------------
+ #endregion
+
+ #region [ [GUID] ]
+ //-----------------------------
+ case E繧ｻ繧ｯ繧ｷ繝ｧ繝ｳ遞ｮ蛻･.GUID:
+ if( str3.Equals( "JoystickID" ) )
+ {
+ this.tJoystickID縺ｮ蜿門ｾ( str4 );
+ }
+ continue;
+ //-----------------------------
+ #endregion
+
+ #region [ [DrumsKeyAssign] ]
+ //-----------------------------
+ case E繧ｻ繧ｯ繧ｷ繝ｧ繝ｳ遞ｮ蛻･.DrumsKeyAssign:
+ {
+ if( str3.Equals( "LeftRed" ) )
+ {
+ this.t繧ｭ繝ｼ縺ｮ隱ｭ縺ｿ蜃ｺ縺励→險ｭ螳( str4, this.KeyAssign.Drums.LeftRed );
+ }
+ else if( str3.Equals( "RightRed" ) )
+ {
+ this.t繧ｭ繝ｼ縺ｮ隱ｭ縺ｿ蜃ｺ縺励→險ｭ螳( str4, this.KeyAssign.Drums.RightRed );
+ }
+ else if( str3.Equals( "LeftBlue" ) ) // #27029 2012.1.4 from
+ { //
+ this.t繧ｭ繝ｼ縺ｮ隱ｭ縺ｿ蜃ｺ縺励→險ｭ螳( str4, this.KeyAssign.Drums.LeftBlue ); //
+ } //
+ else if( str3.Equals( "RightBlue" ) ) // #27029 2012.1.4 from
+ { //
+ this.t繧ｭ繝ｼ縺ｮ隱ｭ縺ｿ蜃ｺ縺励→險ｭ螳( str4, this.KeyAssign.Drums.RightBlue ); //
+ }
+
+ else if( str3.Equals( "LeftRed2P" ) )
+ {
+ this.t繧ｭ繝ｼ縺ｮ隱ｭ縺ｿ蜃ｺ縺励→險ｭ螳( str4, this.KeyAssign.Drums.LeftRed2P );
+ }
+ else if( str3.Equals( "RightRed2P" ) )
+ {
+ this.t繧ｭ繝ｼ縺ｮ隱ｭ縺ｿ蜃ｺ縺励→險ｭ螳( str4, this.KeyAssign.Drums.RightRed2P );
+ }
+ else if( str3.Equals( "LeftBlue2P" ) ) // #27029 2012.1.4 from
+ { //
+ this.t繧ｭ繝ｼ縺ｮ隱ｭ縺ｿ蜃ｺ縺励→險ｭ螳( str4, this.KeyAssign.Drums.LeftBlue2P ); //
+ } //
+ else if( str3.Equals( "RightBlue2P" ) ) // #27029 2012.1.4 from
+ { //
+ this.t繧ｭ繝ｼ縺ｮ隱ｭ縺ｿ蜃ｺ縺励→險ｭ螳( str4, this.KeyAssign.Drums.RightBlue2P ); //
+ }
+
+ continue;
+ }
+ //-----------------------------
+ #endregion
+
+ #region [ [SystemKeyAssign] ]
+ //-----------------------------
+ case E繧ｻ繧ｯ繧ｷ繝ｧ繝ｳ遞ｮ蛻･.SystemKeyAssign:
+ if( str3.Equals( "Capture" ) )
+ {
+ this.t繧ｭ繝ｼ縺ｮ隱ｭ縺ｿ蜃ｺ縺励→險ｭ螳( str4, this.KeyAssign.System.Capture );
+ }
+ continue;
+ //-----------------------------
+ #endregion
+ }
+ }
+ }
+ continue;
+ }
+ catch ( Exception exception )
+ {
+ Trace.TraceError( exception.ToString() );
+ Trace.TraceError( "萓句､悶′逋ｺ逕溘＠縺ｾ縺励◆縺悟ｦ逅繧堤ｶ咏ｶ壹＠縺ｾ縺吶 (93c4c5cd-4996-4e8c-a82f-a179ff590b44)" );
+ continue;
+ }
+ }
+ }
+ }
+
+ ///
+ /// 繧ｮ繧ｿ繝ｼ縺ｨ繝吶ｼ繧ｹ縺ｮ繧ｭ繝ｼ繧｢繧ｵ繧､繝ｳ蜈･繧梧崛縺
+ ///
+ //public void SwapGuitarBassKeyAssign() // #24063 2011.1.16 yyagi
+ //{
+ // for ( int j = 0; j <= (int)EKeyConfigPad.Capture; j++ )
+ // {
+ // CKeyAssign.STKEYASSIGN t; //= new CConfigIni.CKeyAssign.STKEYASSIGN();
+ // for ( int k = 0; k < 16; k++ )
+ // {
+ // t = this.KeyAssign[ (int)EKeyConfigPart.GUITAR ][ j ][ k ];
+ // this.KeyAssign[ (int)EKeyConfigPart.GUITAR ][ j ][ k ] = this.KeyAssign[ (int)EKeyConfigPart.BASS ][ j ][ k ];
+ // this.KeyAssign[ (int)EKeyConfigPart.BASS ][ j ][ k ] = t;
+ // }
+ // }
+ // this.bIsSwappedGuitarBass = !bIsSwappedGuitarBass;
+ //}
+
+
+ // 縺昴ｮ莉
+
+ #region [ private ]
+ //-----------------
+ private enum E繧ｻ繧ｯ繧ｷ繝ｧ繝ｳ遞ｮ蛻･
+ {
+ Unknown,
+ System,
+ Log,
+ PlayOption,
+ ViewerOption,
+ AutoPlay,
+ HitRange,
+ GUID,
+ DrumsKeyAssign,
+ SystemKeyAssign,
+ Temp,
+ }
+
+ private bool _bDrums譛牙柑;
+ private bool _bGuitar譛牙柑;
+ private bool bConfigIni縺悟ｭ伜惠縺励※縺繧;
+ private string ConfigIni繝輔ぃ繧､繝ｫ蜷;
+
+ private void tJoystickID縺ｮ蜿門ｾ( string str繧ｭ繝ｼ險倩ｿｰ )
+ {
+ string[] strArray = str繧ｭ繝ｼ險倩ｿｰ.Split( new char[] { ',' } );
+ if( strArray.Length >= 2 )
+ {
+ int result = 0;
+ if( ( int.TryParse( strArray[ 0 ], out result ) && ( result >= 0 ) ) && ( result <= 9 ) )
+ {
+ if( this.dicJoystick.ContainsKey( result ) )
+ {
+ this.dicJoystick.Remove( result );
+ }
+ this.dicJoystick.Add( result, strArray[ 1 ] );
+ }
+ }
+ }
+ private void t繧ｭ繝ｼ繧｢繧ｵ繧､繝ｳ繧貞ｨ驛ｨ繧ｯ繝ｪ繧｢縺吶ｋ()
+ {
+ this.KeyAssign = new CKeyAssign();
+ for( int i = 0; i <= (int)EKeyConfigPart.SYSTEM; i++ )
+ {
+ for( int j = 0; j <= (int)EKeyConfigPad.Capture; j++ )
+ {
+ this.KeyAssign[ i ][ j ] = new CKeyAssign.STKEYASSIGN[ 16 ];
+ for( int k = 0; k < 16; k++ )
+ {
+ this.KeyAssign[ i ][ j ][ k ] = new CKeyAssign.STKEYASSIGN( E蜈･蜉帙ョ繝舌う繧ｹ.荳肴, 0, 0 );
+ }
+ }
+ }
+ }
+ private void t繧ｭ繝ｼ縺ｮ譖ｸ縺榊ｺ縺( StreamWriter sw, CKeyAssign.STKEYASSIGN[] assign )
+ {
+ bool flag = true;
+ for( int i = 0; i < 0x10; i++ )
+ {
+ if( assign[ i ].蜈･蜉帙ョ繝舌う繧ｹ == E蜈･蜉帙ョ繝舌う繧ｹ.荳肴 )
+ {
+ continue;
+ }
+ if( !flag )
+ {
+ sw.Write( ',' );
+ }
+ flag = false;
+ switch( assign[ i ].蜈･蜉帙ョ繝舌う繧ｹ )
+ {
+ case E蜈･蜉帙ョ繝舌う繧ｹ.繧ｭ繝ｼ繝懊ｼ繝:
+ sw.Write( 'K' );
+ break;
+
+ case E蜈･蜉帙ョ繝舌う繧ｹ.MIDI蜈･蜉:
+ sw.Write( 'M' );
+ break;
+
+ case E蜈･蜉帙ョ繝舌う繧ｹ.繧ｸ繝ｧ繧､繝代ャ繝:
+ sw.Write( 'J' );
+ break;
+
+ case E蜈･蜉帙ョ繝舌う繧ｹ.繝槭え繧ｹ:
+ sw.Write( 'N' );
+ break;
+ }
+ sw.Write( "{0}{1}", "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ".Substring( assign[ i ].ID, 1 ), assign[ i ].繧ｳ繝ｼ繝 ); // #24166 2011.1.15 yyagi: to support ID > 10, change 2nd character from Decimal to 36-numeral system. (e.g. J1023 -> JA23)
+ }
+ }
+ private void t繧ｭ繝ｼ縺ｮ隱ｭ縺ｿ蜃ｺ縺励→險ｭ螳( string str繧ｭ繝ｼ險倩ｿｰ, CKeyAssign.STKEYASSIGN[] assign )
+ {
+ string[] strArray = str繧ｭ繝ｼ險倩ｿｰ.Split( new char[] { ',' } );
+ for( int i = 0; ( i < strArray.Length ) && ( i < 0x10 ); i++ )
+ {
+ E蜈･蜉帙ョ繝舌う繧ｹ e蜈･蜉帙ョ繝舌う繧ｹ;
+ int id;
+ int code;
+ string str = strArray[ i ].Trim().ToUpper();
+ if ( str.Length >= 3 )
+ {
+ e蜈･蜉帙ョ繝舌う繧ｹ = E蜈･蜉帙ョ繝舌う繧ｹ.荳肴;
+ switch ( str[ 0 ] )
+ {
+ case 'J':
+ e蜈･蜉帙ョ繝舌う繧ｹ = E蜈･蜉帙ョ繝舌う繧ｹ.繧ｸ繝ｧ繧､繝代ャ繝;
+ break;
+
+ case 'K':
+ e蜈･蜉帙ョ繝舌う繧ｹ = E蜈･蜉帙ョ繝舌う繧ｹ.繧ｭ繝ｼ繝懊ｼ繝;
+ break;
+
+ case 'L':
+ continue;
+
+ case 'M':
+ e蜈･蜉帙ョ繝舌う繧ｹ = E蜈･蜉帙ョ繝舌う繧ｹ.MIDI蜈･蜉;
+ break;
+
+ case 'N':
+ e蜈･蜉帙ョ繝舌う繧ｹ = E蜈･蜉帙ョ繝舌う繧ｹ.繝槭え繧ｹ;
+ break;
+ }
+ }
+ else
+ {
+ continue;
+ }
+ id = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ".IndexOf( str[ 1 ] ); // #24166 2011.1.15 yyagi: to support ID > 10, change 2nd character from Decimal to 36-numeral system. (e.g. J1023 -> JA23)
+ if( ( ( id >= 0 ) && int.TryParse( str.Substring( 2 ), out code ) ) && ( ( code >= 0 ) && ( code <= 0xff ) ) )
+ {
+ this.t謖螳壹＠縺溷･蜉帙′譌｢縺ｫ繧｢繧ｵ繧､繝ｳ貂医∩縺ｧ縺ゅｋ蝣ｴ蜷医ｯ縺昴ｌ繧貞ｨ蜑企勁縺吶ｋ( e蜈･蜉帙ョ繝舌う繧ｹ, id, code );
+ assign[ i ].蜈･蜉帙ョ繝舌う繧ｹ = e蜈･蜉帙ョ繝舌う繧ｹ;
+ assign[ i ].ID = id;
+ assign[ i ].繧ｳ繝ｼ繝 = code;
+ }
+ }
+ }
+ private void t繝繝輔か繝ｫ繝医ｮ繧ｭ繝ｼ繧｢繧ｵ繧､繝ｳ縺ｫ險ｭ螳壹☆繧()
+ {
+ this.t繧ｭ繝ｼ繧｢繧ｵ繧､繝ｳ繧貞ｨ驛ｨ繧ｯ繝ｪ繧｢縺吶ｋ();
+
+ string strDefaultKeyAssign = @"
+[DrumsKeyAssign]
+LeftRed=K015
+RightRed=K019
+LeftBlue=K013
+RightBlue=K020
+LeftRed2P=K011
+RightRed2P=K023
+LeftBlue2P=K012
+RightBlue2P=K047
+
+[SystemKeyAssign]
+Capture=K065
+";
+ t譁蟄怜励°繧芽ｪｭ縺ｿ霎ｼ縺ｿ( strDefaultKeyAssign );
+ }
+ //-----------------
+ #endregion
+
+
+ public event PropertyChangedEventHandler PropertyChanged;
+
+ private bool SetProperty(ref T storage, T value, string propertyName = null)
+ {
+ if (Equals(storage, value))
+ {
+ return false;
+ }
+
+ storage = value;
+ OnPropertyChanged(propertyName);
+ return true;
+ }
+
+ private void OnPropertyChanged(string propertyName)
+ {
+ PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
+ }
+ }
+}
diff --git a/TJAPlayer3/Common/CDTXVersion.cs b/TJAPlayer3/Common/CDTXVersion.cs
new file mode 100644
index 00000000..a83090ce
--- /dev/null
+++ b/TJAPlayer3/Common/CDTXVersion.cs
@@ -0,0 +1,210 @@
+ｻｿusing System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace TJAPlayer3
+{
+ ///
+ /// DTXMania 縺ｮ繝舌ｼ繧ｸ繝ｧ繝ｳ縲
+ /// 萓1ｼ"078b" 竊 謨ｴ謨ｰ驛ｨ=078, 蟆乗焚驛ｨ=2000000 ('闍ｱ蟄'+'yymmdd')
+ /// 萓2ｼ"078a(100124)" 竊 謨ｴ謨ｰ驛ｨ=078, 蟆乗焚驛ｨ=1100124 ('闍ｱ蟄'+'yymmdd')
+ ///
+ public class CDTXVersion
+ {
+ // 繝励Ο繝代ユ繧｣
+
+ ///
+ /// 繝舌ｼ繧ｸ繝ｧ繝ｳ縺梧悴遏･縺ｮ縺ｨ縺阪↓ true 縺ｫ縺ｪ繧九
+ ///
+ public bool Unknown
+ {
+ get;
+ private set;
+ }
+
+ ///
+ /// DTXMania 縺ｮ繝舌ｼ繧ｸ繝ｧ繝ｳ縺ｮ謨ｴ謨ｰ驛ｨ繧定｡ｨ縺吶
+ /// 萓1ｼ"078b" 竊 謨ｴ謨ｰ驛ｨ=078
+ /// 萓2ｼ"078a(100124)" 竊 謨ｴ謨ｰ驛ｨ=078
+ ///
+ public int n謨ｴ謨ｰ驛ｨ;
+
+ ///
+ /// DTXMania 縺ｮ繝舌ｼ繧ｸ繝ｧ繝ｳ縺ｮ蟆乗焚驛ｨ繧定｡ｨ縺吶
+ /// 蟆乗焚驛ｨ縺ｯ縲'闍ｱ蟄(0ｽ26) * 1000000 + 譌･莉(yymmdd)' 縺ｮ蠑上〒陦ｨ縺輔ｌ繧区紛謨ｰ縲
+ /// 萓1ｼ"078b" 竊 蟆乗焚驛ｨ=2000000
+ /// 萓2ｼ"078a(100124)" 竊 蟆乗焚驛ｨ=1100124
+ ///
+ public int n蟆乗焚驛ｨ;
+
+
+ // 繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ
+
+ public CDTXVersion()
+ {
+ this.n謨ｴ謨ｰ驛ｨ = 0;
+ this.n蟆乗焚驛ｨ = 0;
+ this.Unknown = true;
+ }
+ public CDTXVersion( int n謨ｴ謨ｰ驛ｨ )
+ {
+ this.n謨ｴ謨ｰ驛ｨ = n謨ｴ謨ｰ驛ｨ;
+ this.n蟆乗焚驛ｨ = 0;
+ this.Unknown = false;
+ }
+ public CDTXVersion( string Version )
+ {
+ this.n謨ｴ謨ｰ驛ｨ = 0;
+ this.n蟆乗焚驛ｨ = 0;
+ this.Unknown = true;
+
+ if( Version.ToLower().Equals( "unknown" ) )
+ {
+ this.Unknown = true;
+ }
+ else
+ {
+ int num = 0;
+ int length = Version.Length;
+ if( ( num < length ) && char.IsDigit( Version[ num ] ) )
+ {
+ // 謨ｴ謨ｰ驛ｨ縲蜿門ｾ
+ while( ( num < length ) && char.IsDigit( Version[ num ] ) )
+ {
+ this.n謨ｴ謨ｰ驛ｨ = ( this.n謨ｴ謨ｰ驛ｨ * 10 ) + CDTXVersion.DIG10.IndexOf( Version[ num++ ] );
+ }
+
+ // 蟆乗焚驛ｨ(1)闍ｱ蟄鈴Κ蛻縲蜿門ｾ
+ while( ( num < length ) && ( ( Version[ num ] == ' ' ) || ( Version[ num ] == '(' ) ) )
+ {
+ num++;
+ }
+ if( ( num < length ) && ( CDTXVersion.DIG36.IndexOf( Version[ num ] ) >= 10 ) )
+ {
+ this.n蟆乗焚驛ｨ = CDTXVersion.DIG36.IndexOf( Version[ num++ ] ) - 10;
+ if( this.n蟆乗焚驛ｨ >= 0x1a )
+ {
+ this.n蟆乗焚驛ｨ -= 0x1a;
+ }
+ this.n蟆乗焚驛ｨ++;
+ }
+
+ // 蟆乗焚驛ｨ(2)譌･莉倬Κ蛻(yymmdd)縲蜿門ｾ
+ while( ( num < length ) && ( ( Version[ num ] == ' ' ) || ( Version[ num ] == '(' ) ) )
+ {
+ num++;
+ }
+ for( int i = 0; i < 6; i++ )
+ {
+ this.n蟆乗焚驛ｨ *= 10;
+ if( ( num < length ) && char.IsDigit( Version[ num ] ) )
+ {
+ this.n蟆乗焚驛ｨ += CDTXVersion.DIG10.IndexOf( Version[ num ] );
+ }
+ num++;
+ }
+ this.Unknown = false;
+ }
+ else
+ {
+ this.Unknown = true;
+ }
+ }
+ }
+ public CDTXVersion( int n謨ｴ謨ｰ驛ｨ, int n蟆乗焚驛ｨ )
+ {
+ this.n謨ｴ謨ｰ驛ｨ = n謨ｴ謨ｰ驛ｨ;
+ this.n蟆乗焚驛ｨ = n蟆乗焚驛ｨ;
+ this.Unknown = false;
+ }
+
+
+ // 繝｡繧ｽ繝繝
+
+ public string toString()
+ {
+ var result = new StringBuilder( 32 );
+
+ // 謨ｴ謨ｰ驛ｨ
+ result.Append( this.n謨ｴ謨ｰ驛ｨ.ToString( "000" ) );
+
+ // 闍ｱ蟄鈴Κ蛻ｼ医≠繧後ｰｼ
+ if( this.n蟆乗焚驛ｨ >= 1000000 )
+ {
+ int n闍ｱ蟄 = Math.Min( this.n蟆乗焚驛ｨ / 1000000, 26 ); // 1ｽ26
+ result.Append( CDTXVersion.DIG36[ 10 + ( n闍ｱ蟄 - 1 ) ] );
+ }
+
+ // 譌･莉倬Κ蛻ｼ医≠繧後ｰｼ
+ int n譌･莉 = this.n蟆乗焚驛ｨ % 1000000;
+ if( n譌･莉 > 0 )
+ {
+ result.Append( '(' );
+ result.Append( n譌･莉.ToString( "000000" ) );
+ result.Append( ')' );
+ }
+
+ return result.ToString();
+ }
+
+ public static bool operator ==( CDTXVersion x, CDTXVersion y )
+ {
+ return ( ( ( x.n謨ｴ謨ｰ驛ｨ == y.n謨ｴ謨ｰ驛ｨ ) && ( x.n蟆乗焚驛ｨ == y.n蟆乗焚驛ｨ ) ) && ( x.Unknown == y.Unknown ) );
+ }
+ public static bool operator >( CDTXVersion x, CDTXVersion y )
+ {
+ return ( ( x.n謨ｴ謨ｰ驛ｨ > y.n謨ｴ謨ｰ驛ｨ ) || ( ( x.n謨ｴ謨ｰ驛ｨ == y.n謨ｴ謨ｰ驛ｨ ) && ( x.n蟆乗焚驛ｨ > y.n蟆乗焚驛ｨ ) ) );
+ }
+ public static bool operator >=( CDTXVersion x, CDTXVersion y )
+ {
+ return ( ( x.n謨ｴ謨ｰ驛ｨ > y.n謨ｴ謨ｰ驛ｨ ) || ( ( x.n謨ｴ謨ｰ驛ｨ == y.n謨ｴ謨ｰ驛ｨ ) && ( x.n蟆乗焚驛ｨ >= y.n蟆乗焚驛ｨ ) ) );
+ }
+ public static bool operator !=( CDTXVersion x, CDTXVersion y )
+ {
+ if( ( x.n謨ｴ謨ｰ驛ｨ == y.n謨ｴ謨ｰ驛ｨ ) && ( x.n蟆乗焚驛ｨ == y.n蟆乗焚驛ｨ ) )
+ {
+ return ( x.Unknown != y.Unknown );
+ }
+ return true;
+ }
+ public static bool operator <( CDTXVersion x, CDTXVersion y )
+ {
+ return ( ( x.n謨ｴ謨ｰ驛ｨ < y.n謨ｴ謨ｰ驛ｨ ) || ( ( x.n謨ｴ謨ｰ驛ｨ == y.n謨ｴ謨ｰ驛ｨ ) && ( x.n蟆乗焚驛ｨ < y.n蟆乗焚驛ｨ ) ) );
+ }
+ public static bool operator <=( CDTXVersion x, CDTXVersion y )
+ {
+ return ( ( x.n謨ｴ謨ｰ驛ｨ < y.n謨ｴ謨ｰ驛ｨ ) || ( ( x.n謨ｴ謨ｰ驛ｨ == y.n謨ｴ謨ｰ驛ｨ ) && ( x.n蟆乗焚驛ｨ <= y.n蟆乗焚驛ｨ ) ) );
+ }
+ public override bool Equals(object obj) // 2011.1.3 yyagi: warning繧堤┌縺上☆縺溘ａ縺ｫ霑ｽ蜉
+ {
+ if (obj == null)
+ {
+ return false;
+ }
+ if (this.GetType() != obj.GetType())
+ {
+ return false;
+ }
+ CDTXVersion objCDTXVersion = (CDTXVersion)obj;
+ if (!int.Equals(this.n謨ｴ謨ｰ驛ｨ, objCDTXVersion.n謨ｴ謨ｰ驛ｨ) || !int.Equals(this.n蟆乗焚驛ｨ, objCDTXVersion.n蟆乗焚驛ｨ))
+ {
+ return false;
+ }
+ return true;
+ }
+ public override int GetHashCode() // 2011.1.3 yyagi: warning繧堤┌縺上☆縺溘ａ縺ｫ霑ｽ蜉
+ {
+ string v = this.toString();
+ return v.GetHashCode();
+ }
+
+ // 縺昴ｮ莉
+
+ #region [ private ]
+ //-----------------
+ private const string DIG36 = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+ private const string DIG10 = "0123456789";
+ //-----------------
+ #endregion
+ }
+}
diff --git a/TJAPlayer3/Common/CPad.cs b/TJAPlayer3/Common/CPad.cs
new file mode 100644
index 00000000..32243313
--- /dev/null
+++ b/TJAPlayer3/Common/CPad.cs
@@ -0,0 +1,225 @@
+ｻｿusing System;
+using System.Collections.Generic;
+using System.Text;
+using System.Runtime.InteropServices;
+using FDK;
+
+namespace TJAPlayer3
+{
+ public class CPad
+ {
+ // 繝励Ο繝代ユ繧｣
+
+ internal STHIT st讀懃衍縺励◆繝繝舌う繧ｹ;
+ [StructLayout( LayoutKind.Sequential )]
+ internal struct STHIT
+ {
+ public bool Keyboard;
+ public bool MIDIIN;
+ public bool Joypad;
+ public bool Mouse;
+ public void Clear()
+ {
+ this.Keyboard = false;
+ this.MIDIIN = false;
+ this.Joypad = false;
+ this.Mouse = false;
+ }
+ }
+
+
+ // 繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ
+
+ internal CPad( CConfigIni configIni, CInput邂｡逅 mgrInput )
+ {
+ this.rConfigIni = configIni;
+ this.rInput邂｡逅 = mgrInput;
+ this.st讀懃衍縺励◆繝繝舌う繧ｹ.Clear();
+ }
+
+
+ // 繝｡繧ｽ繝繝
+
+ public List GetEvents( E讌ｽ蝎ｨ繝代ｼ繝 part, E繝代ャ繝 pad )
+ {
+ CConfigIni.CKeyAssign.STKEYASSIGN[] stkeyassignArray = this.rConfigIni.KeyAssign[ (int) part ][ (int) pad ];
+ List list = new List();
+
+ // 縺吶∋縺ｦ縺ｮ蜈･蜉帙ョ繝舌う繧ｹ縺ｫ縺､縺縺ｦ窶ｦ
+ foreach( IInputDevice device in this.rInput邂｡逅.list蜈･蜉帙ョ繝舌う繧ｹ )
+ {
+ if( ( device.list蜈･蜉帙う繝吶Φ繝 != null ) && ( device.list蜈･蜉帙う繝吶Φ繝.Count != 0 ) )
+ {
+ foreach( STInputEvent event2 in device.list蜈･蜉帙う繝吶Φ繝 )
+ {
+ for( int i = 0; i < stkeyassignArray.Length; i++ )
+ {
+ switch( stkeyassignArray[ i ].蜈･蜉帙ョ繝舌う繧ｹ )
+ {
+ case E蜈･蜉帙ョ繝舌う繧ｹ.繧ｭ繝ｼ繝懊ｼ繝:
+ if( ( device.e蜈･蜉帙ョ繝舌う繧ｹ遞ｮ蛻･ == E蜈･蜉帙ョ繝舌う繧ｹ遞ｮ蛻･.Keyboard ) && ( event2.nKey == stkeyassignArray[ i ].繧ｳ繝ｼ繝 ) )
+ {
+ list.Add( event2 );
+ this.st讀懃衍縺励◆繝繝舌う繧ｹ.Keyboard = true;
+ }
+ break;
+
+ case E蜈･蜉帙ョ繝舌う繧ｹ.MIDI蜈･蜉:
+ if( ( ( device.e蜈･蜉帙ョ繝舌う繧ｹ遞ｮ蛻･ == E蜈･蜉帙ョ繝舌う繧ｹ遞ｮ蛻･.MidiIn ) && ( device.ID == stkeyassignArray[ i ].ID ) ) && ( event2.nKey == stkeyassignArray[ i ].繧ｳ繝ｼ繝 ) )
+ {
+ list.Add( event2 );
+ this.st讀懃衍縺励◆繝繝舌う繧ｹ.MIDIIN = true;
+ }
+ break;
+
+ case E蜈･蜉帙ョ繝舌う繧ｹ.繧ｸ繝ｧ繧､繝代ャ繝:
+ if( ( ( device.e蜈･蜉帙ョ繝舌う繧ｹ遞ｮ蛻･ == E蜈･蜉帙ョ繝舌う繧ｹ遞ｮ蛻･.Joystick ) && ( device.ID == stkeyassignArray[ i ].ID ) ) && ( event2.nKey == stkeyassignArray[ i ].繧ｳ繝ｼ繝 ) )
+ {
+ list.Add( event2 );
+ this.st讀懃衍縺励◆繝繝舌う繧ｹ.Joypad = true;
+ }
+ break;
+
+ case E蜈･蜉帙ョ繝舌う繧ｹ.繝槭え繧ｹ:
+ if( ( device.e蜈･蜉帙ョ繝舌う繧ｹ遞ｮ蛻･ == E蜈･蜉帙ョ繝舌う繧ｹ遞ｮ蛻･.Mouse ) && ( event2.nKey == stkeyassignArray[ i ].繧ｳ繝ｼ繝 ) )
+ {
+ list.Add( event2 );
+ this.st讀懃衍縺励◆繝繝舌う繧ｹ.Mouse = true;
+ }
+ break;
+ }
+ }
+ }
+ continue;
+ }
+ }
+ return list;
+ }
+ public bool b謚ｼ縺輔ｌ縺( E讌ｽ蝎ｨ繝代ｼ繝 part, E繝代ャ繝 pad )
+ {
+ if( part != E讌ｽ蝎ｨ繝代ｼ繝.UNKNOWN )
+ {
+
+ CConfigIni.CKeyAssign.STKEYASSIGN[] stkeyassignArray = this.rConfigIni.KeyAssign[ (int) part ][ (int) pad ];
+ for( int i = 0; i < stkeyassignArray.Length; i++ )
+ {
+ switch( stkeyassignArray[ i ].蜈･蜉帙ョ繝舌う繧ｹ )
+ {
+ case E蜈･蜉帙ョ繝舌う繧ｹ.繧ｭ繝ｼ繝懊ｼ繝:
+ if( !this.rInput邂｡逅.Keyboard.b繧ｭ繝ｼ縺梧款縺輔ｌ縺( stkeyassignArray[ i ].繧ｳ繝ｼ繝 ) )
+ break;
+
+ this.st讀懃衍縺励◆繝繝舌う繧ｹ.Keyboard = true;
+ return true;
+
+ case E蜈･蜉帙ョ繝舌う繧ｹ.MIDI蜈･蜉:
+ {
+ IInputDevice device2 = this.rInput邂｡逅.MidiIn( stkeyassignArray[ i ].ID );
+ if( ( device2 == null ) || !device2.b繧ｭ繝ｼ縺梧款縺輔ｌ縺( stkeyassignArray[ i ].繧ｳ繝ｼ繝 ) )
+ break;
+
+ this.st讀懃衍縺励◆繝繝舌う繧ｹ.MIDIIN = true;
+ return true;
+ }
+ case E蜈･蜉帙ョ繝舌う繧ｹ.繧ｸ繝ｧ繧､繝代ャ繝:
+ {
+ if( !this.rConfigIni.dicJoystick.ContainsKey( stkeyassignArray[ i ].ID ) )
+ break;
+
+ IInputDevice device = this.rInput邂｡逅.Joystick( stkeyassignArray[ i ].ID );
+ if( ( device == null ) || !device.b繧ｭ繝ｼ縺梧款縺輔ｌ縺( stkeyassignArray[ i ].繧ｳ繝ｼ繝 ) )
+ break;
+
+ this.st讀懃衍縺励◆繝繝舌う繧ｹ.Joypad = true;
+ return true;
+ }
+ case E蜈･蜉帙ョ繝舌う繧ｹ.繝槭え繧ｹ:
+ if( !this.rInput邂｡逅.Mouse.b繧ｭ繝ｼ縺梧款縺輔ｌ縺( stkeyassignArray[ i ].繧ｳ繝ｼ繝 ) )
+ break;
+
+ this.st讀懃衍縺励◆繝繝舌う繧ｹ.Mouse = true;
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+ public bool b謚ｼ縺輔ｌ縺櫂GB( E繝代ャ繝 pad )
+ {
+ if( !this.b謚ｼ縺輔ｌ縺( E讌ｽ蝎ｨ繝代ｼ繝.DRUMS, pad ) && !this.b謚ｼ縺輔ｌ縺( E讌ｽ蝎ｨ繝代ｼ繝.GUITAR, pad ) )
+ {
+ return this.b謚ｼ縺輔ｌ縺( E讌ｽ蝎ｨ繝代ｼ繝.BASS, pad );
+ }
+ return true;
+ }
+ public bool b謚ｼ縺輔ｌ縺檬B( E繝代ャ繝 pad )
+ {
+ if( !this.b謚ｼ縺輔ｌ縺( E讌ｽ蝎ｨ繝代ｼ繝.GUITAR, pad ) )
+ {
+ return this.b謚ｼ縺輔ｌ縺( E讌ｽ蝎ｨ繝代ｼ繝.BASS, pad );
+ }
+ return true;
+ }
+ public bool b謚ｼ縺輔ｌ縺ｦ縺繧( E讌ｽ蝎ｨ繝代ｼ繝 part, E繝代ャ繝 pad )
+ {
+ if( part != E讌ｽ蝎ｨ繝代ｼ繝.UNKNOWN )
+ {
+ CConfigIni.CKeyAssign.STKEYASSIGN[] stkeyassignArray = this.rConfigIni.KeyAssign[ (int) part ][ (int) pad ];
+ for( int i = 0; i < stkeyassignArray.Length; i++ )
+ {
+ switch( stkeyassignArray[ i ].蜈･蜉帙ョ繝舌う繧ｹ )
+ {
+ case E蜈･蜉帙ョ繝舌う繧ｹ.繧ｭ繝ｼ繝懊ｼ繝:
+ if( !this.rInput邂｡逅.Keyboard.b繧ｭ繝ｼ縺梧款縺輔ｌ縺ｦ縺繧( stkeyassignArray[ i ].繧ｳ繝ｼ繝 ) )
+ {
+ break;
+ }
+ this.st讀懃衍縺励◆繝繝舌う繧ｹ.Keyboard = true;
+ return true;
+
+ case E蜈･蜉帙ョ繝舌う繧ｹ.繧ｸ繝ｧ繧､繝代ャ繝:
+ {
+ if( !this.rConfigIni.dicJoystick.ContainsKey( stkeyassignArray[ i ].ID ) )
+ {
+ break;
+ }
+ IInputDevice device = this.rInput邂｡逅.Joystick( stkeyassignArray[ i ].ID );
+ if( ( device == null ) || !device.b繧ｭ繝ｼ縺梧款縺輔ｌ縺ｦ縺繧( stkeyassignArray[ i ].繧ｳ繝ｼ繝 ) )
+ {
+ break;
+ }
+ this.st讀懃衍縺励◆繝繝舌う繧ｹ.Joypad = true;
+ return true;
+ }
+ case E蜈･蜉帙ョ繝舌う繧ｹ.繝槭え繧ｹ:
+ if( !this.rInput邂｡逅.Mouse.b繧ｭ繝ｼ縺梧款縺輔ｌ縺ｦ縺繧( stkeyassignArray[ i ].繧ｳ繝ｼ繝 ) )
+ {
+ break;
+ }
+ this.st讀懃衍縺励◆繝繝舌う繧ｹ.Mouse = true;
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+ public bool b謚ｼ縺輔ｌ縺ｦ縺繧季B( E繝代ャ繝 pad )
+ {
+ if( !this.b謚ｼ縺輔ｌ縺ｦ縺繧( E讌ｽ蝎ｨ繝代ｼ繝.GUITAR, pad ) )
+ {
+ return this.b謚ｼ縺輔ｌ縺ｦ縺繧( E讌ｽ蝎ｨ繝代ｼ繝.BASS, pad );
+ }
+ return true;
+ }
+
+
+ // 縺昴ｮ莉
+
+ #region [ private ]
+ //-----------------
+ private CConfigIni rConfigIni;
+ private CInput邂｡逅 rInput邂｡逅;
+ //-----------------
+ #endregion
+ }
+}
diff --git a/TJAPlayer3/Common/CPrivateFastFont.cs b/TJAPlayer3/Common/CPrivateFastFont.cs
new file mode 100644
index 00000000..4d8edb67
--- /dev/null
+++ b/TJAPlayer3/Common/CPrivateFastFont.cs
@@ -0,0 +1,427 @@
+ｻｿusing System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Drawing;
+using System.Drawing.Drawing2D;
+using System.Diagnostics;
+
+namespace TJAPlayer3
+{
+ ///
+ /// 鬮倬滓緒逕ｻ迚医ｮCPrivateFont繧ｯ繝ｩ繧ｹ縲
+ /// 縺ｨ縺縺｣縺ｦ繧ゅ∽ｸ蠎ｦ繝ｬ繝ｳ繝繝ｪ繝ｳ繧ｰ縺励◆邨先棡繧偵く繝｣繝繧ｷ繝･縺励※菴ｿ縺縺ｾ繧上＠縺ｦ縺繧九□縺代
+ ///
+ public class CPrivateFastFont : CPrivateFont
+ {
+ ///
+ /// 繧ｭ繝｣繝繧ｷ繝･螳ｹ驥
+ ///
+ private const int MAXCACHESIZE = 128;
+
+ private struct FontCache
+ {
+ // public Font font;
+ public int edgePt;
+ public string drawstr;
+ public DrawMode drawmode;
+ public Color fontColor;
+ public Color edgeColor;
+ public Color gradationTopColor;
+ public Color gradationBottomColor;
+ public Bitmap bmp;
+ public Rectangle rectStrings;
+ public Point ptOrigin;
+ }
+ private List listFontCache;
+
+
+ #region [ 繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ ]
+ public CPrivateFastFont(FontFamily fontfamily, int pt, FontStyle style)
+ {
+ Initialize(null, fontfamily, pt, style);
+ }
+ public CPrivateFastFont(FontFamily fontfamily, int pt)
+ {
+ Initialize(null, fontfamily, pt, FontStyle.Regular);
+ }
+ public CPrivateFastFont(string fontpath, int pt, FontStyle style)
+ {
+ Initialize(fontpath, null, pt, style);
+ }
+ public CPrivateFastFont(string fontpath, int pt)
+ {
+ Initialize(fontpath, null, pt, FontStyle.Regular);
+ }
+ public CPrivateFastFont()
+ {
+ throw new ArgumentException("CPrivateFastFont: 蠑墓焚縺後≠繧九さ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ繧剃ｽｿ逕ｨ縺励※縺上□縺輔＞縲");
+ }
+ #endregion
+ #region [ 繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ縺九ｉ蜻ｼ縺ｰ繧後ｋ蛻晄悄蛹門ｦ逅 ]
+ protected new void Initialize(string fontpath, FontFamily fontfamily, int pt, FontStyle style)
+ {
+ this.bDispose螳御ｺ貂医∩_CPrivateFastFont = false;
+ this.listFontCache = new List();
+ base.Initialize(fontpath, fontfamily, pt, style);
+ }
+ #endregion
+
+
+ #region [ DrawPrivateFont縺ｮ繧ｪ繝ｼ繝舌ｼ繝ｭ繝ｼ繝臥ｾ､ ]
+ ///
+ /// 譁蟄怜励ｒ謠冗判縺励◆繝繧ｯ繧ｹ繝√Ε繧定ｿ斐☆
+ ///
+ /// 謠冗判譁蟄怜
+ /// 謠冗判濶ｲ
+ /// 謠冗判貂医ユ繧ｯ繧ｹ繝√Ε
+ public new Bitmap DrawPrivateFont(string drawstr, Color fontColor)
+ {
+ return DrawPrivateFont(drawstr, DrawMode.Normal, fontColor, Color.White, Color.White, Color.White);
+ }
+
+ public new Bitmap DrawPrivateFont(string drawstr, Color fontColor, Color edgeColor, int edgePt)
+ {
+ return DrawPrivateFont_E(drawstr, DrawMode.Edge, fontColor, edgeColor, Color.White, Color.White, edgePt);
+ }
+
+ ///
+ /// 譁蟄怜励ｒ謠冗判縺励◆繝繧ｯ繧ｹ繝√Ε繧定ｿ斐☆
+ ///
+ /// 謠冗判譁蟄怜
+ /// 謠冗判濶ｲ
+ /// 邵∝叙濶ｲ
+ /// 謠冗判貂医ユ繧ｯ繧ｹ繝√Ε
+ public new Bitmap DrawPrivateFont(string drawstr, Color fontColor, Color edgeColor)
+ {
+ return DrawPrivateFont(drawstr, DrawMode.Edge, fontColor, edgeColor, Color.White, Color.White);
+ }
+
+ ///
+ /// 譁蟄怜励ｒ謠冗判縺励◆繝繧ｯ繧ｹ繝√Ε繧定ｿ斐☆
+ ///
+ /// 謠冗判譁蟄怜
+ /// 謠冗判濶ｲ
+ /// 邵∝叙濶ｲ
+ /// 謠冗判貂医ユ繧ｯ繧ｹ繝√Ε
+ public Bitmap DrawPrivateFont(string drawstr, Color fontColor, Color edgeColor, DrawMode dMode)
+ {
+ return DrawPrivateFont(drawstr, dMode, fontColor, edgeColor, Color.White, Color.White);
+ }
+ ///
+ /// 譁蟄怜励ｒ謠冗判縺励◆繝繧ｯ繧ｹ繝√Ε繧定ｿ斐☆
+ ///
+ /// 謠冗判譁蟄怜
+ /// 謠冗判濶ｲ
+ /// 繧ｰ繝ｩ繝繝ｼ繧ｷ繝ｧ繝ｳ 荳雁ｴ縺ｮ濶ｲ
+ /// 繧ｰ繝ｩ繝繝ｼ繧ｷ繝ｧ繝ｳ 荳句ｴ縺ｮ濶ｲ
+ /// 謠冗判貂医ユ繧ｯ繧ｹ繝√Ε
+ //public new Bitmap DrawPrivateFont( string drawstr, Color fontColor, Color gradationTopColor, Color gradataionBottomColor )
+ //{
+ // return DrawPrivateFont( drawstr, DrawMode.Gradation, fontColor, Color.White, gradationTopColor, gradataionBottomColor );
+ //}
+
+ ///
+ /// 譁蟄怜励ｒ謠冗判縺励◆繝繧ｯ繧ｹ繝√Ε繧定ｿ斐☆
+ ///
+ /// 謠冗判譁蟄怜
+ /// 謠冗判濶ｲ
+ /// 邵∝叙濶ｲ
+ /// 繧ｰ繝ｩ繝繝ｼ繧ｷ繝ｧ繝ｳ 荳雁ｴ縺ｮ濶ｲ
+ /// 繧ｰ繝ｩ繝繝ｼ繧ｷ繝ｧ繝ｳ 荳句ｴ縺ｮ濶ｲ
+ /// 謠冗判貂医ユ繧ｯ繧ｹ繝√Ε
+ public new Bitmap DrawPrivateFont(string drawstr, Color fontColor, Color edgeColor, Color gradationTopColor, Color gradataionBottomColor)
+ {
+ return DrawPrivateFont(drawstr, DrawMode.Edge | DrawMode.Gradation, fontColor, edgeColor, gradationTopColor, gradataionBottomColor);
+ }
+
+ ///
+ /// 譁蟄怜励ｒ謠冗判縺励◆繝繧ｯ繧ｹ繝√Ε繧定ｿ斐☆
+ ///
+ /// 謠冗判譁蟄怜
+ /// 謠冗判濶ｲ
+ /// 邵∝叙濶ｲ
+ /// 繧ｰ繝ｩ繝繝ｼ繧ｷ繝ｧ繝ｳ 荳雁ｴ縺ｮ濶ｲ
+ /// 繧ｰ繝ｩ繝繝ｼ繧ｷ繝ｧ繝ｳ 荳句ｴ縺ｮ濶ｲ
+ /// 謠冗判貂医ユ繧ｯ繧ｹ繝√Ε
+ public Bitmap DrawPrivateFont(string drawstr, Color fontColor, Color edgeColor, bool bVertical)
+ {
+ return DrawPrivateFont_V(drawstr, fontColor, edgeColor, bVertical);
+ }
+
+#if 縺薙■繧峨ｯ菴ｿ繧上↑縺 // (Bitmap縺ｧ縺ｯ縺ｪ縺上，Texture繧定ｿ斐☆迚)
+ ///
+ /// 譁蟄怜励ｒ謠冗判縺励◆繝繧ｯ繧ｹ繝√Ε繧定ｿ斐☆
+ ///
+ /// 謠冗判譁蟄怜
+ /// 謠冗判濶ｲ
+ /// 謠冗判貂医ユ繧ｯ繧ｹ繝√Ε
+ public CTexture DrawPrivateFont( string drawstr, Color fontColor )
+ {
+ Bitmap bmp = DrawPrivateFont( drawstr, DrawMode.Normal, fontColor, Color.White, Color.White, Color.White );
+ return CDTXMania.t繝繧ｯ繧ｹ繝√Ε縺ｮ逕滓( bmp, false );
+ }
+
+ ///
+ /// 譁蟄怜励ｒ謠冗判縺励◆繝繧ｯ繧ｹ繝√Ε繧定ｿ斐☆
+ ///
+ /// 謠冗判譁蟄怜
+ /// 謠冗判濶ｲ
+ /// 邵∝叙濶ｲ
+ /// 謠冗判貂医ユ繧ｯ繧ｹ繝√Ε
+ public CTexture DrawPrivateFont( string drawstr, Color fontColor, Color edgeColor )
+ {
+ Bitmap bmp = DrawPrivateFont( drawstr, DrawMode.Edge, fontColor, edgeColor, Color.White, Color.White );
+ return CDTXMania.t繝繧ｯ繧ｹ繝√Ε縺ｮ逕滓( bmp, false );
+ }
+
+ ///
+ /// 譁蟄怜励ｒ謠冗判縺励◆繝繧ｯ繧ｹ繝√Ε繧定ｿ斐☆
+ ///
+ /// 謠冗判譁蟄怜
+ /// 謠冗判濶ｲ
+ /// 繧ｰ繝ｩ繝繝ｼ繧ｷ繝ｧ繝ｳ 荳雁ｴ縺ｮ濶ｲ
+ /// 繧ｰ繝ｩ繝繝ｼ繧ｷ繝ｧ繝ｳ 荳句ｴ縺ｮ濶ｲ
+ /// 謠冗判貂医ユ繧ｯ繧ｹ繝√Ε
+ //public CTexture DrawPrivateFont( string drawstr, Color fontColor, Color gradationTopColor, Color gradataionBottomColor )
+ //{
+ // Bitmap bmp = DrawPrivateFont( drawstr, DrawMode.Gradation, fontColor, Color.White, gradationTopColor, gradataionBottomColor );
+ // return CDTXMania.t繝繧ｯ繧ｹ繝√Ε縺ｮ逕滓( bmp, false );
+ //}
+
+ ///
+ /// 譁蟄怜励ｒ謠冗判縺励◆繝繧ｯ繧ｹ繝√Ε繧定ｿ斐☆
+ ///
+ /// 謠冗判譁蟄怜
+ /// 謠冗判濶ｲ
+ /// 邵∝叙濶ｲ
+ /// 繧ｰ繝ｩ繝繝ｼ繧ｷ繝ｧ繝ｳ 荳雁ｴ縺ｮ濶ｲ
+ /// 繧ｰ繝ｩ繝繝ｼ繧ｷ繝ｧ繝ｳ 荳句ｴ縺ｮ濶ｲ
+ /// 謠冗判貂医ユ繧ｯ繧ｹ繝√Ε
+ public CTexture DrawPrivateFont( string drawstr, Color fontColor, Color edgeColor, Color gradationTopColor, Color gradataionBottomColor )
+ {
+ Bitmap bmp = DrawPrivateFont( drawstr, DrawMode.Edge | DrawMode.Gradation, fontColor, edgeColor, gradationTopColor, gradataionBottomColor );
+ return CDTXMania.t繝繧ｯ繧ｹ繝√Ε縺ｮ逕滓( bmp, false );
+ }
+#endif
+ #endregion
+
+ protected new Bitmap DrawPrivateFont_E(string drawstr, DrawMode drawmode, Color fontColor, Color edgeColor, Color gradationTopColor, Color gradationBottomColor, int edgePt)
+ {
+ #region [ 莉･蜑阪Ξ繝ｳ繝繝ｪ繝ｳ繧ｰ縺励◆縺薙→縺ｮ縺ゅｋ譁蟄怜/繝輔か繝ｳ繝医°? (繧ｭ繝｣繝繧ｷ繝･縺ｫ繝偵ャ繝医☆繧九°?) ]
+ int index = listFontCache.FindIndex(
+ delegate (FontCache fontcache)
+ {
+ return (
+ drawstr == fontcache.drawstr &&
+ drawmode == fontcache.drawmode &&
+ fontColor == fontcache.fontColor &&
+ edgeColor == fontcache.edgeColor &&
+ gradationTopColor == fontcache.gradationTopColor &&
+ gradationBottomColor == fontcache.gradationBottomColor &&
+ edgePt == fontcache.edgePt
+ // _font == fontcache.font
+ );
+ }
+ );
+ #endregion
+ if (index < 0)
+ {
+ // 繧ｭ繝｣繝繧ｷ繝･縺ｫ繝偵ャ繝医○縺壹
+ #region [ 繝ｬ繝ｳ繝繝ｪ繝ｳ繧ｰ縺励※縲√く繝｣繝繧ｷ繝･縺ｫ逋ｻ骭ｲ ]
+ FontCache fc = new FontCache();
+ fc.bmp = base.DrawPrivateFont_E(drawstr, drawmode, fontColor, edgeColor, gradationTopColor, gradationBottomColor, edgePt);
+ fc.drawstr = drawstr;
+ fc.drawmode = drawmode;
+ fc.fontColor = fontColor;
+ fc.edgeColor = edgeColor;
+ fc.gradationTopColor = gradationTopColor;
+ fc.gradationBottomColor = gradationBottomColor;
+ fc.edgePt = edgePt;
+ fc.rectStrings = RectStrings;
+ fc.ptOrigin = PtOrigin;
+ listFontCache.Add(fc);
+ Debug.WriteLine(drawstr + ": Cache縺ｫ繝偵ャ繝医○縺壹(cachesize=" + listFontCache.Count + ")");
+ #endregion
+ #region [ 繧ゅ＠繧ｭ繝｣繝繧ｷ繝･縺後≠縺ｵ繧後◆繧峨∵怙繧ょ商縺繧ｭ繝｣繝繧ｷ繝･繧堤ｴ譽縺吶ｋ ]
+ if (listFontCache.Count > MAXCACHESIZE)
+ {
+ Debug.WriteLine("Cache貅｢繧後" + listFontCache[0].drawstr + " 繧定ｧ｣謾ｾ縺励∪縺吶");
+ if (listFontCache[0].bmp != null)
+ {
+ listFontCache[0].bmp.Dispose();
+ }
+ listFontCache.RemoveAt(0);
+ }
+ #endregion
+
+ // 蜻ｼ縺ｳ蜃ｺ縺怜縺ｮDispose()縺ｧ繧ｭ繝｣繝繧ｷ繝･繧Dispose()縺輔ｌ縺ｪ縺繧医≧縺ｫ縲，lone()縺ｧ霑斐☆縲
+ return (Bitmap)listFontCache[listFontCache.Count - 1].bmp.Clone();
+ }
+ else
+ {
+ Debug.WriteLine(drawstr + ": Cache縺ｫ繝偵ャ繝!! index=" + index);
+ #region [ 繧ｭ繝｣繝繧ｷ繝･縺ｫ繝偵ャ繝医ゅΞ繝ｳ繝繝ｪ繝ｳ繧ｰ縺ｯ陦後ｏ縺壹√く繝｣繝繧ｷ繝･蜀縺ｮ繝繝ｼ繧ｿ繧定ｿ斐＠縺ｦ邨ゆｺ縲]
+ RectStrings = listFontCache[index].rectStrings;
+ PtOrigin = listFontCache[index].ptOrigin;
+ // 蜻ｼ縺ｳ蜃ｺ縺怜縺ｮDispose()縺ｧ繧ｭ繝｣繝繧ｷ繝･繧Dispose()縺輔ｌ縺ｪ縺繧医≧縺ｫ縲，lone()縺ｧ霑斐☆縲
+ return (Bitmap)listFontCache[index].bmp.Clone();
+ #endregion
+ }
+ }
+
+ protected new Bitmap DrawPrivateFont(string drawstr, DrawMode drawmode, Color fontColor, Color edgeColor, Color gradationTopColor, Color gradationBottomColor)
+ {
+ #region [ 莉･蜑阪Ξ繝ｳ繝繝ｪ繝ｳ繧ｰ縺励◆縺薙→縺ｮ縺ゅｋ譁蟄怜/繝輔か繝ｳ繝医°? (繧ｭ繝｣繝繧ｷ繝･縺ｫ繝偵ャ繝医☆繧九°?) ]
+ int index = listFontCache.FindIndex(
+ delegate (FontCache fontcache)
+ {
+ return (
+ drawstr == fontcache.drawstr &&
+ drawmode == fontcache.drawmode &&
+ fontColor == fontcache.fontColor &&
+ edgeColor == fontcache.edgeColor &&
+ gradationTopColor == fontcache.gradationTopColor &&
+ gradationBottomColor == fontcache.gradationBottomColor
+ // _font == fontcache.font
+ );
+ }
+ );
+ #endregion
+ if (index < 0)
+ {
+ // 繧ｭ繝｣繝繧ｷ繝･縺ｫ繝偵ャ繝医○縺壹
+ #region [ 繝ｬ繝ｳ繝繝ｪ繝ｳ繧ｰ縺励※縲√く繝｣繝繧ｷ繝･縺ｫ逋ｻ骭ｲ ]
+ FontCache fc = new FontCache();
+ fc.bmp = base.DrawPrivateFont(drawstr, drawmode, fontColor, edgeColor, gradationTopColor, gradationBottomColor);
+ fc.drawstr = drawstr;
+ fc.drawmode = drawmode;
+ fc.fontColor = fontColor;
+ fc.edgeColor = edgeColor;
+ fc.gradationTopColor = gradationTopColor;
+ fc.gradationBottomColor = gradationBottomColor;
+ fc.rectStrings = RectStrings;
+ fc.ptOrigin = PtOrigin;
+ listFontCache.Add(fc);
+ Debug.WriteLine(drawstr + ": Cache縺ｫ繝偵ャ繝医○縺壹(cachesize=" + listFontCache.Count + ")");
+ #endregion
+ #region [ 繧ゅ＠繧ｭ繝｣繝繧ｷ繝･縺後≠縺ｵ繧後◆繧峨∵怙繧ょ商縺繧ｭ繝｣繝繧ｷ繝･繧堤ｴ譽縺吶ｋ ]
+ if (listFontCache.Count > MAXCACHESIZE)
+ {
+ Debug.WriteLine("Cache貅｢繧後" + listFontCache[0].drawstr + " 繧定ｧ｣謾ｾ縺励∪縺吶");
+ if (listFontCache[0].bmp != null)
+ {
+ listFontCache[0].bmp.Dispose();
+ }
+ listFontCache.RemoveAt(0);
+ }
+ #endregion
+
+ // 蜻ｼ縺ｳ蜃ｺ縺怜縺ｮDispose()縺ｧ繧ｭ繝｣繝繧ｷ繝･繧Dispose()縺輔ｌ縺ｪ縺繧医≧縺ｫ縲，lone()縺ｧ霑斐☆縲
+ return (Bitmap)listFontCache[listFontCache.Count - 1].bmp.Clone();
+ }
+ else
+ {
+ Debug.WriteLine(drawstr + ": Cache縺ｫ繝偵ャ繝!! index=" + index);
+ #region [ 繧ｭ繝｣繝繧ｷ繝･縺ｫ繝偵ャ繝医ゅΞ繝ｳ繝繝ｪ繝ｳ繧ｰ縺ｯ陦後ｏ縺壹√く繝｣繝繧ｷ繝･蜀縺ｮ繝繝ｼ繧ｿ繧定ｿ斐＠縺ｦ邨ゆｺ縲]
+ RectStrings = listFontCache[index].rectStrings;
+ PtOrigin = listFontCache[index].ptOrigin;
+ // 蜻ｼ縺ｳ蜃ｺ縺怜縺ｮDispose()縺ｧ繧ｭ繝｣繝繧ｷ繝･繧Dispose()縺輔ｌ縺ｪ縺繧医≧縺ｫ縲，lone()縺ｧ霑斐☆縲
+ return (Bitmap)listFontCache[index].bmp.Clone();
+ #endregion
+ }
+ }
+
+ protected new Bitmap DrawPrivateFont_V(string drawstr, Color fontColor, Color edgeColor, bool bVertical)
+ {
+ #region [ 莉･蜑阪Ξ繝ｳ繝繝ｪ繝ｳ繧ｰ縺励◆縺薙→縺ｮ縺ゅｋ譁蟄怜/繝輔か繝ｳ繝医°? (繧ｭ繝｣繝繧ｷ繝･縺ｫ繝偵ャ繝医☆繧九°?) ]
+ int index = listFontCache.FindIndex(
+ delegate (FontCache fontcache)
+ {
+ return (
+ drawstr == fontcache.drawstr &&
+ fontColor == fontcache.fontColor &&
+ edgeColor == fontcache.edgeColor &&
+ bVertical == true
+ // _font == fontcache.font
+ );
+ }
+ );
+ #endregion
+ if (index < 0)
+ {
+ // 繧ｭ繝｣繝繧ｷ繝･縺ｫ繝偵ャ繝医○縺壹
+ #region [ 繝ｬ繝ｳ繝繝ｪ繝ｳ繧ｰ縺励※縲√く繝｣繝繧ｷ繝･縺ｫ逋ｻ骭ｲ ]
+ FontCache fc = new FontCache();
+ fc.bmp = base.DrawPrivateFont_V(drawstr, fontColor, edgeColor, true);
+ fc.drawstr = drawstr;
+ fc.fontColor = fontColor;
+ fc.edgeColor = edgeColor;
+ fc.rectStrings = RectStrings;
+ fc.ptOrigin = PtOrigin;
+ listFontCache.Add(fc);
+ Debug.WriteLine(drawstr + ": Cache縺ｫ繝偵ャ繝医○縺壹(cachesize=" + listFontCache.Count + ")");
+ #endregion
+ #region [ 繧ゅ＠繧ｭ繝｣繝繧ｷ繝･縺後≠縺ｵ繧後◆繧峨∵怙繧ょ商縺繧ｭ繝｣繝繧ｷ繝･繧堤ｴ譽縺吶ｋ ]
+ if (listFontCache.Count > MAXCACHESIZE)
+ {
+ Debug.WriteLine("Cache貅｢繧後" + listFontCache[0].drawstr + " 繧定ｧ｣謾ｾ縺励∪縺吶");
+ if (listFontCache[0].bmp != null)
+ {
+ listFontCache[0].bmp.Dispose();
+ }
+ listFontCache.RemoveAt(0);
+ }
+ #endregion
+
+ // 蜻ｼ縺ｳ蜃ｺ縺怜縺ｮDispose()縺ｧ繧ｭ繝｣繝繧ｷ繝･繧Dispose()縺輔ｌ縺ｪ縺繧医≧縺ｫ縲，lone()縺ｧ霑斐☆縲
+ return (Bitmap)listFontCache[listFontCache.Count - 1].bmp.Clone();
+ }
+ else
+ {
+ Debug.WriteLine(drawstr + ": Cache縺ｫ繝偵ャ繝!! index=" + index);
+ #region [ 繧ｭ繝｣繝繧ｷ繝･縺ｫ繝偵ャ繝医ゅΞ繝ｳ繝繝ｪ繝ｳ繧ｰ縺ｯ陦後ｏ縺壹√く繝｣繝繧ｷ繝･蜀縺ｮ繝繝ｼ繧ｿ繧定ｿ斐＠縺ｦ邨ゆｺ縲]
+ RectStrings = listFontCache[index].rectStrings;
+ PtOrigin = listFontCache[index].ptOrigin;
+ // 蜻ｼ縺ｳ蜃ｺ縺怜縺ｮDispose()縺ｧ繧ｭ繝｣繝繧ｷ繝･繧Dispose()縺輔ｌ縺ｪ縺繧医≧縺ｫ縲，lone()縺ｧ霑斐☆縲
+ return (Bitmap)listFontCache[index].bmp.Clone();
+ #endregion
+ }
+ }
+
+ #region [ IDisposable 螳溯｣ ]
+ //-----------------
+ public new void Dispose()
+ {
+ if (!this.bDispose螳御ｺ貂医∩_CPrivateFastFont)
+ {
+ if (listFontCache != null)
+ {
+ //Debug.WriteLine( "Disposing CPrivateFastFont()" );
+ #region [ 繧ｭ繝｣繝繧ｷ繝･縺励※縺繧狗判蜒上ｒ遐ｴ譽縺吶ｋ ]
+ foreach (FontCache bc in listFontCache)
+
+ {
+ if (bc.bmp != null)
+ {
+ bc.bmp.Dispose();
+ }
+ }
+ #endregion
+ listFontCache.Clear();
+ listFontCache = null;
+ }
+ this.bDispose螳御ｺ貂医∩_CPrivateFastFont = true;
+ }
+ base.Dispose();
+ }
+ //-----------------
+ #endregion
+
+ #region [ private ]
+ //-----------------
+ protected bool bDispose螳御ｺ貂医∩_CPrivateFastFont;
+ //-----------------
+ #endregion
+ }
+}
diff --git a/TJAPlayer3/Common/CPrivateFont.cs b/TJAPlayer3/Common/CPrivateFont.cs
new file mode 100644
index 00000000..c154eee3
--- /dev/null
+++ b/TJAPlayer3/Common/CPrivateFont.cs
@@ -0,0 +1,1121 @@
+ｻｿusing System;
+using System.Collections.Generic;
+using System.Text;
+using System.IO;
+using System.Runtime.InteropServices;
+using System.Drawing;
+using System.Drawing.Drawing2D;
+using System.Diagnostics;
+using SlimDX;
+using FDK;
+using System.Linq;
+
+namespace TJAPlayer3
+{
+ ///
+ /// 繝励Λ繧､繝吶ｼ繝医ヵ繧ｩ繝ｳ繝医〒縺ｮ謠冗判繧呈桶縺繧ｯ繝ｩ繧ｹ縲
+ ///
+ /// 繝輔か繝ｳ繝医ヵ繧｡繧､繝ｫ縺瑚ｦ九▽縺九ｉ縺ｪ縺譎ゅ↓萓句､也匱逕
+ /// 繧ｹ繧ｿ繧､繝ｫ謖螳壻ｸ肴ｭ｣譎ゅ↓萓句､也匱逕
+ ///
+ /// 邁｡蜊倥↑菴ｿ縺譁ｹ
+ /// CPrivateFont prvFont = new CPrivateFont( CSkin.Path( @"Graphics\fonts\mplus-1p-bold.ttf" ), 36 ); // 繝励Λ繧､繝吶ｼ繝医ヵ繧ｩ繝ｳ繝
+ /// 縺ｨ縺
+ /// CPrivateFont prvFont = new CPrivateFont( new FontFamily("MS UI Gothic"), 36, FontStyle.Bold ); // 繧ｷ繧ｹ繝繝繝輔か繝ｳ繝
+ /// 縺ｨ縺九＠縺滉ｸ翫〒縲
+ /// Bitmap bmp = prvFont.DrawPrivateFont( "ABCDE", Color.White, Color.Black ); // 繝輔か繝ｳ繝郁牡ｼ晉區縲∫ｸ√ｮ濶ｲｼ晞ｻ偵ｮ萓九らｸ√ｮ濶ｲ縺ｯ逵∫払蜿ｯ閭ｽ
+ /// 縺ｨ縺
+ /// Bitmap bmp = prvFont.DrawPrivateFont( "ABCDE", Color.White, Color.Black, Color.Yellow, Color.OrangeRed ); // 荳贋ｸ九げ繝ｩ繝繝ｼ繧ｷ繝ｧ繝ｳ(Yellow竊丹rangeRed)
+ /// 縺ｨ縺九＠縺ｦ縲
+ /// CTexture ctBmp = CDTXMania.t繝繧ｯ繧ｹ繝√Ε縺ｮ逕滓( bmp, false );
+ /// ctBMP.t2D謠冗判( ｽ橸ｽ橸ｽ );
+ /// 縺ｧ陦ｨ遉ｺ縺励※縺上□縺輔＞縲
+ ///
+ /// 豕ｨ諢冗せ
+ /// 莉ｻ諢上ｮ繝輔か繝ｳ繝医〒縺ｮ繝ｬ繝ｳ繝繝ｪ繝ｳ繧ｰ縺ｯ邨先ｧ玖ｲ闕ｷ縺悟､ｧ縺阪＞縺ｮ縺ｧ縲√↑繧九∋ｽ九↑繧画緒逕ｻ繝輔Ξ繝ｼ繝豈弱↓繝輔か繝ｳ繝医ｒ蜀阪Ξ繝ｳ繝繝ｪ繝ｳ繧ｰ縺吶ｋ繧医≧縺ｪ縺薙→縺ｯ縺帙★縲
+ /// 荳譌ｦ繝ｬ繝ｳ繝繝ｪ繝ｳ繧ｰ縺励◆繧ゅｮ繧呈緒逕ｻ縺ｫ菴ｿ縺蝗槭☆繧医≧縺ｫ縺励※縺上□縺輔＞縲
+ /// 縺ｾ縺溘髟ｷ縺譁蟄怜励ｒ荳弱∴繧九→縲∬ｿ斐＆繧後ｋBitmap繧よｨｪ髟ｷ縺ｫ縺ｪ繧翫∪縺吶ゅ％縺ｮ讓ｪ髟ｷ逕ｻ蜒上ｒ縺昴ｮ縺ｾ縺ｾ繝繧ｯ繧ｹ繝√Ε縺ｨ縺励※菴ｿ縺縺ｨ縲
+ /// 蜿､縺ПC縺ｧ蝠城｡後ｒ逋ｺ逕溘＆縺帙ｄ縺吶＞縺ｧ縺吶ゅ％繧後ｒ蝗樣∩縺吶ｋ縺ｫ縺ｯ縲∽ｸ譌ｦBitmap縺ｨ縺励※蜿門ｾ励＠縺溘ｮ縺｡縲256pix繧512pix縺ｧ蛻蜑ｲ縺励※
+ /// 繝繧ｯ繧ｹ繝√Ε縺ｫ螳夂ｾｩ縺吶ｋ繧医≧縺ｫ縺励※縺上□縺輔＞縲
+ ///
+
+ #region In諡｡蠑ｵ蟄
+ public static class StringExtensions
+ {
+ public static bool In(this string str, params string[] param)
+ {
+ return param.Contains(str);
+ }
+ }
+ #endregion
+
+ public class CPrivateFont : IDisposable
+ {
+ #region [ 繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ ]
+ public CPrivateFont( FontFamily fontfamily, int pt, FontStyle style )
+ {
+ Initialize( null, fontfamily, pt, style );
+ }
+ public CPrivateFont( FontFamily fontfamily, int pt )
+ {
+ Initialize( null, fontfamily, pt, FontStyle.Regular );
+ }
+ public CPrivateFont( string fontpath, int pt, FontStyle style )
+ {
+ Initialize( fontpath, null, pt, style );
+ }
+ public CPrivateFont( string fontpath, int pt )
+ {
+ Initialize( fontpath, null, pt, FontStyle.Regular );
+ }
+ public CPrivateFont()
+ {
+ //throw new ArgumentException("CPrivateFont: 蠑墓焚縺後≠繧九さ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ繧剃ｽｿ逕ｨ縺励※縺上□縺輔＞縲");
+ }
+ #endregion
+
+ protected void Initialize( string fontpath, FontFamily fontfamily, int pt, FontStyle style )
+ {
+ this._pfc = null;
+ this._fontfamily = null;
+ this._font = null;
+ this._pt = pt;
+ this._rectStrings = new Rectangle(0, 0, 0, 0);
+ this._ptOrigin = new Point(0, 0);
+ this.bDispose螳御ｺ貂医∩ = false;
+
+ if (fontfamily != null)
+ {
+ this._fontfamily = fontfamily;
+ }
+ else
+ {
+ try
+ {
+ this._pfc = new System.Drawing.Text.PrivateFontCollection(); //PrivateFontCollection繧ｪ繝悶ず繧ｧ繧ｯ繝医ｒ菴懈舌☆繧
+ this._pfc.AddFontFile(fontpath); //PrivateFontCollection縺ｫ繝輔か繝ｳ繝医ｒ霑ｽ蜉縺吶ｋ
+ _fontfamily = _pfc.Families[0];
+ }
+ catch (System.IO.FileNotFoundException)
+ {
+ Trace.TraceWarning("繝励Λ繧､繝吶ｼ繝医ヵ繧ｩ繝ｳ繝医ｮ霑ｽ蜉縺ｫ螟ｱ謨励＠縺ｾ縺励◆({0})縲ゆｻ｣繧上ｊ縺ｫMS UI Gothic縺ｮ菴ｿ逕ｨ繧定ｩｦ縺ｿ縺ｾ縺吶", fontpath);
+ //throw new FileNotFoundException( "繝励Λ繧､繝吶ｼ繝医ヵ繧ｩ繝ｳ繝医ｮ霑ｽ蜉縺ｫ螟ｱ謨励＠縺ｾ縺励◆縲({0})", Path.GetFileName( fontpath ) );
+ //return;
+ _fontfamily = null;
+ }
+
+ //foreach ( FontFamily ff in _pfc.Families )
+ //{
+ // Debug.WriteLine( "fontname=" + ff.Name );
+ // if ( ff.Name == Path.GetFileNameWithoutExtension( fontpath ) )
+ // {
+ // _fontfamily = ff;
+ // break;
+ // }
+ //}
+ //if ( _fontfamily == null )
+ //{
+ // Trace.TraceError( "繝励Λ繧､繝吶ｼ繝医ヵ繧ｩ繝ｳ繝医ｮ霑ｽ蜉蠕後∵､懃ｴ｢縺ｫ螟ｱ謨励＠縺ｾ縺励◆縲({0})", fontpath );
+ // return;
+ //}
+ }
+
+ // 謖螳壹＆繧後◆繝輔か繝ｳ繝医せ繧ｿ繧､繝ｫ縺碁←逕ｨ縺ｧ縺阪↑縺蝣ｴ蜷医ｯ縲√ヵ繧ｩ繝ｳ繝亥縺ｧ螳夂ｾｩ縺輔ｌ縺ｦ縺繧九せ繧ｿ繧､繝ｫ縺九ｉ蛟呵｣懊ｒ驕ｸ繧薙〒菴ｿ逕ｨ縺吶ｋ
+ // 菴輔ｂ繧ｹ繧ｿ繧､繝ｫ縺御ｽｿ縺医↑縺繧医≧縺ｪ繝輔か繝ｳ繝医↑繧峨∽ｾ句､悶ｒ蜃ｺ縺吶
+ if (_fontfamily != null)
+ {
+ if (!_fontfamily.IsStyleAvailable(style))
+ {
+ FontStyle[] FS = { FontStyle.Regular, FontStyle.Bold, FontStyle.Italic, FontStyle.Underline, FontStyle.Strikeout };
+ style = FontStyle.Regular | FontStyle.Bold | FontStyle.Italic | FontStyle.Underline | FontStyle.Strikeout; // null髱櫁ｨｱ螳ｹ蝙九↑縺ｮ縺ｧ縲∽ｻ｣繧上ｊ縺ｫ蜈ｨ逶帙ｒNG繝ｯ繝ｼ繝峨↓險ｭ螳
+ foreach (FontStyle ff in FS)
+ {
+ if (this._fontfamily.IsStyleAvailable(ff))
+ {
+ style = ff;
+ Trace.TraceWarning("繝輔か繝ｳ繝{0}縺ｸ縺ｮ繧ｹ繧ｿ繧､繝ｫ謖螳壹ｒ縲＋1}縺ｫ螟画峩縺励∪縺励◆縲", Path.GetFileName(fontpath), style.ToString());
+ break;
+ }
+ }
+ if (style == (FontStyle.Regular | FontStyle.Bold | FontStyle.Italic | FontStyle.Underline | FontStyle.Strikeout))
+ {
+ Trace.TraceWarning("繝輔か繝ｳ繝{0}縺ｯ驕ｩ蛻縺ｪ繧ｹ繧ｿ繧､繝ｫ{1}繧帝∈謚槭〒縺阪∪縺帙ｓ縺ｧ縺励◆縲", Path.GetFileName(fontpath), style.ToString());
+ }
+ }
+ //this._font = new Font(this._fontfamily, pt, style); //PrivateFontCollection縺ｮ蜈磯ｭ縺ｮ繝輔か繝ｳ繝医ｮFont繧ｪ繝悶ず繧ｧ繧ｯ繝医ｒ菴懈舌☆繧
+ float emSize = pt * 96.0f / 72.0f;
+ this._font = new Font(this._fontfamily, emSize, style, GraphicsUnit.Pixel); //PrivateFontCollection縺ｮ蜈磯ｭ縺ｮ繝輔か繝ｳ繝医ｮFont繧ｪ繝悶ず繧ｧ繧ｯ繝医ｒ菴懈舌☆繧
+ //HighDPI蟇ｾ蠢懊ｮ縺溘ａ縲｝x繧ｵ繧､繧ｺ縺ｧ謖螳
+ }
+ else
+ // 繝輔か繝ｳ繝医ヵ繧｡繧､繝ｫ縺瑚ｦ九▽縺九ｉ縺ｪ縺九▲縺溷ｴ蜷 (MS PGothic繧剃ｻ｣繧上ｊ縺ｫ謖螳壹☆繧)
+ {
+ float emSize = pt * 96.0f / 72.0f;
+ this._font = new Font("MS UI Gothic", emSize, style, GraphicsUnit.Pixel); //MS PGothic縺ｮFont繧ｪ繝悶ず繧ｧ繧ｯ繝医ｒ菴懈舌☆繧
+ FontFamily[] ffs = new System.Drawing.Text.InstalledFontCollection().Families;
+ int lcid = System.Globalization.CultureInfo.GetCultureInfo("en-us").LCID;
+ foreach (FontFamily ff in ffs)
+ {
+ // Trace.WriteLine( lcid ) );
+ if (ff.GetName(lcid) == "MS UI Gothic")
+ {
+ this._fontfamily = ff;
+ Trace.TraceInformation("MS UI Gothic繧剃ｻ｣繧上ｊ縺ｫ謖螳壹＠縺ｾ縺励◆縲");
+ return;
+ }
+ }
+ throw new FileNotFoundException("繝励Λ繧､繝吶ｼ繝医ヵ繧ｩ繝ｳ繝医ｮ霑ｽ蜉縺ｫ螟ｱ謨励＠縲｀S UI Gothic縺ｧ縺ｮ莉｣譖ｿ蜃ｦ逅縺ｫ繧ょ､ｱ謨励＠縺ｾ縺励◆縲({0})", Path.GetFileName(fontpath));
+ }
+ }
+
+ [Flags]
+ public enum DrawMode
+ {
+ Normal,
+ Edge,
+ Gradation,
+ Vertical
+ }
+
+ #region [ DrawPrivateFont縺ｮ繧ｪ繝ｼ繝舌ｼ繝ｭ繝ｼ繝臥ｾ､ ]
+ ///
+ /// 譁蟄怜励ｒ謠冗判縺励◆繝繧ｯ繧ｹ繝√Ε繧定ｿ斐☆
+ ///
+ /// 謠冗判譁蟄怜
+ /// 謠冗判濶ｲ
+ /// 謠冗判貂医ユ繧ｯ繧ｹ繝√Ε
+ public Bitmap DrawPrivateFont( string drawstr, Color fontColor )
+ {
+ return DrawPrivateFont( drawstr, DrawMode.Normal, fontColor, Color.White, Color.White, Color.White );
+ }
+
+ ///
+ /// 譁蟄怜励ｒ謠冗判縺励◆繝繧ｯ繧ｹ繝√Ε繧定ｿ斐☆
+ ///
+ /// 謠冗判譁蟄怜
+ /// 謠冗判濶ｲ
+ /// 邵∝叙濶ｲ
+ /// 謠冗判貂医ユ繧ｯ繧ｹ繝√Ε
+ public Bitmap DrawPrivateFont( string drawstr, Color fontColor, Color edgeColor )
+ {
+ return DrawPrivateFont( drawstr, DrawMode.Edge, fontColor, edgeColor, Color.White, Color.White );
+ }
+
+ ///
+ /// 譁蟄怜励ｒ謠冗判縺励◆繝繧ｯ繧ｹ繝√Ε繧定ｿ斐☆
+ ///
+ /// 謠冗判譁蟄怜
+ /// 謠冗判濶ｲ
+ /// 繧ｰ繝ｩ繝繝ｼ繧ｷ繝ｧ繝ｳ 荳雁ｴ縺ｮ濶ｲ
+ /// 繧ｰ繝ｩ繝繝ｼ繧ｷ繝ｧ繝ｳ 荳句ｴ縺ｮ濶ｲ
+ /// 謠冗判貂医ユ繧ｯ繧ｹ繝√Ε
+ //public Bitmap DrawPrivateFont( string drawstr, Color fontColor, Color gradationTopColor, Color gradataionBottomColor )
+ //{
+ // return DrawPrivateFont( drawstr, DrawMode.Gradation, fontColor, Color.White, gradationTopColor, gradataionBottomColor );
+ //}
+
+ ///
+ /// 譁蟄怜励ｒ謠冗判縺励◆繝繧ｯ繧ｹ繝√Ε繧定ｿ斐☆
+ ///
+ /// 謠冗判譁蟄怜
+ /// 謠冗判濶ｲ
+ /// 邵∝叙濶ｲ
+ /// 繧ｰ繝ｩ繝繝ｼ繧ｷ繝ｧ繝ｳ 荳雁ｴ縺ｮ濶ｲ
+ /// 繧ｰ繝ｩ繝繝ｼ繧ｷ繝ｧ繝ｳ 荳句ｴ縺ｮ濶ｲ
+ /// 謠冗判貂医ユ繧ｯ繧ｹ繝√Ε
+ public Bitmap DrawPrivateFont( string drawstr, Color fontColor, Color edgeColor, Color gradationTopColor, Color gradataionBottomColor )
+ {
+ return DrawPrivateFont( drawstr, DrawMode.Edge | DrawMode.Gradation, fontColor, edgeColor, gradationTopColor, gradataionBottomColor );
+ }
+
+#if 縺薙■繧峨ｯ菴ｿ繧上↑縺 // (Bitmap縺ｧ縺ｯ縺ｪ縺上，Texture繧定ｿ斐☆迚)
+ ///
+ /// 譁蟄怜励ｒ謠冗判縺励◆繝繧ｯ繧ｹ繝√Ε繧定ｿ斐☆
+ ///
+ /// 謠冗判譁蟄怜
+ /// 謠冗判濶ｲ
+ /// 謠冗判貂医ユ繧ｯ繧ｹ繝√Ε
+ public CTexture DrawPrivateFont( string drawstr, Color fontColor )
+ {
+ Bitmap bmp = DrawPrivateFont( drawstr, DrawMode.Normal, fontColor, Color.White, Color.White, Color.White );
+ return CDTXMania.t繝繧ｯ繧ｹ繝√Ε縺ｮ逕滓( bmp, false );
+ }
+
+ ///
+ /// 譁蟄怜励ｒ謠冗判縺励◆繝繧ｯ繧ｹ繝√Ε繧定ｿ斐☆
+ ///
+ /// 謠冗判譁蟄怜
+ /// 謠冗判濶ｲ
+ /// 邵∝叙濶ｲ
+ /// 謠冗判貂医ユ繧ｯ繧ｹ繝√Ε
+ public CTexture DrawPrivateFont( string drawstr, Color fontColor, Color edgeColor )
+ {
+ Bitmap bmp = DrawPrivateFont( drawstr, DrawMode.Edge, fontColor, edgeColor, Color.White, Color.White );
+ return CDTXMania.t繝繧ｯ繧ｹ繝√Ε縺ｮ逕滓( bmp, false );
+ }
+
+ ///
+ /// 譁蟄怜励ｒ謠冗判縺励◆繝繧ｯ繧ｹ繝√Ε繧定ｿ斐☆
+ ///
+ /// 謠冗判譁蟄怜
+ /// 謠冗判濶ｲ
+ /// 繧ｰ繝ｩ繝繝ｼ繧ｷ繝ｧ繝ｳ 荳雁ｴ縺ｮ濶ｲ
+ /// 繧ｰ繝ｩ繝繝ｼ繧ｷ繝ｧ繝ｳ 荳句ｴ縺ｮ濶ｲ
+ /// 謠冗判貂医ユ繧ｯ繧ｹ繝√Ε
+ //public CTexture DrawPrivateFont( string drawstr, Color fontColor, Color gradationTopColor, Color gradataionBottomColor )
+ //{
+ // Bitmap bmp = DrawPrivateFont( drawstr, DrawMode.Gradation, fontColor, Color.White, gradationTopColor, gradataionBottomColor );
+ // return CDTXMania.t繝繧ｯ繧ｹ繝√Ε縺ｮ逕滓( bmp, false );
+ //}
+
+ ///
+ /// 譁蟄怜励ｒ謠冗判縺励◆繝繧ｯ繧ｹ繝√Ε繧定ｿ斐☆
+ ///
+ /// 謠冗判譁蟄怜
+ /// 謠冗判濶ｲ
+ /// 邵∝叙濶ｲ
+ /// 繧ｰ繝ｩ繝繝ｼ繧ｷ繝ｧ繝ｳ 荳雁ｴ縺ｮ濶ｲ
+ /// 繧ｰ繝ｩ繝繝ｼ繧ｷ繝ｧ繝ｳ 荳句ｴ縺ｮ濶ｲ
+ /// 謠冗判貂医ユ繧ｯ繧ｹ繝√Ε
+ public CTexture DrawPrivateFont( string drawstr, Color fontColor, Color edgeColor, Color gradationTopColor, Color gradataionBottomColor )
+ {
+ Bitmap bmp = DrawPrivateFont( drawstr, DrawMode.Edge | DrawMode.Gradation, fontColor, edgeColor, gradationTopColor, gradataionBottomColor );
+ return CDTXMania.t繝繧ｯ繧ｹ繝√Ε縺ｮ逕滓( bmp, false );
+ }
+#endif
+ #endregion
+
+ protected Bitmap DrawPrivateFont_E(string drawstr, DrawMode drawmode, Color fontColor, Color edgeColor, Color gradationTopColor, Color gradationBottomColor, int edgePt)
+ {
+ if (this._fontfamily == null || drawstr == null || drawstr == "")
+ {
+ // null繧定ｿ斐☆縺ｨ縲√◎縺ｮ蠕恵mp竊稚exture蜃ｦ逅繧縲》exture縺ｮ繧ｵ繧､繧ｺ繧定ｦ九※__縺ｮ蜃ｦ逅縺ｧ蜈ｨ驛ｨ萓句､悶′逋ｺ逕溘☆繧九％縺ｨ縺ｫ縺ｪ繧九
+ // 縺昴ｌ縺ｯ髱槫ｸｸ縺ｫ髱｢蛟偵↑縺ｮ縺ｧ縲∵怙蟆城剞縺ｮbitmap繧定ｿ斐＠縺ｦ縺励∪縺縲
+ // 縺ｾ縺壹ｯ縺薙ｮ莉墓ｧ倥〒騾ｲ繧√∪縺吶′縲∝撫鬘梧怏繧後ｰ(荳贋ｽ榊ｴ縺九ｉ繧ｨ繝ｩ繝ｼ讀懷ｺ縺悟ｿ隕√〒縺ゅｌ縺ｰ)萓句､悶ｒ蜃ｺ縺励◆繧翫お繝ｩ繝ｼ迥ｶ諷九〒縺ゅｋ繝励Ο繝代ユ繧｣繧貞ｮ夂ｾｩ縺吶ｋ縺ｪ繧頑､懆ｨ弱＠縺ｾ縺吶
+ if (drawstr != "")
+ {
+ Trace.TraceWarning("DrawPrivateFont()縺ｮ蜈･蜉帑ｸ肴ｭ｣縲よ怙蟆丞､縺ｮbitmap繧定ｿ斐＠縺ｾ縺吶");
+ }
+ _rectStrings = new Rectangle(0, 0, 0, 0);
+ _ptOrigin = new Point(0, 0);
+ return new Bitmap(1, 1);
+ }
+ bool bEdge = ((drawmode & DrawMode.Edge) == DrawMode.Edge);
+ bool bGradation = ((drawmode & DrawMode.Gradation) == DrawMode.Gradation);
+
+ // 邵∝叙繧翫ｮ邵√ｮ繧ｵ繧､繧ｺ縺ｯ縲√→繧翫≠縺医★繝輔か繝ｳ繝医ｮ螟ｧ縺阪＆縺ｮ1/4縺ｨ縺吶ｋ
+ //int nEdgePt = (bEdge)? _pt / 4 : 0;
+ //int nEdgePt = (bEdge) ? (_pt / 3) : 0; // 邵∝叙繧翫′蟆代↑縺吶℃繧九→縺縺諢剰ｦ九′螟壹°縺｣縺溘◆繧∝､画峩縲 (AioiLight)
+ int nEdgePt = (bEdge) ? (10 * _pt / edgePt) : 0; //SkinConfig縺ｫ縺ｦ險ｭ螳壼庄閭ｽ縺ｫ(rhimm)
+
+ // 謠冗判繧ｵ繧､繧ｺ繧呈ｸｬ螳壹☆繧
+ Size stringSize = System.Windows.Forms.TextRenderer.MeasureText(drawstr, this._font, new Size(int.MaxValue, int.MaxValue),
+ System.Windows.Forms.TextFormatFlags.NoPrefix |
+ System.Windows.Forms.TextFormatFlags.NoPadding
+ );
+ stringSize.Width += 10; //2015.04.01 kairera0467 ROTTERDAM NATION縺ｮ謠冗判繧ｵ繧､繧ｺ縺後≧縺ｾ縺上＞縺九ｓ縺ｮ縺ｧ縲
+ stringSize.Height += 5;
+
+ //蜿門ｾ励＠縺滓緒逕ｻ繧ｵ繧､繧ｺ繧貞渕縺ｫ縲∵緒逕ｻ蜈医ｮbitmap繧剃ｽ懈舌☆繧
+ Bitmap bmp = new Bitmap(stringSize.Width + nEdgePt * 2, stringSize.Height + nEdgePt * 3);
+ bmp.MakeTransparent();
+ Graphics g = Graphics.FromImage(bmp);
+ g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.HighQuality;
+
+ StringFormat sf = new StringFormat();
+ sf.LineAlignment = StringAlignment.Far; // 逕ｻ髱｢荳矩Κｼ亥桙逶ｴ譁ｹ蜷台ｽ咲ｽｮｼ
+ sf.Alignment = StringAlignment.Center; // 逕ｻ髱｢荳ｭ螟ｮｼ域ｰｴ蟷ｳ譁ｹ蜷台ｽ咲ｽｮｼ
+ sf.FormatFlags = StringFormatFlags.NoWrap; // 縺ｩ繧薙↑縺ｫ髟ｷ縺上※蜊倩ｪ槭ｮ蛹ｺ蛻繧翫′濶ｯ縺上※繧よ隼陦後＠縺ｪ縺 (AioiLight)
+ sf.Trimming = StringTrimming.None; // 縺ｩ繧薙↑縺ｫ髟ｷ縺上※繧ゅヨ繝ｪ繝溘Φ繧ｰ縺励↑縺 (AioiLight)
+ // 繝ｬ繧､繧｢繧ｦ繝域棧
+ Rectangle r = new Rectangle(0, 0, stringSize.Width + nEdgePt * 2 + (TJAPlayer3.Skin.Text_Correction_X * stringSize.Width / 100), stringSize.Height + nEdgePt * 2 + (TJAPlayer3.Skin.Text_Correction_Y * stringSize.Height / 100));
+
+ if (bEdge) // 邵∝叙繧頑怏繧翫ｮ謠冗判
+ {
+ // DrawPath縺ｧ縲√昴う繝ｳ繝医し繧､繧ｺ繧剃ｽｿ縺｣縺ｦ謠冗判縺吶ｋ縺溘ａ縺ｫ縲．PI繧剃ｽｿ縺｣縺ｦ蜊倅ｽ榊､画鋤縺吶ｋ
+ // (縺薙ｌ繧偵＠縺ｪ縺縺ｨ縲∝腰菴阪′驕輔≧縺溘ａ縺ｫ縲∝ｰ上＆繧√↓謠冗判縺輔ｌ縺ｦ縺励∪縺)
+ float sizeInPixels = _font.SizeInPoints * g.DpiY / 72; // 1 inch = 72 points
+
+ System.Drawing.Drawing2D.GraphicsPath gp = new System.Drawing.Drawing2D.GraphicsPath();
+ gp.AddString(drawstr, this._fontfamily, (int)this._font.Style, sizeInPixels, r, sf);
+
+ // 邵∝叙繧翫ｒ謠冗判縺吶ｋ
+ Pen p = new Pen(edgeColor, nEdgePt);
+ p.LineJoin = System.Drawing.Drawing2D.LineJoin.Round;
+ g.DrawPath(p, gp);
+
+ // 蝪励ｊ縺､縺ｶ縺
+ Brush br;
+ if (bGradation)
+ {
+ br = new LinearGradientBrush(r, gradationTopColor, gradationBottomColor, LinearGradientMode.Vertical);
+ }
+ else
+ {
+ br = new SolidBrush(fontColor);
+ }
+ g.FillPath(br, gp);
+
+ if (br != null) br.Dispose(); br = null;
+ if (p != null) p.Dispose(); p = null;
+ if (gp != null) gp.Dispose(); gp = null;
+ }
+ else
+ {
+ // 邵∝叙繧翫↑縺励ｮ謠冗判
+ System.Windows.Forms.TextRenderer.DrawText(g, drawstr, _font, new Point(0, 0), fontColor);
+ }
+
+ _rectStrings = new Rectangle(0, 0, stringSize.Width, stringSize.Height);
+ _ptOrigin = new Point(nEdgePt * 2, nEdgePt * 2);
+
+
+ #region [ 繝ｪ繧ｽ繝ｼ繧ｹ繧定ｧ｣謾ｾ縺吶ｋ ]
+ if (sf != null) sf.Dispose(); sf = null;
+ if (g != null) g.Dispose(); g = null;
+ #endregion
+
+ return bmp;
+ }
+
+
+ ///
+ /// 譁蟄怜励ｒ謠冗判縺励◆繝繧ｯ繧ｹ繝√Ε繧定ｿ斐☆(繝｡繧､繝ｳ蜃ｦ逅)
+ ///
+ /// 謠冗判縺輔ｌ縺滄伜沺
+ /// 謠冗判譁蟄怜
+ /// 謠冗判譁蟄怜
+ /// 謠冗判繝｢繝ｼ繝
+ /// 謠冗判濶ｲ
+ /// 邵∝叙濶ｲ
+ /// 繧ｰ繝ｩ繝繝ｼ繧ｷ繝ｧ繝ｳ 荳雁ｴ縺ｮ濶ｲ
+ /// 繧ｰ繝ｩ繝繝ｼ繧ｷ繝ｧ繝ｳ 荳句ｴ縺ｮ濶ｲ
+ /// 謠冗判貂医ユ繧ｯ繧ｹ繝√Ε
+ protected Bitmap DrawPrivateFont(string drawstr, DrawMode drawmode, Color fontColor, Color edgeColor, Color gradationTopColor, Color gradationBottomColor)
+ {
+ int Interval = 5;
+
+ if (this._fontfamily == null || drawstr == null || drawstr == "" || drawstr == " " || drawstr == "縲")
+ {
+ // null繧定ｿ斐☆縺ｨ縲√◎縺ｮ蠕恵mp竊稚exture蜃ｦ逅繧縲》exture縺ｮ繧ｵ繧､繧ｺ繧定ｦ九※__縺ｮ蜃ｦ逅縺ｧ蜈ｨ驛ｨ萓句､悶′逋ｺ逕溘☆繧九％縺ｨ縺ｫ縺ｪ繧九
+ // 縺昴ｌ縺ｯ髱槫ｸｸ縺ｫ髱｢蛟偵↑縺ｮ縺ｧ縲∵怙蟆城剞縺ｮbitmap繧定ｿ斐＠縺ｦ縺励∪縺縲
+ // 縺ｾ縺壹ｯ縺薙ｮ莉墓ｧ倥〒騾ｲ繧√∪縺吶′縲∝撫鬘梧怏繧後ｰ(荳贋ｽ榊ｴ縺九ｉ繧ｨ繝ｩ繝ｼ讀懷ｺ縺悟ｿ隕√〒縺ゅｌ縺ｰ)萓句､悶ｒ蜃ｺ縺励◆繧翫お繝ｩ繝ｼ迥ｶ諷九〒縺ゅｋ繝励Ο繝代ユ繧｣繧貞ｮ夂ｾｩ縺吶ｋ縺ｪ繧頑､懆ｨ弱＠縺ｾ縺吶
+ if (drawstr != "")
+ {
+ Trace.TraceWarning("DrawPrivateFont()縺ｮ蜈･蜉帑ｸ肴ｭ｣縲よ怙蟆丞､縺ｮbitmap繧定ｿ斐＠縺ｾ縺吶");
+ }
+ _rectStrings = new Rectangle(0, 0, 0, 0);
+ _ptOrigin = new Point(0, 0);
+ return new Bitmap(1, 1);
+ }
+ bool bEdge = ((drawmode & DrawMode.Edge) == DrawMode.Edge);
+ bool bGradation = ((drawmode & DrawMode.Gradation) == DrawMode.Gradation);
+
+ // 邵∝叙繧翫ｮ邵√ｮ繧ｵ繧､繧ｺ縺ｯ縲√→繧翫≠縺医★繝輔か繝ｳ繝医ｮ螟ｧ縺阪＆縺ｮ1/4縺ｨ縺吶ｋ
+ //int nEdgePt = (bEdge)? _pt / 4 : 0;
+ //int nEdgePt = (bEdge) ? (_pt / 3) : 0; // 邵∝叙繧翫′蟆代↑縺吶℃繧九→縺縺諢剰ｦ九′螟壹°縺｣縺溘◆繧∝､画峩縲 (AioiLight)
+ int nEdgePt = (bEdge) ? (10 * _pt / TJAPlayer3.Skin.Font_Edge_Ratio) : 0; //SkinConfig縺ｫ縺ｦ險ｭ螳壼庄閭ｽ縺ｫ(rhimm)
+
+ // 謠冗判繧ｵ繧､繧ｺ繧呈ｸｬ螳壹☆繧
+ Size stringSize = System.Windows.Forms.TextRenderer.MeasureText(drawstr, this._font, new Size(int.MaxValue, int.MaxValue),
+ System.Windows.Forms.TextFormatFlags.NoPrefix |
+ System.Windows.Forms.TextFormatFlags.NoPadding
+ );
+ stringSize.Width += 10; //2015.04.01 kairera0467 ROTTERDAM NATION縺ｮ謠冗判繧ｵ繧､繧ｺ縺後≧縺ｾ縺上＞縺九ｓ縺ｮ縺ｧ縲
+ stringSize.Height += 5;
+
+ //蜿門ｾ励＠縺滓緒逕ｻ繧ｵ繧､繧ｺ繧貞渕縺ｫ縲∵緒逕ｻ蜈医ｮbitmap繧剃ｽ懈舌☆繧
+ Bitmap bmp = new Bitmap(stringSize.Width + nEdgePt * 2, stringSize.Height + nEdgePt * 2);
+ bmp.MakeTransparent();
+ Graphics g = Graphics.FromImage(bmp);
+ g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.HighQuality;
+
+ StringFormat sf = new StringFormat();
+ sf.LineAlignment = StringAlignment.Far; // 逕ｻ髱｢荳矩Κｼ亥桙逶ｴ譁ｹ蜷台ｽ咲ｽｮｼ
+ sf.Alignment = StringAlignment.Center; // 逕ｻ髱｢荳ｭ螟ｮｼ域ｰｴ蟷ｳ譁ｹ蜷台ｽ咲ｽｮｼ
+ sf.FormatFlags = StringFormatFlags.NoWrap; // 縺ｩ繧薙↑縺ｫ髟ｷ縺上※蜊倩ｪ槭ｮ蛹ｺ蛻繧翫′濶ｯ縺上※繧よ隼陦後＠縺ｪ縺 (AioiLight)
+ sf.Trimming = StringTrimming.None; // 縺ｩ繧薙↑縺ｫ髟ｷ縺上※繧ゅヨ繝ｪ繝溘Φ繧ｰ縺励↑縺 (AioiLight)
+ // 繝ｬ繧､繧｢繧ｦ繝域棧
+ Rectangle r = new Rectangle(0, 0, stringSize.Width + nEdgePt * 2 + (TJAPlayer3.Skin.Text_Correction_X * stringSize.Width / 100), stringSize.Height + nEdgePt * 2 + (TJAPlayer3.Skin.Text_Correction_Y * stringSize.Height / 100));
+
+ if (bEdge) // 邵∝叙繧頑怏繧翫ｮ謠冗判
+ {
+ // DrawPath縺ｧ縲√昴う繝ｳ繝医し繧､繧ｺ繧剃ｽｿ縺｣縺ｦ謠冗判縺吶ｋ縺溘ａ縺ｫ縲．PI繧剃ｽｿ縺｣縺ｦ蜊倅ｽ榊､画鋤縺吶ｋ
+ // (縺薙ｌ繧偵＠縺ｪ縺縺ｨ縲∝腰菴阪′驕輔≧縺溘ａ縺ｫ縲∝ｰ上＆繧√↓謠冗判縺輔ｌ縺ｦ縺励∪縺)
+ float sizeInPixels = _font.SizeInPoints * g.DpiY / 72; // 1 inch = 72 points
+
+ System.Drawing.Drawing2D.GraphicsPath gp = new System.Drawing.Drawing2D.GraphicsPath();
+ gp.AddString(drawstr, this._fontfamily, (int)this._font.Style, sizeInPixels, r, sf);
+
+ // 邵∝叙繧翫ｒ謠冗判縺吶ｋ
+ Pen p = new Pen(edgeColor, nEdgePt);
+ p.LineJoin = System.Drawing.Drawing2D.LineJoin.Round;
+ g.DrawPath(p, gp);
+
+ // 蝪励ｊ縺､縺ｶ縺
+ Brush br;
+ if (bGradation)
+ {
+ br = new LinearGradientBrush(r, gradationTopColor, gradationBottomColor, LinearGradientMode.Vertical);
+ }
+ else
+ {
+ br = new SolidBrush(fontColor);
+ }
+ g.FillPath(br, gp);
+
+ if (br != null) br.Dispose(); br = null;
+ if (p != null) p.Dispose(); p = null;
+ if (gp != null) gp.Dispose(); gp = null;
+ }
+ else
+ {
+ // 邵∝叙繧翫↑縺励ｮ謠冗判
+ System.Windows.Forms.TextRenderer.DrawText(g, drawstr, _font, new Point(0, 0), fontColor);
+ }
+
+#if debug陦ｨ遉ｺ
+ g.DrawRectangle( new Pen( Color.White, 1 ), new Rectangle( 1, 1, stringSize.Width-1, stringSize.Height-1 ) );
+ g.DrawRectangle( new Pen( Color.Green, 1 ), new Rectangle( 0, 0, bmp.Width - 1, bmp.Height - 1 ) );
+#endif
+ _rectStrings = new Rectangle(0, 0, stringSize.Width, stringSize.Height);
+ _ptOrigin = new Point(nEdgePt * 2, nEdgePt * 2);
+
+
+ #region [ 繝ｪ繧ｽ繝ｼ繧ｹ繧定ｧ｣謾ｾ縺吶ｋ ]
+ if (sf != null) sf.Dispose(); sf = null;
+ if (g != null) g.Dispose(); g = null;
+ #endregion
+
+ return bmp;
+ }
+
+ ///
+ /// 譁蟄怜励ｒ謠冗判縺励◆繝繧ｯ繧ｹ繝√Ε繧定ｿ斐☆(繝｡繧､繝ｳ蜃ｦ逅)
+ ///
+ /// 謠冗判縺輔ｌ縺滄伜沺
+ /// 謠冗判譁蟄怜
+ /// 謠冗判譁蟄怜
+ /// 謠冗判繝｢繝ｼ繝
+ /// 謠冗判濶ｲ
+ /// 邵∝叙濶ｲ
+ /// 繧ｰ繝ｩ繝繝ｼ繧ｷ繝ｧ繝ｳ 荳雁ｴ縺ｮ濶ｲ
+ /// 繧ｰ繝ｩ繝繝ｼ繧ｷ繝ｧ繝ｳ 荳句ｴ縺ｮ濶ｲ
+ /// 謠冗判貂医ユ繧ｯ繧ｹ繝√Ε
+ protected Bitmap DrawPrivateFont_V( string drawstr, Color fontColor, Color edgeColor, bool bVertical )
+ {
+ if ( this._fontfamily == null || drawstr == null || drawstr == "" )
+ {
+ // null繧定ｿ斐☆縺ｨ縲√◎縺ｮ蠕恵mp竊稚exture蜃ｦ逅繧縲》exture縺ｮ繧ｵ繧､繧ｺ繧定ｦ九※__縺ｮ蜃ｦ逅縺ｧ蜈ｨ驛ｨ萓句､悶′逋ｺ逕溘☆繧九％縺ｨ縺ｫ縺ｪ繧九
+ // 縺昴ｌ縺ｯ髱槫ｸｸ縺ｫ髱｢蛟偵↑縺ｮ縺ｧ縲∵怙蟆城剞縺ｮbitmap繧定ｿ斐＠縺ｦ縺励∪縺縲
+ // 縺ｾ縺壹ｯ縺薙ｮ莉墓ｧ倥〒騾ｲ繧√∪縺吶′縲∝撫鬘梧怏繧後ｰ(荳贋ｽ榊ｴ縺九ｉ繧ｨ繝ｩ繝ｼ讀懷ｺ縺悟ｿ隕√〒縺ゅｌ縺ｰ)萓句､悶ｒ蜃ｺ縺励◆繧翫お繝ｩ繝ｼ迥ｶ諷九〒縺ゅｋ繝励Ο繝代ユ繧｣繧貞ｮ夂ｾｩ縺吶ｋ縺ｪ繧頑､懆ｨ弱＠縺ｾ縺吶
+ if ( drawstr != "" )
+ {
+ Trace.TraceWarning( "DrawPrivateFont()縺ｮ蜈･蜉帑ｸ肴ｭ｣縲よ怙蟆丞､縺ｮbitmap繧定ｿ斐＠縺ｾ縺吶" );
+ }
+ _rectStrings = new Rectangle( 0, 0, 0, 0 );
+ _ptOrigin = new Point( 0, 0 );
+ return new Bitmap(1, 1);
+ }
+
+ //StreamWriter stream = stream = new StreamWriter("Test.txt", false);
+
+ //try
+ //{
+ // stream = new StreamWriter("Test.txt", false);
+ //}
+ //catch (Exception ex)
+ //{
+ // stream.Close();
+ // stream = new StreamWriter("Test.txt", false);
+ //}
+
+ string[] strName = new string[ drawstr.Length ];
+ for( int i = 0; i < drawstr.Length; i++ ) strName[i] = drawstr.Substring(i, 1);
+
+ #region[ 繧ｭ繝｣繝ｳ繝舌せ縺ｮ螟ｧ縺阪＆莠域ｸｬ ]
+ //螟ｧ縺阪＆繧定ｨ育ｮ励＠縺ｦ縺縺上
+ int nHeight = 0;
+ for( int i = 0; i < strName.Length; i++ )
+ {
+ Size strSize = System.Windows.Forms.TextRenderer.MeasureText( strName[ i ], this._font, new Size( int.MaxValue, int.MaxValue ),
+ System.Windows.Forms.TextFormatFlags.NoPrefix |
+ System.Windows.Forms.TextFormatFlags.NoPadding );
+
+ //stringformat縺ｯ譛蛻昴↓繧縺｣縺ｦ縺縺ｦ繧ゅ＞縺縺繧阪≧縲
+ StringFormat sFormat = new StringFormat();
+ sFormat.LineAlignment = StringAlignment.Center; // 逕ｻ髱｢荳矩Κｼ亥桙逶ｴ譁ｹ蜷台ｽ咲ｽｮｼ
+ sFormat.Alignment = StringAlignment.Center; // 逕ｻ髱｢荳ｭ螟ｮｼ域ｰｴ蟷ｳ譁ｹ蜷台ｽ咲ｽｮｼ
+
+
+ //縺ｧ縺阪ｋ縺縺第ｭ｣遒ｺ縺ｪ蛟､繧定ｨ育ｮ励＠縺ｦ縺翫″縺溘＞...!
+ Bitmap bmpDummy = new Bitmap( 150, 150 ); //縺ｨ繧翫≠縺医★150
+ Graphics gCal = Graphics.FromImage( bmpDummy );
+ Rectangle rect豁｣遒ｺ縺ｪ繧ｵ繧､繧ｺ = this.MeasureStringPrecisely( gCal, strName[ i ], this._font, strSize, sFormat );
+ int n菴咏區繧ｵ繧､繧ｺ = strSize.Height - rect豁｣遒ｺ縺ｪ繧ｵ繧､繧ｺ.Height;
+
+ Rectangle rect = new Rectangle( 0, -n菴咏區繧ｵ繧､繧ｺ + 2, 46, ( strSize.Height + 16 ));
+
+ if( strName[ i ] == "繝ｼ" || strName[ i ] == "-" || strName[ i ] == "ｽ" || strName[ i ] == "<" || strName[ i ] == ">" || strName[ i ] == "(" || strName[ i ] == ")" || strName[ i ] == "縲" || strName[ i ] == "縲" || strName[ i ] == "[" || strName[ i ] == "]" )
+ {
+ nHeight += ( rect豁｣遒ｺ縺ｪ繧ｵ繧､繧ｺ.Width ) + 4;
+ }
+ else if( strName[ i ] == "_" ){ nHeight += ( rect豁｣遒ｺ縺ｪ繧ｵ繧､繧ｺ.Height ) + 6; }
+ else if( strName[ i ] == " " )
+ { nHeight += ( 12 ); }
+ else { nHeight += ( rect豁｣遒ｺ縺ｪ繧ｵ繧､繧ｺ.Height ) + 10; }
+
+ //蠢ｵ縺ｮ縺溘ａ隗｣謾ｾ
+ bmpDummy.Dispose();
+ gCal.Dispose();
+
+ //stream.WriteLine( "譁蟄励ｮ螟ｧ縺阪＆{0},螟ｧ縺阪＆蜷郁ｨ{1}", ( rect豁｣遒ｺ縺ｪ繧ｵ繧､繧ｺ.Height ) + 6, nHeight );
+
+ }
+ #endregion
+
+ Bitmap bmpCambus = new Bitmap( 46, nHeight );
+ Graphics Gcambus = Graphics.FromImage( bmpCambus );
+
+ //繧ｭ繝｣繝ｳ繝舌せ菴懈絶1譁蟄励★縺､菴懈舌＠縺ｦ繧ｭ繝｣繝ｳ繝舌せ縺ｫ謠冗判縺ｨ縺縺蠖｢縺後ｈ縺輔◎縺縺九↑?
+ int nNowPos = 0;
+ int nAdded = 0;
+ int nEdge陬懈ｭ｣X = 0;
+ int nEdge陬懈ｭ｣Y = 0;
+ if (this._pt < 18)
+ nAdded = nAdded - 2;
+
+ for (int i = 0; i < strName.Length; i++)
+ {
+ Size strSize = System.Windows.Forms.TextRenderer.MeasureText(strName[i], this._font, new Size(int.MaxValue, int.MaxValue),
+ System.Windows.Forms.TextFormatFlags.NoPrefix |
+ System.Windows.Forms.TextFormatFlags.NoPadding);
+
+ //stringformat縺ｯ譛蛻昴↓繧縺｣縺ｦ縺縺ｦ繧ゅ＞縺縺繧阪≧縲
+ StringFormat sFormat = new StringFormat();
+ sFormat.LineAlignment = StringAlignment.Center; // 逕ｻ髱｢荳矩Κｼ亥桙逶ｴ譁ｹ蜷台ｽ咲ｽｮｼ
+ sFormat.Alignment = StringAlignment.Near; // 逕ｻ髱｢荳ｭ螟ｮｼ域ｰｴ蟷ｳ譁ｹ蜷台ｽ咲ｽｮｼ
+
+ //縺ｧ縺阪ｋ縺縺第ｭ｣遒ｺ縺ｪ蛟､繧定ｨ育ｮ励＠縺ｦ縺翫″縺溘＞...!
+ Bitmap bmpDummy = new Bitmap(150, 150); //縺ｨ繧翫≠縺医★150
+ Graphics gCal = Graphics.FromImage(bmpDummy);
+ Rectangle rect豁｣遒ｺ縺ｪ繧ｵ繧､繧ｺ = this.MeasureStringPrecisely(gCal, strName[i], this._font, strSize, sFormat);
+ int n菴咏區繧ｵ繧､繧ｺ = strSize.Height - rect豁｣遒ｺ縺ｪ繧ｵ繧､繧ｺ.Height;
+
+ //Bitmap bmpV = new Bitmap( 36, ( strSize.Height + 12 ) - 6 );
+
+ Bitmap bmpV = new Bitmap((rect豁｣遒ｺ縺ｪ繧ｵ繧､繧ｺ.Width + 12) + nAdded, (rect豁｣遒ｺ縺ｪ繧ｵ繧､繧ｺ.Height) + 12);
+
+ bmpV.MakeTransparent();
+ Graphics gV = Graphics.FromImage(bmpV);
+ gV.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.HighQuality;
+
+
+ if (strName[i].In(TJAPlayer3.Skin.SongSelect_CorrectionX_Chara))
+ {
+ nEdge陬懈ｭ｣X = TJAPlayer3.Skin.SongSelect_CorrectionX_Chara_Value;
+ }
+ else
+ {
+ nEdge陬懈ｭ｣X = 0;
+ }
+ if (strName[i].In(TJAPlayer3.Skin.SongSelect_CorrectionY_Chara))
+ {
+ nEdge陬懈ｭ｣Y = TJAPlayer3.Skin.SongSelect_CorrectionY_Chara_Value;
+ }
+ else
+ {
+ nEdge陬懈ｭ｣Y = 0;
+ }
+ //X蠎ｧ讓吶〆蠎ｧ讓吶◎繧後◇繧後↓縺､縺縺ｦ縲ヾkinConfig蜀縺ｧ繧ｺ繝ｬ繧堤峩縺励◆縺譁蟄励ｒ , 縺ｧ蛹ｺ蛻縺｣縺ｦ蛻玲嫌縺励※縲
+ //陬懈ｭ｣蛟､繧定ｨ伜･縺吶ｋ縺薙→縺ｧ縲∫音螳壹ｮ縺昴ｌ繧峨ｮ譁蟄励↓縺､縺縺ｦ荳諡ｬ縺ｧ蠎ｧ讓吶ｒ縺壹ｉ縺吶
+ //迴ｾ譎らせ縺ｧ縺ｯ陬懈ｭ｣蛟､繧湛,Y蜷蠎ｧ讓吶↓縺､縺縺ｦ1蛟九★縺､縺励°蜿悶ｌ縺ｪ縺ｼ郁､謨ｰ蟇ｾ1ｼ峨ｮ縺ｧ縲
+ //譁蟄励ｒ蛻玲嫌縺励※縲∝酔縺俶焚縺縺代◎繧後◇繧後ｮ譁蟄励ｮ陬懈ｭ｣蛟､繧定ｨ伜･縺ｧ縺阪ｋ繧医≧縺ｪ譫邨繧偵▽縺上ｊ縺溘＞縲ゑｼ20181205 rhimmｼ
+
+ Rectangle rect = new Rectangle(-3 - nAdded + (nEdge陬懈ｭ｣X * _pt / 100), -rect豁｣遒ｺ縺ｪ繧ｵ繧､繧ｺ.Y - 2 + (nEdge陬懈ｭ｣Y * _pt / 100), (strSize.Width + 12), (strSize.Height + 12));
+ //Rectangle rect = new Rectangle( 0, -rect豁｣遒ｺ縺ｪ繧ｵ繧､繧ｺ.Y - 2, 36, rect豁｣遒ｺ縺ｪ繧ｵ繧､繧ｺ.Height + 10);
+
+ // DrawPath縺ｧ縲√昴う繝ｳ繝医し繧､繧ｺ繧剃ｽｿ縺｣縺ｦ謠冗判縺吶ｋ縺溘ａ縺ｫ縲．PI繧剃ｽｿ縺｣縺ｦ蜊倅ｽ榊､画鋤縺吶ｋ
+ // (縺薙ｌ繧偵＠縺ｪ縺縺ｨ縲∝腰菴阪′驕輔≧縺溘ａ縺ｫ縲∝ｰ上＆繧√↓謠冗判縺輔ｌ縺ｦ縺励∪縺)
+ float sizeInPixels = _font.SizeInPoints * gV.DpiY / 72; // 1 inch = 72 points
+
+ System.Drawing.Drawing2D.GraphicsPath gpV = new System.Drawing.Drawing2D.GraphicsPath();
+ gpV.AddString(strName[i], this._fontfamily, (int)this._font.Style, sizeInPixels, rect, sFormat);
+
+ // 邵∝叙繧翫ｒ謠冗判縺吶ｋ
+ //int nEdgePt = (_pt / 3); // 邵∝叙繧翫ｒ繝輔か繝ｳ繝医し繧､繧ｺ蝓ｺ貅悶↓螟画峩
+ int nEdgePt = (10 * _pt / TJAPlayer3.Skin.Font_Edge_Ratio_Vertical); // SkinConfig縺ｫ縺ｦ險ｭ螳壼庄閭ｽ縺ｫ(rhimm)
+ Pen pV = new Pen(edgeColor, nEdgePt);
+ pV.LineJoin = System.Drawing.Drawing2D.LineJoin.Round;
+ gV.DrawPath(pV, gpV);
+
+ // 蝪励ｊ縺､縺ｶ縺
+ Brush brV;
+ {
+ brV = new SolidBrush(fontColor);
+ }
+ gV.FillPath(brV, gpV);
+
+ if (brV != null) brV.Dispose(); brV = null;
+ if (pV != null) pV.Dispose(); pV = null;
+ if (gpV != null) gpV.Dispose(); gpV = null;
+ if (gV != null) gV.Dispose(); gV = null;
+
+ int n陬懈ｭ｣ = 0;
+ int nY陬懈ｭ｣ = 0;
+
+ if (strName[i] == "繝ｼ" || strName[i] == "-" || strName[i] == "ｽ")
+ {
+ bmpV.RotateFlip(RotateFlipType.Rotate90FlipNone);
+ n陬懈ｭ｣ = 2;
+ if (this._pt < 20)
+ n陬懈ｭ｣ = 0;
+ //nNowPos = nNowPos - 2;
+ }
+ else if (strName[i] == "<" || strName[i] == ">" || strName[i] == "(" || strName[i] == ")" || strName[i] == "[" || strName[i] == "]" || strName[i] == "縲" || strName[i] == "ｼ" || strName[i] == "縲")
+ {
+ bmpV.RotateFlip(RotateFlipType.Rotate90FlipNone);
+ n陬懈ｭ｣ = 2;
+ if (this._pt < 20)
+ {
+ n陬懈ｭ｣ = 0;
+ //nNowPos = nNowPos - 4;
+ }
+ }
+ else if (strName[i] == "縲" || strName[i] == "ｼ" || strName[i] == "縲")
+ {
+ bmpV.RotateFlip(RotateFlipType.Rotate90FlipNone);
+ n陬懈ｭ｣ = 2;
+ if (this._pt < 20)
+ {
+ n陬懈ｭ｣ = 2;
+ //nNowPos = nNowPos;
+ }
+ }
+ else if (strName[i] == "繝ｻ")
+ {
+ n陬懈ｭ｣ = -8;
+ if (this._pt < 20)
+ {
+ n陬懈ｭ｣ = -8;
+ //nNowPos = nNowPos;
+ }
+ }
+ else if (strName[i] == ".")
+ {
+ n陬懈ｭ｣ = 8;
+ if (this._pt < 20)
+ {
+ n陬懈ｭ｣ = 8;
+ //nNowPos = nNowPos;
+ }
+ }
+ else if (strName[i].In(TJAPlayer3.Skin.SongSelect_Rotate_Chara))
+ {
+ bmpV.RotateFlip(RotateFlipType.Rotate90FlipNone);
+ }
+ //蛟句挨縺ｮ譁蟄励↓髢｢縺励※縲√き繝ｳ繝槭〒蛹ｺ蛻縺｣縺ｦSkinConfig縺ｫ險伜･縺励◆繧ゅｮ繧貞屓霆｢縺輔○繧(20181205 rhimm)
+
+
+ //else if( strName[ i ] == "_" )
+ // nNowPos = nNowPos + 20;
+ else if( strName[ i ] == " " )
+ nNowPos = nNowPos + 10;
+
+
+ //bmpV.Save( "String" + i.ToString() + ".png" );
+
+
+ if( i == 0 )
+ {
+ nNowPos = 4;
+ }
+ Gcambus.DrawImage( bmpV, (bmpCambus.Width / 2) - (bmpV.Width / 2) + n陬懈ｭ｣, nNowPos + nY陬懈ｭ｣ );
+ nNowPos += bmpV.Size.Height - 6;
+
+ if( bmpV != null ) bmpV.Dispose(); bmpV = null;
+ if( gCal != null ) gCal.Dispose(); gCal = null;
+
+ //bmpCambus.Save( "test.png" );
+ //if( this._pt < 20 )
+ // bmpCambus.Save( "test_S.png" );
+
+ _rectStrings = new Rectangle( 0, 0, strSize.Width, strSize.Height );
+ _ptOrigin = new Point( 6 * 2, 6 * 2 );
+
+
+ //stream.WriteLine( "鮟堤┌縺励し繧､繧ｺ{0},菴咏區{1},鮟偵≠繧贋ｺ域ｸｬ繧ｵ繧､繧ｺ{2},繝昶代ず竊怒3}",rect豁｣遒ｺ縺ｪ繧ｵ繧､繧ｺ.Height, n菴咏區繧ｵ繧､繧ｺ, rect豁｣遒ｺ縺ｪ繧ｵ繧､繧ｺ.Height + 8, nNowPos );
+
+ }
+ //stream.Close();
+
+ if( Gcambus != null ) Gcambus.Dispose();
+
+ //return bmp;
+ return bmpCambus;
+ }
+
+ /////
+ ///// 譁蟄怜励ｒ謠冗判縺励◆繝繧ｯ繧ｹ繝√Ε繧定ｿ斐☆(繝｡繧､繝ｳ蜃ｦ逅)
+ /////
+ ///// 謠冗判縺輔ｌ縺滄伜沺
+ ///// 謠冗判譁蟄怜
+ ///// 謠冗判譁蟄怜
+ ///// 謠冗判繝｢繝ｼ繝
+ ///// 謠冗判濶ｲ
+ ///// 邵∝叙濶ｲ
+ ///// 繧ｰ繝ｩ繝繝ｼ繧ｷ繝ｧ繝ｳ 荳雁ｴ縺ｮ濶ｲ
+ ///// 繧ｰ繝ｩ繝繝ｼ繧ｷ繝ｧ繝ｳ 荳句ｴ縺ｮ濶ｲ
+ ///// 謠冗判貂医ユ繧ｯ繧ｹ繝√Ε
+ //protected Bitmap DrawPrivateFont_V( string drawstr, Color fontColor, Color edgeColor, bool bVertical )
+ //{
+ // if ( this._fontfamily == null || drawstr == null || drawstr == "" )
+ // {
+ // // null繧定ｿ斐☆縺ｨ縲√◎縺ｮ蠕恵mp竊稚exture蜃ｦ逅繧縲》exture縺ｮ繧ｵ繧､繧ｺ繧定ｦ九※__縺ｮ蜃ｦ逅縺ｧ蜈ｨ驛ｨ萓句､悶′逋ｺ逕溘☆繧九％縺ｨ縺ｫ縺ｪ繧九
+ // // 縺昴ｌ縺ｯ髱槫ｸｸ縺ｫ髱｢蛟偵↑縺ｮ縺ｧ縲∵怙蟆城剞縺ｮbitmap繧定ｿ斐＠縺ｦ縺励∪縺縲
+ // // 縺ｾ縺壹ｯ縺薙ｮ莉墓ｧ倥〒騾ｲ繧√∪縺吶′縲∝撫鬘梧怏繧後ｰ(荳贋ｽ榊ｴ縺九ｉ繧ｨ繝ｩ繝ｼ讀懷ｺ縺悟ｿ隕√〒縺ゅｌ縺ｰ)萓句､悶ｒ蜃ｺ縺励◆繧翫お繝ｩ繝ｼ迥ｶ諷九〒縺ゅｋ繝励Ο繝代ユ繧｣繧貞ｮ夂ｾｩ縺吶ｋ縺ｪ繧頑､懆ｨ弱＠縺ｾ縺吶
+ // if ( drawstr != "" )
+ // {
+ // Trace.TraceWarning( "DrawPrivateFont()縺ｮ蜈･蜉帑ｸ肴ｭ｣縲よ怙蟆丞､縺ｮbitmap繧定ｿ斐＠縺ｾ縺吶" );
+ // }
+ // _rectStrings = new Rectangle( 0, 0, 0, 0 );
+ // _ptOrigin = new Point( 0, 0 );
+ // return new Bitmap(1, 1);
+ // }
+
+ // //StreamWriter stream = stream = new StreamWriter("Test.txt", false);
+
+ // //try
+ // //{
+ // // stream = new StreamWriter("Test.txt", false);
+ // //}
+ // //catch (Exception ex)
+ // //{
+ // // stream.Close();
+ // // stream = new StreamWriter("Test.txt", false);
+ // //}
+
+ // string[] strName = new string[] { "辟ｼ","閧","螳","鬟", "X", "G", "t", "e", "s", "t" };
+ // strName = new string[ drawstr.Length ];
+ // for( int i = 0; i < drawstr.Length; i++ ) strName[i] = drawstr.Substring(i, 1);
+
+
+ // Bitmap bmpCambus = new Bitmap( 48, ( drawstr.Length * 31 ) );
+ // Graphics Gcambus = Graphics.FromImage( bmpCambus );
+
+ // //繧ｭ繝｣繝ｳ繝舌せ菴懈絶1譁蟄励★縺､菴懈舌＠縺ｦ繧ｭ繝｣繝ｳ繝舌せ縺ｫ謠冗判縺ｨ縺縺蠖｢縺後ｈ縺輔◎縺縺九↑?
+
+ // int nStartPos = 0;
+ // int nNowPos = 0;
+
+ // //for繝ｫ繝ｼ繝励〒1譁蟄励★縺､bitmap菴懈?
+ // for( int i = 0; i < strName.Length; i++ )
+ // {
+ // Size strSize = System.Windows.Forms.TextRenderer.MeasureText( strName[ i ], this._font, new Size( int.MaxValue, int.MaxValue ),
+ // System.Windows.Forms.TextFormatFlags.NoPrefix |
+ // System.Windows.Forms.TextFormatFlags.NoPadding );
+
+ // //Bitmap bmpV = new Bitmap( strSize.Width + 12, ( strSize.Height + 12 ) - 6 );
+ // Bitmap bmpV = new Bitmap( 36, ( strSize.Height + 12 ) - 6 );
+ // bmpV.MakeTransparent();
+ // Graphics gV = Graphics.FromImage( bmpV );
+ // gV.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.HighQuality;
+
+ // StringFormat sFormat = new StringFormat();
+ // sFormat.LineAlignment = StringAlignment.Center; // 逕ｻ髱｢荳矩Κｼ亥桙逶ｴ譁ｹ蜷台ｽ咲ｽｮｼ
+ // sFormat.Alignment = StringAlignment.Center; // 逕ｻ髱｢荳ｭ螟ｮｼ域ｰｴ蟷ｳ譁ｹ蜷台ｽ咲ｽｮｼ
+
+
+ // //Rectangle rect = new Rectangle( 0, 0, strSize.Width + 12, ( strSize.Height + 12 ));
+ // Rectangle rect = new Rectangle( 0, 0, 36, ( strSize.Height + 12 ));
+
+ // // DrawPath縺ｧ縲√昴う繝ｳ繝医し繧､繧ｺ繧剃ｽｿ縺｣縺ｦ謠冗判縺吶ｋ縺溘ａ縺ｫ縲．PI繧剃ｽｿ縺｣縺ｦ蜊倅ｽ榊､画鋤縺吶ｋ
+ // // (縺薙ｌ繧偵＠縺ｪ縺縺ｨ縲∝腰菴阪′驕輔≧縺溘ａ縺ｫ縲∝ｰ上＆繧√↓謠冗判縺輔ｌ縺ｦ縺励∪縺)
+ // float sizeInPixels = _font.SizeInPoints * gV.DpiY / 72; // 1 inch = 72 points
+
+ // System.Drawing.Drawing2D.GraphicsPath gpV = new System.Drawing.Drawing2D.GraphicsPath();
+ // gpV.AddString( strName[ i ], this._fontfamily, (int) this._font.Style, sizeInPixels, rect, sFormat );
+
+
+ // Rectangle rect豁｣遒ｺ縺ｪ繧ｵ繧､繧ｺ = this.MeasureStringPrecisely( gV, strName[ i ], this._font, strSize, sFormat );
+
+ // // 邵∝叙繧翫ｒ謠冗判縺吶ｋ
+ // Pen pV = new Pen( edgeColor, 6 );
+ // pV.LineJoin = System.Drawing.Drawing2D.LineJoin.Round;
+ // gV.DrawPath( pV, gpV );
+
+ // // 蝪励ｊ縺､縺ｶ縺
+ // Brush brV;
+ // {
+ // brV = new SolidBrush( fontColor );
+ // }
+ // gV.FillPath( brV, gpV );
+
+ // if ( brV != null ) brV.Dispose(); brV = null;
+ // if ( pV != null ) pV.Dispose(); pV = null;
+ // if ( gpV != null ) gpV.Dispose(); gpV = null;
+
+ // int n陬懈ｭ｣ = 0;
+
+ // //bmpV.Save( "String" + i.ToString() + ".png" );
+ // if( strName[ i ] == "繝ｼ" || strName[ i ] == "-" || strName[ i ] == "ｽ")
+ // {
+ // bmpV.RotateFlip( RotateFlipType.Rotate90FlipNone );
+ // nNowPos = nNowPos + 20;
+ // n陬懈ｭ｣ = 2;
+ // }
+ // else if( strName[ i ] == "<" || strName[ i ] == ">" || strName[ i ] == "(" || strName[ i ] == ")" )
+ // {
+ // bmpV.RotateFlip( RotateFlipType.Rotate90FlipNone );
+ // nNowPos = nNowPos + 8;
+ // n陬懈ｭ｣ = 2;
+ // }
+ // else if( strName[ i ] == "_" )
+ // nNowPos = nNowPos + 20;
+ // else if( strName[ i ] == " " )
+ // nNowPos = nNowPos + 10;
+
+ // int n菴咏區繧ｵ繧､繧ｺ = strSize.Height - rect豁｣遒ｺ縺ｪ繧ｵ繧､繧ｺ.Height;
+ // if( i == 0 )
+ // {
+ // nStartPos = -n菴咏區繧ｵ繧､繧ｺ + 2;
+ // nNowPos = -n菴咏區繧ｵ繧､繧ｺ + 2;
+ // Gcambus.DrawImage( bmpV, ( bmpCambus.Size.Width - bmpV.Size.Width ) + n陬懈ｭ｣, nStartPos );
+ // //nNowPos += ( rect豁｣遒ｺ縺ｪ繧ｵ繧､繧ｺ.Height + 6 );
+ // }
+ // else
+ // {
+ // nNowPos += ( strSize.Height - n菴咏區繧ｵ繧､繧ｺ ) + 4;
+ // Gcambus.DrawImage( bmpV, ( bmpCambus.Size.Width - bmpV.Size.Width ) + n陬懈ｭ｣, nNowPos );
+ // }
+
+ // if ( bmpV != null ) bmpV.Dispose();
+
+ // //bmpCambus.Save( "test.png" );
+
+ // _rectStrings = new Rectangle( 0, 0, strSize.Width, strSize.Height );
+ // _ptOrigin = new Point( 6 * 2, 6 * 2 );
+
+
+ // //stream.WriteLine( "鮟堤┌縺励し繧､繧ｺ{0},菴咏區{1},鮟偵≠繧贋ｺ域ｸｬ繧ｵ繧､繧ｺ{2},繝昶代ず竊怒3}",rect豁｣遒ｺ縺ｪ繧ｵ繧､繧ｺ.Height, n菴咏區繧ｵ繧､繧ｺ, rect豁｣遒ｺ縺ｪ繧ｵ繧､繧ｺ.Height + 6, nNowPos );
+
+ // }
+ // //stream.Close();
+
+ // //return bmp;
+ // return bmpCambus;
+ //}
+
+
+ //------------------------------------------------
+ //菴ｿ逕ｨ:http://dobon.net/vb/dotnet/graphics/measurestring.html
+
+ ///
+ /// Graphics.DrawString縺ｧ譁蟄怜励ｒ謠冗判縺励◆譎ゅｮ螟ｧ縺阪＆縺ｨ菴咲ｽｮ繧呈ｭ｣遒ｺ縺ｫ險域ｸｬ縺吶ｋ
+ ///
+ /// 譁蟄怜励ｒ謠冗判縺吶ｋGraphics
+ /// 謠冗判縺吶ｋ譁蟄怜
+ /// 謠冗判縺ｫ菴ｿ逕ｨ縺吶ｋ繝輔か繝ｳ繝
+ /// 縺薙ｌ莉･荳雁､ｧ縺阪＞縺薙→縺ｯ縺ｪ縺縺ｨ縺縺繧ｵ繧､繧ｺ縲
+ /// 縺ｧ縺阪ｋ縺縺大ｰ上＆縺上☆繧九％縺ｨ縲
+ /// 謠冗判縺ｫ菴ｿ逕ｨ縺吶ｋStringFormat
+ /// 譁蟄怜励′謠冗判縺輔ｌ繧狗ｯ蝗ｲ縲
+ /// 隕九▽縺九ｉ縺ｪ縺九▲縺滓凾縺ｯ縲ヽectangle.Empty縲
+ public Rectangle MeasureStringPrecisely(Graphics g,
+ string text, Font font, Size proposedSize, StringFormat stringFormat)
+ {
+ //隗｣蜒丞ｺｦ繧貞ｼ輔″邯吶＞縺ｧ縲。itmap繧剃ｽ懈舌☆繧
+ Bitmap bmp = new Bitmap(proposedSize.Width, proposedSize.Height, g);
+ //Bitmap縺ｮGraphics繧剃ｽ懈舌☆繧
+ Graphics bmpGraphics = Graphics.FromImage(bmp);
+ //Graphics縺ｮ繝励Ο繝代ユ繧｣繧貞ｼ輔″邯吶＄
+ bmpGraphics.TextRenderingHint = g.TextRenderingHint;
+ bmpGraphics.TextContrast = g.TextContrast;
+ bmpGraphics.PixelOffsetMode = g.PixelOffsetMode;
+ //譁蟄怜励ｮ謠上°繧後※縺縺ｪ縺驛ｨ蛻縺ｮ濶ｲ繧貞叙蠕励☆繧
+ Color backColor = bmp.GetPixel(0, 0);
+ //螳滄圀縺ｫBitmap縺ｫ譁蟄怜励ｒ謠冗判縺吶ｋ
+ bmpGraphics.DrawString(text, font, Brushes.Black,
+ new RectangleF(0f, 0f, proposedSize.Width, proposedSize.Height),
+ stringFormat);
+ bmpGraphics.Dispose();
+ //譁蟄怜励′謠冗判縺輔ｌ縺ｦ縺繧狗ｯ蝗ｲ繧定ｨ域ｸｬ縺吶ｋ
+ Rectangle resultRect = MeasureForegroundArea(bmp, backColor);
+ bmp.Dispose();
+
+ return resultRect;
+ }
+
+ ///
+ /// 謖螳壹＆繧後◆Bitmap縺ｧ縲｜ackColor莉･螟悶ｮ濶ｲ縺御ｽｿ繧上ｌ縺ｦ縺繧狗ｯ蝗ｲ繧定ｨ域ｸｬ縺吶ｋ
+ ///
+ private Rectangle MeasureForegroundArea(Bitmap bmp, Color backColor)
+ {
+ int backColorArgb = backColor.ToArgb();
+ int maxWidth = bmp.Width;
+ int maxHeight = bmp.Height;
+
+ //蟾ｦ蛛ｴ縺ｮ遨ｺ逋ｽ驛ｨ蛻繧定ｨ域ｸｬ縺吶ｋ
+ int leftPosition = -1;
+ for (int x = 0; x < maxWidth; x++)
+ {
+ for (int y = 0; y < maxHeight; y++)
+ {
+ //驕輔≧濶ｲ繧定ｦ九▽縺代◆縺ｨ縺阪ｯ縲∽ｽ咲ｽｮ繧呈ｱｺ螳壹☆繧
+ if (bmp.GetPixel(x, y).ToArgb() != backColorArgb)
+ {
+ leftPosition = x;
+ break;
+ }
+ }
+ if (0 <= leftPosition)
+ {
+ break;
+ }
+ }
+ //驕輔≧濶ｲ縺瑚ｦ九▽縺九ｉ縺ｪ縺九▲縺滓凾
+ if (leftPosition < 0)
+ {
+ return Rectangle.Empty;
+ }
+
+ //蜿ｳ蛛ｴ縺ｮ遨ｺ逋ｽ驛ｨ蛻繧定ｨ域ｸｬ縺吶ｋ
+ int rightPosition = -1;
+ for (int x = maxWidth - 1; leftPosition < x; x--)
+ {
+ for (int y = 0; y < maxHeight; y++)
+ {
+ if (bmp.GetPixel(x, y).ToArgb() != backColorArgb)
+ {
+ rightPosition = x;
+ break;
+ }
+ }
+ if (0 <= rightPosition)
+ {
+ break;
+ }
+ }
+ if (rightPosition < 0)
+ {
+ rightPosition = leftPosition;
+ }
+
+ //荳翫ｮ遨ｺ逋ｽ驛ｨ蛻繧定ｨ域ｸｬ縺吶ｋ
+ int topPosition = -1;
+ for (int y = 0; y < maxHeight; y++)
+ {
+ for (int x = leftPosition; x <= rightPosition; x++)
+ {
+ if (bmp.GetPixel(x, y).ToArgb() != backColorArgb)
+ {
+ topPosition = y;
+ break;
+ }
+ }
+ if (0 <= topPosition)
+ {
+ break;
+ }
+ }
+ if (topPosition < 0)
+ {
+ return Rectangle.Empty;
+ }
+
+ //荳九ｮ遨ｺ逋ｽ驛ｨ蛻繧定ｨ域ｸｬ縺吶ｋ
+ int bottomPosition = -1;
+ for (int y = maxHeight - 1; topPosition < y; y--)
+ {
+ for (int x = leftPosition; x <= rightPosition; x++)
+ {
+ if (bmp.GetPixel(x, y).ToArgb() != backColorArgb)
+ {
+ bottomPosition = y;
+ break;
+ }
+ }
+ if (0 <= bottomPosition)
+ {
+ break;
+ }
+ }
+ if (bottomPosition < 0)
+ {
+ bottomPosition = topPosition;
+ }
+
+ //邨先棡繧定ｿ斐☆
+ return new Rectangle(leftPosition, topPosition,
+ rightPosition - leftPosition, bottomPosition - topPosition);
+ }
+
+ private Rectangle MeasureForegroundArea(Bitmap bmp)
+ {
+ return MeasureForegroundArea(bmp, bmp.GetPixel(0, 0));
+ }
+
+ //------------------------------------------------
+
+ ///
+ /// 譛蠕後↓DrawPrivateFont()縺励◆譁蟄怜励ｮ謠冗判鬆伜沺繧貞叙蠕励＠縺ｾ縺吶
+ ///
+ public Rectangle RectStrings
+ {
+ get
+ {
+ return _rectStrings;
+ }
+ protected set
+ {
+ _rectStrings = value;
+ }
+ }
+ public Point PtOrigin
+ {
+ get
+ {
+ return _ptOrigin;
+ }
+ protected set
+ {
+ _ptOrigin = value;
+ }
+ }
+
+ #region [ IDisposable 螳溯｣ ]
+ //-----------------
+ public void Dispose()
+ {
+ if (!this.bDispose螳御ｺ貂医∩)
+ {
+ if (this._font != null)
+ {
+ this._font.Dispose();
+ this._font = null;
+ }
+ if (this._pfc != null)
+ {
+ this._pfc.Dispose();
+ this._pfc = null;
+ }
+
+ this.bDispose螳御ｺ貂医∩ = true;
+ }
+ }
+ //-----------------
+ #endregion
+ #region [ private ]
+ //-----------------
+ protected bool bDispose螳御ｺ貂医∩;
+ protected Font _font;
+
+ private System.Drawing.Text.PrivateFontCollection _pfc;
+ private FontFamily _fontfamily;
+ private int _pt;
+ private Rectangle _rectStrings;
+ private Point _ptOrigin;
+ //-----------------
+ #endregion
+ }
+}
diff --git a/TJAPlayer3/Common/CSkin.cs b/TJAPlayer3/Common/CSkin.cs
new file mode 100644
index 00000000..a3844a9b
--- /dev/null
+++ b/TJAPlayer3/Common/CSkin.cs
@@ -0,0 +1,2921 @@
+ｻｿusing System;
+using System.Collections.Generic;
+using System.Text;
+using System.IO;
+using System.Diagnostics;
+using FDK;
+using System.Drawing;
+using System.Linq;
+
+namespace TJAPlayer3
+{
+ // 繧ｰ繝ｭ繝ｼ繝舌Ν螳壽焚
+
+ public enum E繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝
+ {
+ BGM繧ｪ繝励す繝ｧ繝ｳ逕ｻ髱｢ = 0,
+ BGM繧ｳ繝ｳ繝輔ぅ繧ｰ逕ｻ髱｢,
+ BGM襍ｷ蜍慕判髱｢,
+ BGM驕ｸ譖ｲ逕ｻ髱｢,
+ SOUND繧ｹ繝繝ｼ繧ｸ螟ｱ謨鈴浹,
+ SOUND繧ｫ繝ｼ繧ｽ繝ｫ遘ｻ蜍暮浹,
+ SOUND繧ｲ繝ｼ繝髢句ｧ矩浹,
+ SOUND繧ｲ繝ｼ繝邨ゆｺ髻ｳ,
+ SOUND繧ｹ繝繝ｼ繧ｸ繧ｯ繝ｪ繧｢髻ｳ,
+ SOUND繧ｿ繧､繝医Ν髻ｳ,
+ SOUND繝輔Ν繧ｳ繝ｳ繝憺浹,
+ SOUND豁灘｣ｰ髻ｳ,
+ SOUND譖ｲ隱ｭ霎ｼ髢句ｧ矩浹,
+ SOUND豎ｺ螳夐浹,
+ SOUND蜿匁ｶ磯浹,
+ SOUND螟画峩髻ｳ,
+ //SOUND襍､,
+ //SOUND髱,
+ SOUND鬚ｨ闊ｹ,
+ SOUND譖ｲ豎ｺ螳夐浹,
+ SOUND謌千ｸｾ逋ｺ陦ｨ,
+ SOUND迚ｹ險灘咲函,
+ SOUND迚ｹ險灘●豁｢,
+ sound迚ｹ險薙ず繝｣繝ｳ繝励昴う繝ｳ繝,
+ sound迚ｹ險薙せ繧ｭ繝繝鈴浹,
+ SOUND迚ｹ險薙せ繧ｯ繝ｭ繝ｼ繝ｫ,
+ Count // 繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝臥ｷ乗焚縺ｮ險育ｮ礼畑
+ }
+
+ internal class CSkin : IDisposable
+ {
+ // 繧ｯ繝ｩ繧ｹ
+
+ public class C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝 : IDisposable
+ {
+ // static 繝輔ぅ繝ｼ繝ｫ繝
+
+ public static CSkin.C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝 r譛蠕後↓蜀咲函縺励◆謗剃ｻ悶す繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝;
+
+ private readonly ESoundGroup _soundGroup;
+
+ // 繝輔ぅ繝ｼ繝ｫ繝峨√励Ο繝代ユ繧｣
+
+ public bool bPlayed;
+ public bool bCompact蟇ｾ雎｡;
+ public bool b繝ｫ繝ｼ繝;
+ public bool b隱ｭ縺ｿ霎ｼ縺ｿ譛ｪ隧ｦ陦;
+ public bool b隱ｭ縺ｿ霎ｼ縺ｿ謌仙粥;
+ public bool b謗剃ｻ;
+ public string str繝輔ぃ繧､繝ｫ蜷 = "";
+ public bool b蜀咲函荳ｭ
+ {
+ get
+ {
+ if (this.rSound[1 - this.n谺｡縺ｫ魑ｴ繧九し繧ｦ繝ｳ繝臥分蜿ｷ] == null)
+ return false;
+
+ return this.rSound[1 - this.n谺｡縺ｫ魑ｴ繧九し繧ｦ繝ｳ繝臥分蜿ｷ].b蜀咲函荳ｭ;
+ }
+ }
+ public int n菴咲ｽｮ_迴ｾ蝨ｨ縺ｮ繧ｵ繧ｦ繝ｳ繝
+ {
+ get
+ {
+ CSound sound = this.rSound[1 - this.n谺｡縺ｫ魑ｴ繧九し繧ｦ繝ｳ繝臥分蜿ｷ];
+ if (sound == null)
+ return 0;
+
+ return sound.n菴咲ｽｮ;
+ }
+ set
+ {
+ CSound sound = this.rSound[1 - this.n谺｡縺ｫ魑ｴ繧九し繧ｦ繝ｳ繝臥分蜿ｷ];
+ if (sound != null)
+ sound.n菴咲ｽｮ = value;
+ }
+ }
+ public int n菴咲ｽｮ_谺｡縺ｫ魑ｴ繧九し繧ｦ繝ｳ繝
+ {
+ get
+ {
+ CSound sound = this.rSound[this.n谺｡縺ｫ魑ｴ繧九し繧ｦ繝ｳ繝臥分蜿ｷ];
+ if (sound == null)
+ return 0;
+
+ return sound.n菴咲ｽｮ;
+ }
+ set
+ {
+ CSound sound = this.rSound[this.n谺｡縺ｫ魑ｴ繧九し繧ｦ繝ｳ繝臥分蜿ｷ];
+ if (sound != null)
+ sound.n菴咲ｽｮ = value;
+ }
+ }
+ public int nAutomationLevel_迴ｾ蝨ｨ縺ｮ繧ｵ繧ｦ繝ｳ繝
+ {
+ get
+ {
+ CSound sound = this.rSound[1 - this.n谺｡縺ｫ魑ｴ繧九し繧ｦ繝ｳ繝臥分蜿ｷ];
+ if (sound == null)
+ return 0;
+
+ return sound.AutomationLevel;
+ }
+ set
+ {
+ CSound sound = this.rSound[1 - this.n谺｡縺ｫ魑ｴ繧九し繧ｦ繝ｳ繝臥分蜿ｷ];
+ if (sound != null)
+ {
+ sound.AutomationLevel = value;
+ }
+ }
+ }
+ public int n髟ｷ縺廟迴ｾ蝨ｨ縺ｮ繧ｵ繧ｦ繝ｳ繝
+ {
+ get
+ {
+ CSound sound = this.rSound[1 - this.n谺｡縺ｫ魑ｴ繧九し繧ｦ繝ｳ繝臥分蜿ｷ];
+ if (sound == null)
+ {
+ return 0;
+ }
+ return sound.n邱乗ｼ泌･乗凾髢杜s;
+ }
+ }
+ public int n髟ｷ縺廟谺｡縺ｫ魑ｴ繧九し繧ｦ繝ｳ繝
+ {
+ get
+ {
+ CSound sound = this.rSound[this.n谺｡縺ｫ魑ｴ繧九し繧ｦ繝ｳ繝臥分蜿ｷ];
+ if (sound == null)
+ {
+ return 0;
+ }
+ return sound.n邱乗ｼ泌･乗凾髢杜s;
+ }
+ }
+
+
+ ///
+ /// 繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ
+ ///
+ ///
+ ///
+ ///
+ ///
+ public C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝(string str繝輔ぃ繧､繝ｫ蜷, bool b繝ｫ繝ｼ繝, bool b謗剃ｻ, bool bCompact蟇ｾ雎｡, ESoundGroup soundGroup)
+ {
+ this.str繝輔ぃ繧､繝ｫ蜷 = str繝輔ぃ繧､繝ｫ蜷;
+ this.b繝ｫ繝ｼ繝 = b繝ｫ繝ｼ繝;
+ this.b謗剃ｻ = b謗剃ｻ;
+ this.bCompact蟇ｾ雎｡ = bCompact蟇ｾ雎｡;
+ _soundGroup = soundGroup;
+ this.b隱ｭ縺ｿ霎ｼ縺ｿ譛ｪ隧ｦ陦 = true;
+ this.bPlayed = false;
+ }
+
+
+ // 繝｡繧ｽ繝繝
+
+ public void t隱ｭ縺ｿ霎ｼ縺ｿ()
+ {
+ this.b隱ｭ縺ｿ霎ｼ縺ｿ譛ｪ隧ｦ陦 = false;
+ this.b隱ｭ縺ｿ霎ｼ縺ｿ謌仙粥 = false;
+ if (string.IsNullOrEmpty(this.str繝輔ぃ繧､繝ｫ蜷))
+ throw new InvalidOperationException("繝輔ぃ繧､繝ｫ蜷阪′辟｡蜉ｹ縺ｧ縺吶");
+
+ if (!File.Exists(CSkin.Path(this.str繝輔ぃ繧､繝ｫ蜷)))
+ {
+ Trace.TraceWarning($"繝輔ぃ繧､繝ｫ縺悟ｭ伜惠縺励∪縺帙ｓ縲: {this.str繝輔ぃ繧､繝ｫ蜷閤");
+ return;
+ }
+ //// for( int i = 0; i < 2; i++ ) // #27790 2012.3.10 yyagi 2蝗櫁ｪｭ縺ｿ蜃ｺ縺励ｒ縲1蝗櫁ｪｭ縺ｿ縺縺暦ｼ1蝗槭Γ繝｢繝ｪ繧ｳ繝斐ｼ縺ｫ螟画峩
+ //// {
+ // try
+ // {
+ // this.rSound[ 0 ] = CDTXMania.Sound邂｡逅.t繧ｵ繧ｦ繝ｳ繝峨ｒ逕滓舌☆繧( CSkin.Path( this.str繝輔ぃ繧､繝ｫ蜷 ) );
+ // }
+ // catch
+ // {
+ // this.rSound[ 0 ] = null;
+ // throw;
+ // }
+ // if ( this.rSound[ 0 ] == null ) // #28243 2012.5.3 yyagi "this.rSound[ 0 ].b繧ｹ繝医Μ繝ｼ繝蜀咲函縺吶ｋ"譎ゅｂClone縺吶ｋ繧医≧縺ｫ縺励〉Sound[1]縺系ull縺ｫ縺ｪ繧峨↑縺繧医≧菫ｮ豁｣竊池Sound[1]縺ｮ蜀咲函豁｣蟶ｸ蛹
+ // {
+ // this.rSound[ 1 ] = null;
+ // }
+ // else
+ // {
+ // this.rSound[ 1 ] = ( CSound ) this.rSound[ 0 ].Clone(); // #27790 2012.3.10 yyagi add: to accelerate loading chip sounds
+ // CDTXMania.Sound邂｡逅.t繧ｵ繧ｦ繝ｳ繝峨ｒ逋ｻ骭ｲ縺吶ｋ( this.rSound[ 1 ] ); // #28243 2012.5.3 yyagi add (逋ｻ骭ｲ貍上ｌ縺ｫ繧医ｊ繧ｹ繝医Μ繝ｼ繝蜀咲函蜃ｦ逅縺檎匱逕溘＠縺ｦ縺縺ｪ縺九▲縺)
+ // }
+
+ //// }
+
+ for (int i = 0; i < 2; i++) // 荳譌ｦClone繧呈ｭ｢繧√※ASIO蟇ｾ蠢懊↓蟆ょｿｵ
+ {
+ try
+ {
+ this.rSound[i] = TJAPlayer3.Sound邂｡逅?.t繧ｵ繧ｦ繝ｳ繝峨ｒ逕滓舌☆繧(CSkin.Path(this.str繝輔ぃ繧､繝ｫ蜷), _soundGroup);
+ }
+ catch
+ {
+ this.rSound[i] = null;
+ throw;
+ }
+ }
+ this.b隱ｭ縺ｿ霎ｼ縺ｿ謌仙粥 = true;
+ }
+ public void t蜀咲函縺吶ｋ()
+ {
+ if (this.b隱ｭ縺ｿ霎ｼ縺ｿ譛ｪ隧ｦ陦)
+ {
+ try
+ {
+ t隱ｭ縺ｿ霎ｼ縺ｿ();
+ }
+ catch (Exception e)
+ {
+ Trace.TraceError(e.ToString());
+ Trace.TraceError("萓句､悶′逋ｺ逕溘＠縺ｾ縺励◆縺悟ｦ逅繧堤ｶ咏ｶ壹＠縺ｾ縺吶 (17668977-4686-4aa7-b3f0-e0b9a44975b8)");
+ this.b隱ｭ縺ｿ霎ｼ縺ｿ譛ｪ隧ｦ陦 = false;
+ }
+ }
+ if (this.b謗剃ｻ)
+ {
+ if (r譛蠕後↓蜀咲函縺励◆謗剃ｻ悶す繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝 != null)
+ r譛蠕後↓蜀咲函縺励◆謗剃ｻ悶す繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝.t蛛懈ｭ｢縺吶ｋ();
+
+ r譛蠕後↓蜀咲函縺励◆謗剃ｻ悶す繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝 = this;
+ }
+ CSound sound = this.rSound[this.n谺｡縺ｫ魑ｴ繧九し繧ｦ繝ｳ繝臥分蜿ｷ];
+ if (sound != null)
+ sound.t蜀咲函繧帝幕蟋九☆繧(this.b繝ｫ繝ｼ繝);
+
+ this.bPlayed = true;
+ this.n谺｡縺ｫ魑ｴ繧九し繧ｦ繝ｳ繝臥分蜿ｷ = 1 - this.n谺｡縺ｫ魑ｴ繧九し繧ｦ繝ｳ繝臥分蜿ｷ;
+ }
+ public void t蛛懈ｭ｢縺吶ｋ()
+ {
+ this.bPlayed = false;
+ if (this.rSound[0] != null)
+ this.rSound[0].t蜀咲函繧貞●豁｢縺吶ｋ();
+
+ if (this.rSound[1] != null)
+ this.rSound[1].t蜀咲函繧貞●豁｢縺吶ｋ();
+
+ if (r譛蠕後↓蜀咲函縺励◆謗剃ｻ悶す繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝 == this)
+ r譛蠕後↓蜀咲函縺励◆謗剃ｻ悶す繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝 = null;
+ }
+
+ public void tRemoveMixer()
+ {
+ if (TJAPlayer3.Sound邂｡逅.GetCurrentSoundDeviceType() != "DirectShow")
+ {
+ for (int i = 0; i < 2; i++)
+ {
+ if (this.rSound[i] != null)
+ {
+ TJAPlayer3.Sound邂｡逅.RemoveMixer(this.rSound[i]);
+ }
+ }
+ }
+ }
+
+ #region [ IDisposable 螳溯｣ ]
+ //-----------------
+ public void Dispose()
+ {
+ if (!this.bDisposed貂医∩)
+ {
+ for (int i = 0; i < 2; i++)
+ {
+ if (this.rSound[i] != null)
+ {
+ TJAPlayer3.Sound邂｡逅.t繧ｵ繧ｦ繝ｳ繝峨ｒ遐ｴ譽縺吶ｋ(this.rSound[i]);
+ this.rSound[i] = null;
+ }
+ }
+ this.b隱ｭ縺ｿ霎ｼ縺ｿ謌仙粥 = false;
+ this.bDisposed貂医∩ = true;
+ }
+ }
+ //-----------------
+ #endregion
+
+ #region [ private ]
+ //-----------------
+ private bool bDisposed貂医∩;
+ private int n谺｡縺ｫ魑ｴ繧九し繧ｦ繝ｳ繝臥分蜿ｷ;
+ private CSound[] rSound = new CSound[2];
+ //-----------------
+ #endregion
+ }
+
+
+ // 繝励Ο繝代ユ繧｣
+
+ public C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝 bgm繧ｪ繝励す繝ｧ繝ｳ逕ｻ髱｢ = null;
+ public C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝 bgm繧ｳ繝ｳ繝輔ぅ繧ｰ逕ｻ髱｢ = null;
+ public C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝 bgm襍ｷ蜍慕判髱｢ = null;
+ public C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝 soundSTAGEFAILED髻ｳ = null;
+ public C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝 sound繧ｫ繝ｼ繧ｽ繝ｫ遘ｻ蜍暮浹 = null;
+ public C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝 sound繧ｲ繝ｼ繝髢句ｧ矩浹 = null;
+ public C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝 sound繧ｲ繝ｼ繝邨ゆｺ髻ｳ = null;
+ public C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝 sound繧ｹ繝繝ｼ繧ｸ繧ｯ繝ｪ繧｢髻ｳ = null;
+ public C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝 sound繝輔Ν繧ｳ繝ｳ繝憺浹 = null;
+ public C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝 sound豁灘｣ｰ髻ｳ = null;
+ public C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝 sound譖ｲ隱ｭ霎ｼ髢句ｧ矩浹 = null;
+ public C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝 sound豎ｺ螳夐浹 = null;
+ public C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝 sound蜿匁ｶ磯浹 = null;
+ public C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝 sound螟画峩髻ｳ = null;
+ public C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝 soundSongSelectChara = null;
+ public C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝 soundSkip = null;
+ public C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝 soundEntry = null;
+ public C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝 soundError = null;
+ public C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝 soundsanka = null;
+ //add
+ public C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝 sound譖ｲ豎ｺ螳夐浹 = null;
+ public C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝 bgm繝ｪ繧ｶ繝ｫ繝医う繝ｳ髻ｳ = null;
+ public C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝 bgm繝ｪ繧ｶ繝ｫ繝磯浹 = null;
+
+ public C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝 bgm繧ｿ繧､繝医Ν = null;
+ public C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝 bgm繧ｿ繧､繝医Ν繧､繝ｳ = null;
+ public C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝 bgm驕ｸ譖ｲ逕ｻ髱｢ = null;
+ public C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝 bgm驕ｸ譖ｲ逕ｻ髱｢繧､繝ｳ = null;
+ public C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝 bgm繝ｪ繧ｶ繝ｫ繝 = null;
+ public C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝 bgm繝ｪ繧ｶ繝ｫ繝医う繝ｳ = null;
+
+ public C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝 SoundBanapas = null;
+
+ public C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝 sound迚ｹ險灘咲函髻ｳ = null;
+ public C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝 sound迚ｹ險灘●豁｢髻ｳ = null;
+ public C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝 sound迚ｹ險薙ず繝｣繝ｳ繝励昴う繝ｳ繝 = null;
+ public C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝 sound迚ｹ險薙せ繧ｭ繝繝鈴浹 = null;
+ public C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝 sound迚ｹ險薙せ繧ｯ繝ｭ繝ｼ繝ｫ髻ｳ = null;
+ public C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝 soundPon = null;
+ public C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝 soundGauge = null;
+ public C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝 soundScoreDon = null;
+ public C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝 soundChallengeVoice = null;
+ public C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝 soundDanSelectStart = null;
+ public C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝 soundDanSongSelectCheck = null;
+ public C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝 soundDanSelectBGM = null;
+ public C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝 soundDanSongSelect = null;
+
+ public C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝 soundCrownIn = null;
+ public C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝 soundRankIn = null;
+ public C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝 soundDonClear = null;
+ public C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝 soundDonFailed = null;
+
+ public C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝 soundSelectAnnounce = null;
+
+ //public C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝 soundRed = null;
+ //public C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝 soundBlue = null;
+ public C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝 soundBalloon = null;
+
+
+ public readonly int n繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝画焚 = (int)E繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝.Count;
+ public C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝 this[E繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝 sound]
+ {
+ get
+ {
+ switch (sound)
+ {
+ case E繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝.SOUND繧ｫ繝ｼ繧ｽ繝ｫ遘ｻ蜍暮浹:
+ return this.sound繧ｫ繝ｼ繧ｽ繝ｫ遘ｻ蜍暮浹;
+
+ case E繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝.SOUND豎ｺ螳夐浹:
+ return this.sound豎ｺ螳夐浹;
+
+ case E繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝.SOUND螟画峩髻ｳ:
+ return this.sound螟画峩髻ｳ;
+
+ case E繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝.SOUND蜿匁ｶ磯浹:
+ return this.sound蜿匁ｶ磯浹;
+
+ case E繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝.SOUND豁灘｣ｰ髻ｳ:
+ return this.sound豁灘｣ｰ髻ｳ;
+
+ case E繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝.SOUND繧ｹ繝繝ｼ繧ｸ螟ｱ謨鈴浹:
+ return this.soundSTAGEFAILED髻ｳ;
+
+ case E繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝.SOUND繧ｲ繝ｼ繝髢句ｧ矩浹:
+ return this.sound繧ｲ繝ｼ繝髢句ｧ矩浹;
+
+ case E繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝.SOUND繧ｲ繝ｼ繝邨ゆｺ髻ｳ:
+ return this.sound繧ｲ繝ｼ繝邨ゆｺ髻ｳ;
+
+ case E繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝.SOUND繧ｹ繝繝ｼ繧ｸ繧ｯ繝ｪ繧｢髻ｳ:
+ return this.sound繧ｹ繝繝ｼ繧ｸ繧ｯ繝ｪ繧｢髻ｳ;
+
+ case E繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝.SOUND繝輔Ν繧ｳ繝ｳ繝憺浹:
+ return this.sound繝輔Ν繧ｳ繝ｳ繝憺浹;
+
+ case E繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝.SOUND譖ｲ隱ｭ霎ｼ髢句ｧ矩浹:
+ return this.sound譖ｲ隱ｭ霎ｼ髢句ｧ矩浹;
+
+ case E繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝.SOUND繧ｿ繧､繝医Ν髻ｳ:
+ return this.bgm繧ｿ繧､繝医Ν;
+
+ case E繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝.BGM襍ｷ蜍慕判髱｢:
+ return this.bgm襍ｷ蜍慕判髱｢;
+
+ case E繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝.BGM繧ｪ繝励す繝ｧ繝ｳ逕ｻ髱｢:
+ return this.bgm繧ｪ繝励す繝ｧ繝ｳ逕ｻ髱｢;
+
+ case E繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝.BGM繧ｳ繝ｳ繝輔ぅ繧ｰ逕ｻ髱｢:
+ return this.bgm繧ｳ繝ｳ繝輔ぅ繧ｰ逕ｻ髱｢;
+
+ case E繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝.BGM驕ｸ譖ｲ逕ｻ髱｢:
+ return this.bgm驕ｸ譖ｲ逕ｻ髱｢;
+
+ //case E繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝.SOUND襍､:
+ // return this.soundRed;
+
+ //case E繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝.SOUND髱:
+ // return this.soundBlue;
+
+ case E繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝.SOUND鬚ｨ闊ｹ:
+ return this.soundBalloon;
+
+ case E繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝.SOUND譖ｲ豎ｺ螳夐浹:
+ return this.sound譖ｲ豎ｺ螳夐浹;
+
+ case E繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝.SOUND謌千ｸｾ逋ｺ陦ｨ:
+ return this.bgm繝ｪ繧ｶ繝ｫ繝医う繝ｳ髻ｳ;
+
+ case E繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝.SOUND迚ｹ險灘咲函:
+ return this.sound迚ｹ險灘咲函髻ｳ;
+
+ case E繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝.SOUND迚ｹ險灘●豁｢:
+ return this.sound迚ｹ險灘●豁｢髻ｳ;
+
+ case E繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝.sound迚ｹ險薙ず繝｣繝ｳ繝励昴う繝ｳ繝:
+ return this.sound迚ｹ險薙ず繝｣繝ｳ繝励昴う繝ｳ繝;
+
+ case E繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝.sound迚ｹ險薙せ繧ｭ繝繝鈴浹:
+ return this.sound迚ｹ險薙せ繧ｭ繝繝鈴浹;
+
+ case E繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝.SOUND迚ｹ險薙せ繧ｯ繝ｭ繝ｼ繝ｫ:
+ return this.sound迚ｹ險薙せ繧ｯ繝ｭ繝ｼ繝ｫ髻ｳ;
+
+ }
+ throw new IndexOutOfRangeException();
+ }
+ }
+ public C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝 this[int index]
+ {
+ get
+ {
+ switch (index)
+ {
+ case 0:
+ return this.sound繧ｫ繝ｼ繧ｽ繝ｫ遘ｻ蜍暮浹;
+
+ case 1:
+ return this.sound豎ｺ螳夐浹;
+
+ case 2:
+ return this.sound螟画峩髻ｳ;
+
+ case 3:
+ return this.sound蜿匁ｶ磯浹;
+
+ case 4:
+ return this.sound豁灘｣ｰ髻ｳ;
+
+ case 5:
+ return this.soundSTAGEFAILED髻ｳ;
+
+ case 6:
+ return this.sound繧ｲ繝ｼ繝髢句ｧ矩浹;
+
+ case 7:
+ return this.sound繧ｲ繝ｼ繝邨ゆｺ髻ｳ;
+
+ case 8:
+ return this.sound繧ｹ繝繝ｼ繧ｸ繧ｯ繝ｪ繧｢髻ｳ;
+
+ case 9:
+ return this.sound繝輔Ν繧ｳ繝ｳ繝憺浹;
+
+ case 10:
+ return this.sound譖ｲ隱ｭ霎ｼ髢句ｧ矩浹;
+
+ case 11:
+ return this.bgm繧ｿ繧､繝医Ν;
+
+ case 12:
+ return this.bgm襍ｷ蜍慕判髱｢;
+
+ case 13:
+ return this.bgm繧ｪ繝励す繝ｧ繝ｳ逕ｻ髱｢;
+
+ case 14:
+ return this.bgm繧ｳ繝ｳ繝輔ぅ繧ｰ逕ｻ髱｢;
+
+ case 15:
+ return this.bgm驕ｸ譖ｲ逕ｻ髱｢;
+
+ case 16:
+ return this.soundBalloon;
+
+ case 17:
+ return this.sound譖ｲ豎ｺ螳夐浹;
+
+ case 18:
+ return this.bgm繝ｪ繧ｶ繝ｫ繝医う繝ｳ髻ｳ;
+
+ case 19:
+ return this.sound迚ｹ險灘咲函髻ｳ;
+
+ case 20:
+ return this.sound迚ｹ險灘●豁｢髻ｳ;
+
+ case 21:
+ return this.sound迚ｹ險薙せ繧ｯ繝ｭ繝ｼ繝ｫ髻ｳ;
+
+ case 22:
+ return this.sound迚ｹ險薙ず繝｣繝ｳ繝励昴う繝ｳ繝;
+
+ case 23:
+ return this.sound迚ｹ險薙せ繧ｭ繝繝鈴浹;
+ }
+ throw new IndexOutOfRangeException();
+ }
+ }
+
+
+ // 繧ｹ繧ｭ繝ｳ縺ｮ蛻繧頑崛縺医↓縺､縺縺ｦ___
+ //
+ // _繧ｹ繧ｭ繝ｳ縺ｮ遞ｮ鬘槭ｯ螟ｧ縺阪￥蛻縺代※2遞ｮ鬘槭４ystem繧ｹ繧ｭ繝ｳ縺ｨboxdef繧ｹ繧ｭ繝ｳ縲
+ // 縲蜑崎縺ｯSystem/繝輔か繝ｫ繝縺ｫ繝ｦ繝ｼ繧ｶ繝ｼ縺瑚ｪ繧峨う繝ｳ繧ｹ繝医ｼ繝ｫ縺励※縺翫￥繧ｹ繧ｭ繝ｳ縲
+ // 縲蠕瑚縺ｯbox.def縺ｧ謖螳壹☆繧九∵峇繝繝ｼ繧ｿ蛻ｶ菴懆縺梧署遉ｺ縺吶ｋ繧ｹ繧ｭ繝ｳ縲
+ //
+ // _Config逕ｻ髱｢縺ｧ縲2遞ｮ縺ｮ繧ｹ繧ｭ繝ｳ繧貞玄蛻･辟｡縺丞ｸｸ譎ゆｽｿ逕ｨ縺吶ｋ繧医≧險ｭ螳壹☆繧九％縺ｨ縺後〒縺阪ｋ縲
+ // _box.def縺ｮ#SKINPATH 險ｭ螳壹↓繧医ｊ縲｜oxdef繧ｹ繧ｭ繝ｳ繧剃ｸ譎ら噪縺ｫ菴ｿ逕ｨ縺吶ｋ繧医≧險ｭ螳壹☆繧九
+ // 縲(box.def縺ｮ蜉ｹ譫懊ｮ蜿翫ｰ縺ｪ縺莉悶ｮmuxic box縺ｧ縺ｯ縲∝ｽ楢ｩｲboxdef繧ｹ繧ｭ繝ｳ縺ｮ譛牙柑諤ｧ縺檎┌縺上↑繧)
+ //
+ // 縺薙ｌ繧貞ｮ溽樟縺吶ｋ縺溘ａ縺ｫ___
+ // _System繧ｹ繧ｭ繝ｳ縺ｮ險ｭ螳壽ュ蝣ｱ縺ｨ縲｜oxdef繧ｹ繧ｭ繝ｳ縺ｮ險ｭ螳壽ュ蝣ｱ縺ｯ縲∝髮｢縺励※謖√▽縲
+ // 縲(strSystemｽ橸ｽ 縺ｨ縲《trBoxDefｽ橸ｽ橸ｽ)
+ // _Config逕ｻ髱｢縺九ｉ縺ｯ蜑崎縺ｮ縺ｿ譖ｸ縺肴鋤縺医〒縺阪ｋ繧医≧縺ｫ縺励
+ // 縲驕ｸ譖ｲ逕ｻ髱｢縺九ｉ縺ｯ蠕瑚縺ｮ縺ｿ譖ｸ縺肴鋤縺医〒縺阪ｋ繧医≧縺ｫ縺吶ｋ縲(SetCurrent...())
+ // _隱ｭ縺ｿ蜃ｺ縺励ｯ荳｡閠縺九ｉ陦後∴繧九ｈ縺縺ｫ縺吶ｋ縺ｨ蜈ｱ縺ｫ
+ // 縲驕ｸ譖ｲ逕ｻ髱｢逕ｨ縺ｫ莠檎ｨｮ縺ｮ諠蝣ｱ繧貞玄蛻･縺励↑縺隱ｭ縺ｿ蜃ｺ縺玲婿豕輔ｂ謠蝉ｾ帙☆繧(GetCurrent...)
+
+ private object lockBoxDefSkin;
+ public static bool bUseBoxDefSkin = true; // box.def縺九ｉ縺ｮ繧ｹ繧ｭ繝ｳ螟画峩繧定ｨｱ螳ｹ縺吶ｋ縺句凄縺
+
+ public string strSystemSkinRoot = null;
+ public string[] strSystemSkinSubfolders = null; // List縺縺ｨignoreCase縺ｪ讀懃ｴ｢縺碁擇蛟偵↑縺ｮ縺ｧ縲驟榊励↓騾縺偵ｋ :-)
+ private string[] _strBoxDefSkinSubfolders = null;
+ public string[] strBoxDefSkinSubfolders
+ {
+ get
+ {
+ lock (lockBoxDefSkin)
+ {
+ return _strBoxDefSkinSubfolders;
+ }
+ }
+ set
+ {
+ lock (lockBoxDefSkin)
+ {
+ _strBoxDefSkinSubfolders = value;
+ }
+ }
+ } // 蛻･繧ｹ繝ｬ繝繝峨°繧峨ｂ譖ｸ縺崎ｾｼ縺ｿ繧｢繧ｯ繧ｻ繧ｹ縺輔ｌ繧九◆繧√√せ繝ｬ繝繝峨そ繝ｼ繝輔↑繧｢繧ｯ繧ｻ繧ｹ豕輔ｒ謠蝉ｾ
+
+ private static string strSystemSkinSubfolderFullName; // Config逕ｻ髱｢縺ｧ險ｭ螳壹＆繧後◆繧ｹ繧ｭ繝ｳ
+ private static string strBoxDefSkinSubfolderFullName = ""; // box.def縺ｧ謖螳壹＆繧後※縺繧九せ繧ｭ繝ｳ
+
+ ///
+ /// 繧ｹ繧ｭ繝ｳ繝代せ蜷阪ｒ繝輔Ν繝代せ縺ｧ蜿門ｾ励☆繧
+ ///
+ /// 繝ｦ繝ｼ繧ｶ繝ｼ險ｭ螳夂畑縺ｪ繧液rue, box.def縺九ｉ縺ｮ險ｭ螳壹↑繧映alse
+ ///
+ public string GetCurrentSkinSubfolderFullName(bool bFromUserConfig)
+ {
+ if (!bUseBoxDefSkin || bFromUserConfig == true || strBoxDefSkinSubfolderFullName == "")
+ {
+ return strSystemSkinSubfolderFullName;
+ }
+ else
+ {
+ return strBoxDefSkinSubfolderFullName;
+ }
+ }
+ ///
+ /// 繧ｹ繧ｭ繝ｳ繝代せ蜷阪ｒ繝輔Ν繝代せ縺ｧ險ｭ螳壹☆繧
+ ///
+ /// 繧ｹ繧ｭ繝ｳ繝代せ蜷
+ /// 繝ｦ繝ｼ繧ｶ繝ｼ險ｭ螳夂畑縺ｪ繧液rue, box.def縺九ｉ縺ｮ險ｭ螳壹↑繧映alse
+ public void SetCurrentSkinSubfolderFullName(string value, bool bFromUserConfig)
+ {
+ if (bFromUserConfig)
+ {
+ strSystemSkinSubfolderFullName = value;
+ }
+ else
+ {
+ strBoxDefSkinSubfolderFullName = value;
+ }
+ }
+
+
+ // 繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ
+ public CSkin(string _strSkinSubfolderFullName, bool _bUseBoxDefSkin)
+ {
+ lockBoxDefSkin = new object();
+ strSystemSkinSubfolderFullName = _strSkinSubfolderFullName;
+ bUseBoxDefSkin = _bUseBoxDefSkin;
+ InitializeSkinPathRoot();
+ ReloadSkinPaths();
+ PrepareReloadSkin();
+ }
+ public CSkin()
+ {
+ lockBoxDefSkin = new object();
+ InitializeSkinPathRoot();
+ bUseBoxDefSkin = true;
+ ReloadSkinPaths();
+ PrepareReloadSkin();
+ }
+ private string InitializeSkinPathRoot()
+ {
+ strSystemSkinRoot = System.IO.Path.Combine(TJAPlayer3.strEXE縺ｮ縺ゅｋ繝輔か繝ｫ繝, "System" + System.IO.Path.DirectorySeparatorChar);
+ return strSystemSkinRoot;
+ }
+
+ ///
+ /// Skin(Sounds)繧貞崎ｪｭ霎ｼ縺吶ｋ貅門ｙ繧偵☆繧(蜀咲函蛛懈ｭ｢,Dispose,繝輔ぃ繧､繝ｫ蜷榊崎ｨｭ螳)縲
+ /// 縺ゅｉ縺九§繧《trSkinSubfolder繧帝←蛻縺ｫ險ｭ螳壹＠縺ｦ縺翫￥縺薙→縲
+ /// 縺昴ｮ蠕後ヽeloadSkinPaths()繧貞ｮ溯｡後＠縲《trSkinSubfolder縺ｮ豁｣蠖捺ｧ繧堤｢ｺ隱阪＠縺滉ｸ翫〒縲∵悽繝｡繧ｽ繝繝峨ｒ蜻ｼ縺ｳ蜃ｺ縺吶％縺ｨ縲
+ /// 譛ｬ繝｡繧ｽ繝繝牙他縺ｳ蜃ｺ縺怜ｾ後↓縲ヽeloadSkin()繧貞ｮ溯｡後☆繧九％縺ｨ縺ｧ縲√す繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝峨ｒ隱ｭ縺ｿ霎ｼ縺ｿ逶ｴ縺吶
+ /// ReloadSkin()縺ｮ蜀螳ｹ縺ｯ譛ｬ繝｡繧ｽ繝繝牙縺ｫ蜷ｫ繧√↑縺縺薙→縲りｵｷ蜍墓凾縺ｯReloadSkin()逶ｸ蠖薙ｮ蜃ｦ逅繧辰EnumSongs縺ｧ陦後▲縺ｦ縺繧九◆繧√
+ ///
+ public void PrepareReloadSkin()
+ {
+ Trace.TraceInformation("SkinPath險ｭ螳: {0}",
+ (strBoxDefSkinSubfolderFullName == "") ?
+ strSystemSkinSubfolderFullName :
+ strBoxDefSkinSubfolderFullName
+ );
+
+ for (int i = 0; i < n繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝画焚; i++)
+ {
+ if (this[i] != null && this[i].b隱ｭ縺ｿ霎ｼ縺ｿ謌仙粥)
+ {
+ this[i].t蛛懈ｭ｢縺吶ｋ();
+ this[i].Dispose();
+ }
+ }
+
+ this.sound繧ｫ繝ｼ繧ｽ繝ｫ遘ｻ蜍暮浹 = new C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝(@"Sounds\Move.ogg", false, false, false, ESoundGroup.SoundEffect);
+ this.sound豎ｺ螳夐浹 = new C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝(@"Sounds\Decide.ogg", false, false, false, ESoundGroup.SoundEffect);
+ this.sound螟画峩髻ｳ = new C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝(@"Sounds\Change.ogg", false, false, false, ESoundGroup.SoundEffect);
+ this.sound蜿匁ｶ磯浹 = new C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝(@"Sounds\Cancel.ogg", false, false, true, ESoundGroup.SoundEffect);
+ this.sound豁灘｣ｰ髻ｳ = new C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝(@"Sounds\Audience.ogg", false, false, true, ESoundGroup.SoundEffect);
+ this.soundSTAGEFAILED髻ｳ = new C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝(@"Sounds\Stage failed.ogg", false, true, true, ESoundGroup.Voice);
+ this.sound繧ｲ繝ｼ繝髢句ｧ矩浹 = new C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝(@"Sounds\Game start.ogg", false, false, false, ESoundGroup.Voice);
+ this.sound繧ｲ繝ｼ繝邨ゆｺ髻ｳ = new C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝(@"Sounds\Game end.ogg", false, true, false, ESoundGroup.Voice);
+ this.sound繧ｹ繝繝ｼ繧ｸ繧ｯ繝ｪ繧｢髻ｳ = new C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝(@"Sounds\Stage clear.ogg", false, true, true, ESoundGroup.Voice);
+ this.sound繝輔Ν繧ｳ繝ｳ繝憺浹 = new C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝(@"Sounds\Full combo.ogg", false, false, true, ESoundGroup.Voice);
+ this.sound譖ｲ隱ｭ霎ｼ髢句ｧ矩浹 = new C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝(@"Sounds\Now loading.ogg", false, true, true, ESoundGroup.Unknown);
+ this.bgm襍ｷ蜍慕判髱｢ = new C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝(@"Sounds\Setup BGM.ogg", true, true, false, ESoundGroup.SongPlayback);
+ this.bgm繧ｪ繝励す繝ｧ繝ｳ逕ｻ髱｢ = new C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝(@"Sounds\Option BGM.ogg", true, true, false, ESoundGroup.SongPlayback);
+ this.bgm繧ｳ繝ｳ繝輔ぅ繧ｰ逕ｻ髱｢ = new C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝(@"Sounds\Config BGM.ogg", true, true, false, ESoundGroup.SongPlayback);
+ this.bgm驕ｸ譖ｲ逕ｻ髱｢ = new C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝(@"Sounds\Select BGM.ogg", true, true, false, ESoundGroup.SongPlayback);
+ this.soundSongSelectChara = new C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝(@"Sounds\SongSelect Chara.ogg", false, false, false, ESoundGroup.SongPlayback);
+ this.soundSkip = new C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝(@"Sounds\Skip.ogg", false, false, false, ESoundGroup.SoundEffect);
+ this.SoundBanapas = new C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝(@"Sounds\Banapas.ogg", false, false, false, ESoundGroup.SoundEffect);
+ this.soundEntry = new C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝(@"Sounds\Entry.ogg", true, false, false, ESoundGroup.Voice);
+ this.soundError = new C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝(@"Sounds\Error.ogg", false, false, false, ESoundGroup.SoundEffect);
+ this.soundsanka = new C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝(@"Sounds\sanka.ogg", false, false, false, ESoundGroup.Voice);
+
+ //this.soundRed = new C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝( @"Sounds\dong.ogg", false, false, true, ESoundType.SoundEffect );
+ //this.soundBlue = new C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝( @"Sounds\ka.ogg", false, false, true, ESoundType.SoundEffect );
+ this.soundBalloon = new C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝(@"Sounds\balloon.ogg", false, false, true, ESoundGroup.SoundEffect);
+ this.sound譖ｲ豎ｺ螳夐浹 = new C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝(@"Sounds\SongDecide.ogg", false, false, true, ESoundGroup.Voice);
+
+ this.bgm繧ｿ繧､繝医Ν繧､繝ｳ = new C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝(@"Sounds\BGM\Title_Start.ogg", false, false, true, ESoundGroup.SongPlayback);
+ this.bgm繧ｿ繧､繝医Ν = new C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝(@"Sounds\BGM\Title.ogg", true, false, true, ESoundGroup.SongPlayback);
+ this.bgm驕ｸ譖ｲ逕ｻ髱｢繧､繝ｳ = new C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝(@"Sounds\BGM\SongSelect_Start.ogg", false, false, true, ESoundGroup.SongPlayback);
+ this.bgm驕ｸ譖ｲ逕ｻ髱｢ = new C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝(@"Sounds\BGM\SongSelect.ogg", true, false, true, ESoundGroup.SongPlayback);
+ this.bgm繝ｪ繧ｶ繝ｫ繝医う繝ｳ髻ｳ = new C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝(@"Sounds\BGM\Result_In.ogg", false, false, true, ESoundGroup.SongPlayback);
+ this.bgm繝ｪ繧ｶ繝ｫ繝磯浹 = new C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝(@"Sounds\BGM\Result.ogg", true, false, true, ESoundGroup.SongPlayback);
+
+
+ this.soundCrownIn = new C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝(@"Sounds\ResultScreen\CrownIn.ogg", false, false, false, ESoundGroup.SoundEffect);
+ this.soundRankIn = new C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝(@"Sounds\ResultScreen\RankIn.ogg", false, false, false, ESoundGroup.SoundEffect);
+ this.soundDonClear = new C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝(@"Sounds\ResultScreen\Donchan_Clear.ogg", false, false,true, ESoundGroup.Voice);
+ this.soundDonFailed = new C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝(@"Sounds\ResultScreen\Donchan_Miss.ogg", false, false, true, ESoundGroup.Voice);
+
+ this.soundSelectAnnounce = new C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝(@"Sounds\DiffSelect.ogg", false, false, true, ESoundGroup.Voice);
+ this.sound迚ｹ險灘咲函髻ｳ = new C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝(@"Sounds\Resume.ogg", false, false,false, ESoundGroup.SoundEffect);
+ this.sound迚ｹ險灘●豁｢髻ｳ = new C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝(@"Sounds\Pause.ogg", false, false, false, ESoundGroup.SoundEffect);
+ this.sound迚ｹ險薙せ繧ｯ繝ｭ繝ｼ繝ｫ髻ｳ = new C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝(@"Sounds\Scroll.ogg", false, false, false, ESoundGroup.SoundEffect);
+ this.sound迚ｹ險薙ず繝｣繝ｳ繝励昴う繝ｳ繝 = new C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝(@"Sounds\Jump Point.ogg", false, false, false, ESoundGroup.SoundEffect);
+ this.sound迚ｹ險薙せ繧ｭ繝繝鈴浹 = new C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝(@"Sounds\Traning Skip.ogg", false, false, false, ESoundGroup.SoundEffect);
+ this.soundPon = new C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝(@"Sounds\Pon.ogg", false, false, false, ESoundGroup.SoundEffect);
+ this.soundGauge = new C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝(@"Sounds\Gauge.ogg", false, false, false, ESoundGroup.SoundEffect);
+ this.soundScoreDon = new C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝(@"Sounds\ScoreDon.ogg", false, false, false, ESoundGroup.SoundEffect);
+ this.soundChallengeVoice = new C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝(@"Sounds\Dan\ChallengeVoice.wav", false, false, false, ESoundGroup.SoundEffect);
+ this.soundDanSelectStart = new C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝(@"Sounds\Dan\DanSelectStart.wav", false, false, false, ESoundGroup.SoundEffect);
+ this.soundDanSongSelectCheck = new C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝(@"Sounds\Dan\DanSongSelectCheck.wav", false, false, false, ESoundGroup.SoundEffect);
+ this.soundDanSelectBGM = new C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝(@"Sounds\Dan\DanSelectBGM.wav", true, false, false, ESoundGroup.SongPlayback);
+ this.soundDanSongSelect = new C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝(@"Sounds\Dan\DanSongSelect.wav", false, false, false, ESoundGroup.SoundEffect);
+ ReloadSkin();
+ tReadSkinConfig();
+ }
+
+ public void ReloadSkin()
+ {
+ for (int i = 0; i < n繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝画焚; i++)
+ {
+ if (!this[i].b謗剃ｻ) // BGM邉ｻ莉･螟悶ｮ縺ｿ隱ｭ縺ｿ霎ｼ繧縲(BGM邉ｻ縺ｯ蠢隕√↓縺ｪ縺｣縺溘→縺阪↓隱ｭ縺ｿ霎ｼ繧)
+ {
+ C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝 c繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝 = this[i];
+ if (!TJAPlayer3.b繧ｳ繝ｳ繝代け繝医Δ繝ｼ繝 || c繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝.bCompact蟇ｾ雎｡)
+ {
+ try
+ {
+ c繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝.t隱ｭ縺ｿ霎ｼ縺ｿ();
+ Trace.TraceInformation("繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝峨ｒ隱ｭ縺ｿ霎ｼ縺ｿ縺ｾ縺励◆縲({0})", c繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝.str繝輔ぃ繧､繝ｫ蜷);
+ }
+ catch (FileNotFoundException e)
+ {
+ Trace.TraceWarning(e.ToString());
+ Trace.TraceWarning("繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝峨′蟄伜惠縺励∪縺帙ｓ縲({0})", c繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝.str繝輔ぃ繧､繝ｫ蜷);
+ }
+ catch (Exception e)
+ {
+ Trace.TraceWarning(e.ToString());
+ Trace.TraceWarning("繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝峨ｮ隱ｭ縺ｿ霎ｼ縺ｿ縺ｫ螟ｱ謨励＠縺ｾ縺励◆縲({0})", c繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝.str繝輔ぃ繧､繝ｫ蜷);
+ }
+ }
+ }
+ }
+ }
+
+
+ ///
+ /// Skin縺ｮ荳隕ｧ繧貞榊叙蠕励☆繧九
+ /// System/*****/Graphics (繧Тounds/) 縺ｨ縺縺繝輔か繝ｫ繝讒区舌ｒ諠ｳ螳壹＠縺ｦ縺繧九
+ /// 繧ゅ＠蜀榊叙蠕励ｮ邨先棡縲∫樟蝨ｨ菴ｿ逕ｨ荳ｭ縺ｮSkin縺ｮ繝代せ(strSystemSkinSubfloderFullName)縺梧ｶ医∴縺ｦ縺縺溷ｴ蜷医ｯ縲
+ /// 莉･荳九ｮ蜆ｪ蜈磯菴阪〒蟄伜惠遒ｺ隱阪ｮ荳郭trSystemSkinSubfolderFullName繧貞崎ｨｭ螳壹☆繧九
+ /// 1. System/Default/
+ /// 2. System/*****/ 縺ｧ譛蛻昴↓enumerate縺輔ｌ縺溘ｂ縺ｮ
+ /// 3. System/ (蠕捺擂莠呈鋤)
+ ///
+ public void ReloadSkinPaths()
+ {
+ #region [ 縺ｾ縺 System/*** 繧弾numerate縺吶ｋ ]
+ string[] tempSkinSubfolders = System.IO.Directory.GetDirectories(strSystemSkinRoot, "*");
+ strSystemSkinSubfolders = new string[tempSkinSubfolders.Length];
+ int size = 0;
+ for (int i = 0; i < tempSkinSubfolders.Length; i++)
+ {
+ #region [ 讀懷ｺ縺励◆繝輔か繝ｫ繝縺後せ繧ｭ繝ｳ繝輔か繝ｫ繝縺九←縺縺狗｢ｺ隱阪☆繧犠
+ if (!bIsValid(tempSkinSubfolders[i]))
+ continue;
+ #endregion
+ #region [ 繧ｹ繧ｭ繝ｳ繝輔か繝ｫ繝縺ｨ遒ｺ隱阪〒縺阪◆繧ゅｮ繧偵《trSkinSubfolders縺ｫ蜈･繧後ｋ ]
+ // 繝輔か繝ｫ繝蜷肴忰蟆ｾ縺ｫ蠢縺喀繧偵▽縺代※縺翫￥縺薙→縲ゅ＆繧ゅ↑縺縺ｨConfig隱ｭ縺ｿ蜃ｺ縺怜ｴ(蠢縺喀繧偵▽縺代ｋ)縺ｨ繝槭ャ繝√〒縺阪↑縺
+ if (tempSkinSubfolders[i][tempSkinSubfolders[i].Length - 1] != System.IO.Path.DirectorySeparatorChar)
+ {
+ tempSkinSubfolders[i] += System.IO.Path.DirectorySeparatorChar;
+ }
+ strSystemSkinSubfolders[size] = tempSkinSubfolders[i];
+ Trace.TraceInformation("SkinPath讀懷ｺ: {0}", strSystemSkinSubfolders[size]);
+ size++;
+ #endregion
+ }
+ Trace.TraceInformation("SkinPath蜈･蜉: {0}", strSystemSkinSubfolderFullName);
+ Array.Resize(ref strSystemSkinSubfolders, size);
+ Array.Sort(strSystemSkinSubfolders); // BinarySearch螳溯｡悟燕縺ｫSort縺悟ｿ隕
+ #endregion
+
+ #region [ 迴ｾ蝨ｨ縺ｮSkin繝代せ縺恵ox.def繧ｹ繧ｭ繝ｳ繧辰ONFIG謖螳壹＠縺ｦ縺縺溷ｴ蜷医ｮ縺溘ａ縺ｫ縲∵怙蛻昴↓縺薙ｌ縺梧怏蜉ｹ縺九メ繧ｧ繝繧ｯ縺吶ｋ縲よ怏蜉ｹ縺ｪ繧峨％繧後ｒ菴ｿ縺縲 ]
+ if (bIsValid(strSystemSkinSubfolderFullName) &&
+ Array.BinarySearch(strSystemSkinSubfolders, strSystemSkinSubfolderFullName,
+ StringComparer.InvariantCultureIgnoreCase) < 0)
+ {
+ strBoxDefSkinSubfolders = new string[1] { strSystemSkinSubfolderFullName };
+ return;
+ }
+ #endregion
+
+ #region [ 谺｡縺ｫ縲∫樟蝨ｨ縺ｮSkin繝代せ縺悟ｭ伜惠縺吶ｋ縺玖ｪｿ縺ｹ繧九ゅ≠繧後ｰ邨ゆｺ縲]
+ if (Array.BinarySearch(strSystemSkinSubfolders, strSystemSkinSubfolderFullName,
+ StringComparer.InvariantCultureIgnoreCase) >= 0)
+ return;
+ #endregion
+ #region [ 繧ｫ繝ｬ繝ｳ繝医ｮSkin繝代せ縺梧ｶ域ｻ縺励※縺繧九ｮ縺ｧ縲∽ｻ･荳九〒蜀崎ｨｭ螳壹☆繧九]
+ /// 莉･荳九ｮ蜆ｪ蜈磯菴阪〒迴ｾ蝨ｨ菴ｿ逕ｨ荳ｭ縺ｮSkin繝代せ繧貞崎ｨｭ螳壹☆繧九
+ /// 1. System/Default/
+ /// 2. System/*****/ 縺ｧ譛蛻昴↓enumerate縺輔ｌ縺溘ｂ縺ｮ
+ /// 3. System/ (蠕捺擂莠呈鋤)
+ #region [ System/Default/ 縺後≠繧九↑繧峨√◎縺薙↓繧ｫ繝ｬ繝ｳ繝Skin繝代せ繧定ｨｭ螳壹☆繧犠
+ string tempSkinPath_default = System.IO.Path.Combine(strSystemSkinRoot, "Default" + System.IO.Path.DirectorySeparatorChar);
+ if (Array.BinarySearch(strSystemSkinSubfolders, tempSkinPath_default,
+ StringComparer.InvariantCultureIgnoreCase) >= 0)
+ {
+ strSystemSkinSubfolderFullName = tempSkinPath_default;
+ return;
+ }
+ #endregion
+ #region [ System/SkinFiles.*****/ 縺ｧ譛蛻昴↓enumerate縺輔ｌ縺溘ｂ縺ｮ繧偵√き繝ｬ繝ｳ繝Skin繝代せ縺ｫ蜀崎ｨｭ螳壹☆繧 ]
+ if (strSystemSkinSubfolders.Length > 0)
+ {
+ strSystemSkinSubfolderFullName = strSystemSkinSubfolders[0];
+ return;
+ }
+ #endregion
+ #region [ System/ 縺ｫ縲√き繝ｬ繝ｳ繝Skin繝代せ繧貞崎ｨｭ螳壹☆繧九]
+ strSystemSkinSubfolderFullName = strSystemSkinRoot;
+ strSystemSkinSubfolders = new string[1] { strSystemSkinSubfolderFullName };
+ #endregion
+ #endregion
+ }
+
+ // 繝｡繧ｽ繝繝
+
+ public static string Path(string str繝輔ぃ繧､繝ｫ縺ｮ逶ｸ蟇ｾ繝代せ)
+ {
+ if (strBoxDefSkinSubfolderFullName == "" || !bUseBoxDefSkin)
+ {
+ return System.IO.Path.Combine(strSystemSkinSubfolderFullName, str繝輔ぃ繧､繝ｫ縺ｮ逶ｸ蟇ｾ繝代せ);
+ }
+ else
+ {
+ return System.IO.Path.Combine(strBoxDefSkinSubfolderFullName, str繝輔ぃ繧､繝ｫ縺ｮ逶ｸ蟇ｾ繝代せ);
+ }
+ }
+
+ ///
+ /// 繝輔Ν繝代せ蜷阪ｒ荳弱∴繧九→縲√せ繧ｭ繝ｳ蜷阪→縺励※縲√ョ繧｣繝ｬ繧ｯ繝医Μ蜷肴忰蟆ｾ縺ｮ隕∫ｴ繧定ｿ斐☆
+ /// 萓: C:\foo\bar\ 縺ｪ繧峨｜ar繧定ｿ斐☆
+ ///
+ /// 繧ｹ繧ｭ繝ｳ縺梧ｼ邏阪＆繧後◆繝代せ蜷(繝輔Ν繝代せ)
+ /// 繧ｹ繧ｭ繝ｳ蜷
+ public static string GetSkinName(string skinPathFullName)
+ {
+ if (skinPathFullName != null)
+ {
+ if (skinPathFullName == "") // 縲恵ox.def縺ｧ譛ｪ螳夂ｾｩ縲咲畑
+ skinPathFullName = strSystemSkinSubfolderFullName;
+ string[] tmp = skinPathFullName.Split(System.IO.Path.DirectorySeparatorChar);
+ return tmp[tmp.Length - 2]; // 繝繧｣繝ｬ繧ｯ繝医Μ蜷阪ｮ譛蠕後°繧2逡ｪ逶ｮ縺ｮ隕∫ｴ縺後せ繧ｭ繝ｳ蜷(譛蠕後ｮ隕∫ｴ縺ｯnull縲ょピtring縺ｮ譛ｫ蟆ｾ縺圭縺ｪ縺ｮ縺ｧ縲)
+ }
+ return null;
+ }
+ public static string[] GetSkinName(string[] skinPathFullNames)
+ {
+ string[] ret = new string[skinPathFullNames.Length];
+ for (int i = 0; i < skinPathFullNames.Length; i++)
+ {
+ ret[i] = GetSkinName(skinPathFullNames[i]);
+ }
+ return ret;
+ }
+
+
+ public string GetSkinSubfolderFullNameFromSkinName(string skinName)
+ {
+ foreach (string s in strSystemSkinSubfolders)
+ {
+ if (GetSkinName(s) == skinName)
+ return s;
+ }
+ foreach (string b in strBoxDefSkinSubfolders)
+ {
+ if (GetSkinName(b) == skinName)
+ return b;
+ }
+ return null;
+ }
+
+ ///
+ /// 繧ｹ繧ｭ繝ｳ繝代せ蜷阪′螯･蠖薙°縺ｩ縺縺
+ /// (繧ｿ繧､繝医Ν逕ｻ蜒上↓繧｢繧ｯ繧ｻ繧ｹ縺ｧ縺阪ｋ縺九←縺縺九〒蛻､螳壹☆繧)
+ ///
+ /// 螯･蠖捺ｧ繧堤｢ｺ隱阪☆繧九せ繧ｭ繝ｳ繝代せ(繝輔Ν繝代せ)
+ /// 螯･蠖薙↑繧液rue
+ public bool bIsValid(string skinPathFullName)
+ {
+ string filePathTitle;
+ filePathTitle = System.IO.Path.Combine(skinPathFullName, @"Graphics\1_Title\Background.png");
+ return (File.Exists(filePathTitle));
+ }
+
+
+ public void tRemoveMixerAll()
+ {
+ for (int i = 0; i < n繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝画焚; i++)
+ {
+ if (this[i] != null && this[i].b隱ｭ縺ｿ霎ｼ縺ｿ謌仙粥)
+ {
+ this[i].t蛛懈ｭ｢縺吶ｋ();
+ this[i].tRemoveMixer();
+ }
+ }
+
+ }
+
+ ///
+ /// 螟画焚縺ｮ蛻晄悄蛹
+ ///
+ public void tSkinConfigInit()
+ {
+ this.eDiffDispMode = E髮｣譏灘ｺｦ陦ｨ遉ｺ繧ｿ繧､繝.mtaiko縺ｫ逕ｻ蜒上〒陦ｨ遉ｺ;
+ this.b迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ謨ｰ繧定｡ｨ遉ｺ縺励↑縺 = false;
+ }
+
+ public void tReadSkinConfig()
+ {
+ var str = "";
+ LoadSkinConfigFromFile(Path(@"SkinConfig.ini"), ref str);
+ this.t譁蟄怜励°繧芽ｪｭ縺ｿ霎ｼ縺ｿ(str);
+
+ void LoadSkinConfigFromFile(string path, ref string work)
+ {
+ if (!File.Exists(Path(path))) return;
+ using (var streamReader = new StreamReader(Path(path), Encoding.GetEncoding("Shift_JIS")))
+ {
+ while (streamReader.Peek() > -1) // 荳陦後★縺､隱ｭ縺ｿ霎ｼ繧縲
+ {
+ var nowLine = streamReader.ReadLine();
+ if (nowLine.StartsWith("#include"))
+ {
+ // #include hogehoge.ini縺ｫ縺ｶ縺｡蠖薙◆縺｣縺
+ var includePath = nowLine.Substring("#include ".Length).Trim();
+ LoadSkinConfigFromFile(includePath, ref work); // 蜀榊ｸｰ逧縺ｫ隱ｭ縺ｿ霎ｼ繧
+ }
+ else
+ {
+ work += nowLine + Environment.NewLine;
+ }
+ }
+ }
+ }
+ }
+
+ private void t譁蟄怜励°繧芽ｪｭ縺ｿ霎ｼ縺ｿ(string strAllSettings) // 2011.4.13 yyagi; refactored to make initial KeyConfig easier.
+ {
+ string[] delimiter = { "\n" };
+ string[] strSingleLine = strAllSettings.Split(delimiter, StringSplitOptions.RemoveEmptyEntries);
+ foreach (string s in strSingleLine)
+ {
+ string str = s.Replace('\t', ' ').TrimStart(new char[] { '\t', ' ' });
+ if ((str.Length != 0) && (str[0] != ';'))
+ {
+ try
+ {
+ string strCommand;
+ string strParam;
+ string[] strArray = str.Split(new char[] { '=' });
+ if (strArray.Length == 2)
+ {
+ strCommand = strArray[0].Trim();
+ strParam = strArray[1].Trim();
+
+ #region 繧ｹ繧ｭ繝ｳ險ｭ螳
+
+ void ParseInt32(Action setValue)
+ {
+ if (int.TryParse(strParam, out var unparsedValue))
+ {
+ setValue(unparsedValue);
+ }
+ else
+ {
+ Trace.TraceWarning($"SkinConfig縺ｮ蛟､ {strCommand} 縺ｯ謨ｴ謨ｰ蛟､縺ｧ縺ゅｋ蠢隕√′縺ゅｊ縺ｾ縺吶ら樟蝨ｨ縺ｮ蛟､: {strParam}");
+ }
+ }
+
+ if (strCommand == "Name")
+ {
+ this.Skin_Name = strParam;
+ }
+ else if (strCommand == "Version")
+ {
+ this.Skin_Version = strParam;
+ }
+ else if (strCommand == "Creator")
+ {
+ this.Skin_Creator = strParam;
+ }
+ #endregion
+
+ #region 閭梧勹(繧ｹ繧ｯ繝ｭ繝ｼ繝ｫ)
+ else if (strCommand == "Background_Scroll_Y")
+ {
+ string[] strSplit = strParam.Split(',');
+ for (int i = 0; i < 2; i++)
+ {
+ this.Background_Scroll_Y[i] = int.Parse(strSplit[i]);
+ }
+ }
+ #endregion
+
+ #region[ 貍泌･ ]
+ //-----------------------------
+ else if (strCommand == "ScrollFieldP1Y")
+ {
+ this.nScrollFieldY[0] = C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ霑斐☆(strParam, 192);
+ }
+ else if (strCommand == "ScrollFieldP2Y")
+ {
+ this.nScrollFieldY[1] = C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ霑斐☆(strParam, 192);
+ }
+ else if (strCommand == "SENotesP1Y")
+ {
+ this.nSENotesY[0] = C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ霑斐☆(strParam, this.nSENotesY[0]);
+ }
+ else if (strCommand == "SENotesP2Y")
+ {
+ this.nSENotesY[1] = C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ霑斐☆(strParam, this.nSENotesY[1]);
+ }
+ else if (strCommand == "JudgePointP1Y")
+ {
+ this.nJudgePointY[0] = C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ霑斐☆(strParam, this.nJudgePointY[0]);
+ }
+ else if (strCommand == "JudgePointP2Y")
+ {
+ this.nJudgePointY[1] = C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ霑斐☆(strParam, this.nJudgePointY[1]);
+ }
+
+ else if (strCommand == "DiffDispMode")
+ {
+ this.eDiffDispMode = (E髮｣譏灘ｺｦ陦ｨ遉ｺ繧ｿ繧､繝)C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ遽蝗ｲ蜀縺ｫ荳ｸ繧√※霑斐☆(strParam, 0, 2, (int)this.eDiffDispMode);
+ }
+ else if (strCommand == "NowStageDisp")
+ {
+ this.b迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ謨ｰ繧定｡ｨ遉ｺ縺励↑縺 = C螟画鋤.bONorOFF(strParam[0]);
+ }
+
+ //-----------------------------
+ #endregion
+ #region[ 謌千ｸｾ逋ｺ陦ｨ ]
+ //-----------------------------
+ else if (strCommand == "ResultPanelP1X")
+ {
+ this.nResultPanelP1X = C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ霑斐☆(strParam, 515);
+ }
+ else if (strCommand == "ResultPanelP1Y")
+ {
+ this.nResultPanelP1Y = C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ霑斐☆(strParam, 75);
+ }
+ else if (strCommand == "ResultPanelP2X")
+ {
+ this.nResultPanelP2X = C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ霑斐☆(strParam, 515);
+ }
+ else if (strCommand == "ResultPanelP2Y")
+ {
+ this.nResultPanelP2Y = C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ霑斐☆(strParam, 75);
+ }
+ else if (strCommand == "ResultScoreP1X")
+ {
+ this.nResultScoreP1X = C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ霑斐☆(strParam, 582);
+ }
+ else if (strCommand == "ResultScoreP1Y")
+ {
+ this.nResultScoreP1Y = C螟画鋤.n蛟､繧呈枚蟄怜励°繧牙叙蠕励＠縺ｦ霑斐☆(strParam, 252);
+ }
+ //-----------------------------
+ #endregion
+ #region[ 縺昴ｮ莉 ]
+ #endregion
+
+ #region 譁ｰ繝ｻSkinConfig
+ #region Config
+ else if (strCommand == nameof(Config_ItemText_Correction_X))
+ {
+ Config_ItemText_Correction_X = int.Parse(strParam);
+ }
+ else if (strCommand == nameof(Config_ItemText_Correction_Y))
+ {
+ Config_ItemText_Correction_Y = int.Parse(strParam);
+ }
+ #endregion
+ #region SongSelect
+ else if (strCommand == "SongSelect_Overall_Y")
+ {
+ if (int.Parse(strParam) != 0)
+ {
+ SongSelect_Overall_Y = int.Parse(strParam);
+ }
+ }
+ else if (strCommand == "SongSelect_BoxExplanation_X")
+ {
+ SongSelect_BoxExplanation_X = int.Parse(strParam);
+ }
+ else if (strCommand == "SongSelect_BoxExplanation_Y")
+ {
+ SongSelect_BoxExplanation_Y = int.Parse(strParam);
+ }
+ else if (strCommand == "SongSelect_Title_X")
+ {
+ SongSelect_Title_X = int.Parse(strParam);
+ }
+ else if (strCommand == "SongSelect_Title_Y")
+ {
+ SongSelect_Title_Y = int.Parse(strParam);
+ }
+ else if (strCommand == "SongSelect_BoxExplanation_Interval")
+ {
+ SongSelect_BoxExplanation_Interval = int.Parse(strParam);
+ }
+ else if (strCommand == "SongSelect_GenreName")
+ {
+ SongSelect_GenreName = this.strString繧帝榊励↓逶ｴ縺(strParam);
+ }
+ else if (strCommand == "SongSelect_NamePlate_X")
+ {
+ string[] strSplit = strParam.Split(',');
+ for (int i = 0; i < 2; i++)
+ {
+ SongSelect_NamePlate_X[i] = int.Parse(strSplit[i]);
+ }
+ }
+ else if (strCommand == "SongSelect_NamePlate_Y")
+ {
+ string[] strSplit = strParam.Split(',');
+ for (int i = 0; i < 2; i++)
+ {
+ SongSelect_NamePlate_Y[i] = int.Parse(strSplit[i]);
+ }
+ }
+ else if (strCommand == "SongSelect_Auto_X")
+ {
+ string[] strSplit = strParam.Split(',');
+ for (int i = 0; i < 2; i++)
+ {
+ SongSelect_Auto_X[i] = int.Parse(strSplit[i]);
+ }
+ }
+ else if (strCommand == "SongSelect_Auto_Y")
+ {
+ string[] strSplit = strParam.Split(',');
+ for (int i = 0; i < 2; i++)
+ {
+ SongSelect_Auto_Y[i] = int.Parse(strSplit[i]);
+ }
+ }
+ else if (strCommand == "SongSelect_ForeColor_JPOP")
+ {
+ SongSelect_ForeColor_JPOP = ColorTranslator.FromHtml(strParam);
+ }
+ else if (strCommand == "SongSelect_ForeColor_Anime")
+ {
+ SongSelect_ForeColor_Anime = ColorTranslator.FromHtml(strParam);
+ }
+ else if (strCommand == "SongSelect_ForeColor_VOCALOID")
+ {
+ SongSelect_ForeColor_VOCALOID = ColorTranslator.FromHtml(strParam);
+ }
+ else if (strCommand == "SongSelect_ForeColor_Children")
+ {
+ SongSelect_ForeColor_Children = ColorTranslator.FromHtml(strParam);
+ }
+ else if (strCommand == "SongSelect_ForeColor_Variety")
+ {
+ SongSelect_ForeColor_Variety = ColorTranslator.FromHtml(strParam);
+ }
+ else if (strCommand == "SongSelect_ForeColor_Classic")
+ {
+ SongSelect_ForeColor_Classic = ColorTranslator.FromHtml(strParam);
+ }
+ else if (strCommand == "SongSelect_ForeColor_GameMusic")
+ {
+ SongSelect_ForeColor_GameMusic = ColorTranslator.FromHtml(strParam);
+ }
+ else if (strCommand == nameof(SongSelect_ForeColor_Namco))
+ {
+ SongSelect_ForeColor_GameMusic = ColorTranslator.FromHtml(strParam);
+ }
+ else if (strCommand == "SongSelect_BackColor_JPOP")
+ {
+ SongSelect_BackColor_JPOP = ColorTranslator.FromHtml(strParam);
+ }
+ else if (strCommand == "SongSelect_BackColor_Anime")
+ {
+ SongSelect_BackColor_Anime = ColorTranslator.FromHtml(strParam);
+ }
+ else if (strCommand == "SongSelect_BackColor_VOCALOID")
+ {
+ SongSelect_BackColor_VOCALOID = ColorTranslator.FromHtml(strParam);
+ }
+ else if (strCommand == "SongSelect_BackColor_Children")
+ {
+ SongSelect_BackColor_Children = ColorTranslator.FromHtml(strParam);
+ }
+ else if (strCommand == "SongSelect_BackColor_Variety")
+ {
+ SongSelect_BackColor_Variety = ColorTranslator.FromHtml(strParam);
+ }
+ else if (strCommand == "SongSelect_BackColor_Classic")
+ {
+ SongSelect_BackColor_Classic = ColorTranslator.FromHtml(strParam);
+ }
+ else if (strCommand == "SongSelect_BackColor_GameMusic")
+ {
+ SongSelect_BackColor_GameMusic = ColorTranslator.FromHtml(strParam);
+ }
+ else if (strCommand == nameof(SongSelect_BackColor_Namco))
+ {
+ SongSelect_BackColor_Namco = ColorTranslator.FromHtml(strParam);
+ }
+ else if (strCommand == nameof(SongSelect_CorrectionX_Chara))
+ {
+ SongSelect_CorrectionX_Chara = strParam.Split(',').ToArray();
+ }
+ else if (strCommand == nameof(SongSelect_CorrectionY_Chara))
+ {
+ SongSelect_CorrectionY_Chara = strParam.Split(',').ToArray();
+ }
+ else if (strCommand == nameof(SongSelect_CorrectionX_Chara_Value))
+ {
+ SongSelect_CorrectionX_Chara_Value = int.Parse(strParam);
+ }
+ else if (strCommand == nameof(SongSelect_CorrectionY_Chara_Value))
+ {
+ SongSelect_CorrectionY_Chara_Value = int.Parse(strParam);
+ }
+ else if (strCommand == nameof(SongSelect_Rotate_Chara))
+ {
+ SongSelect_Rotate_Chara = strParam.Split(',').ToArray();
+ }
+ #endregion
+ #region SongLoading
+ else if (strCommand == nameof(SongLoading_Plate_X))
+ {
+ SongLoading_Plate_X = int.Parse(strParam);
+ }
+ else if (strCommand == nameof(SongLoading_Plate_Y))
+ {
+ SongLoading_Plate_Y = int.Parse(strParam);
+ }
+ else if (strCommand == nameof(SongLoading_Title_X))
+ {
+ SongLoading_Title_X = int.Parse(strParam);
+ }
+ else if (strCommand == nameof(SongLoading_Title_Y))
+ {
+ SongLoading_Title_Y = int.Parse(strParam);
+ }
+ else if (strCommand == nameof(SongLoading_SubTitle_X))
+ {
+ SongLoading_SubTitle_X = int.Parse(strParam);
+ }
+ else if (strCommand == nameof(SongLoading_SubTitle_Y))
+ {
+ SongLoading_SubTitle_Y = int.Parse(strParam);
+ }
+ else if (strCommand == nameof(SongLoading_Title_FontSize))
+ {
+ if (int.Parse(strParam) > 0)
+ SongLoading_Title_FontSize = int.Parse(strParam);
+ }
+ else if (strCommand == nameof(SongLoading_SubTitle_FontSize))
+ {
+ if (int.Parse(strParam) > 0)
+ SongLoading_SubTitle_FontSize = int.Parse(strParam);
+ }
+ else if (strCommand == nameof(SongLoading_Plate_ReferencePoint))
+ {
+ SongLoading_Plate_ReferencePoint = (ReferencePoint)int.Parse(strParam);
+ }
+ else if (strCommand == nameof(SongLoading_Title_ReferencePoint))
+ {
+ SongLoading_Title_ReferencePoint = (ReferencePoint)int.Parse(strParam);
+ }
+ else if (strCommand == nameof(SongLoading_SubTitle_ReferencePoint))
+ {
+ SongLoading_SubTitle_ReferencePoint = (ReferencePoint)int.Parse(strParam);
+ }
+
+ else if (strCommand == nameof(SongLoading_Title_ForeColor))
+ {
+ SongLoading_Title_ForeColor = ColorTranslator.FromHtml(strParam);
+ }
+ else if (strCommand == nameof(SongLoading_Title_BackColor))
+ {
+ SongLoading_Title_BackColor = ColorTranslator.FromHtml(strParam);
+ }
+ else if (strCommand == nameof(SongLoading_SubTitle_ForeColor))
+ {
+ SongLoading_SubTitle_ForeColor = ColorTranslator.FromHtml(strParam);
+ }
+ else if (strCommand == nameof(SongLoading_SubTitle_BackColor))
+ {
+ SongLoading_SubTitle_BackColor = ColorTranslator.FromHtml(strParam);
+ }
+ else if (strCommand == nameof(SongLoading_Plate_ScreenBlend))
+ {
+ SongLoading_Plate_ScreenBlend = C螟画鋤.bONorOFF(strParam[0]);
+ }
+ #endregion
+ #region Game
+ else if (strCommand == "Game_Notes_Anime")
+ {
+ Game_Notes_Anime = C螟画鋤.bONorOFF(strParam[0]);
+ }
+ else if (strCommand == "Game_StageText")
+ {
+ Game_StageText = strParam;
+ }
+ else if (strCommand == nameof(Game_RollColorMode))
+ {
+ Game_RollColorMode = (RollColorMode)int.Parse(strParam);
+ }
+ else if (strCommand == nameof(Game_JudgeFrame_AddBlend))
+ {
+ Game_JudgeFrame_AddBlend = C螟画鋤.bONorOFF(strParam[0]);
+ }
+
+ #region CourseSymbol
+ else if (strCommand == "Game_CourseSymbol_X")
+ {
+ string[] strSplit = strParam.Split(',');
+ for (int i = 0; i < 2; i++)
+ {
+ Game_CourseSymbol_X[i] = int.Parse(strSplit[i]);
+ }
+ }
+ else if (strCommand == "Game_CourseSymbol_Y")
+ {
+ string[] strSplit = strParam.Split(',');
+ for (int i = 0; i < 2; i++)
+ {
+ Game_CourseSymbol_Y[i] = int.Parse(strSplit[i]);
+ }
+ }
+ #endregion
+ #region PanelFont
+ else if (strCommand == nameof(Game_MusicName_X))
+ {
+ Game_MusicName_X = int.Parse(strParam);
+ }
+ else if (strCommand == nameof(Game_MusicName_Y))
+ {
+ Game_MusicName_Y = int.Parse(strParam);
+ }
+ else if (strCommand == nameof(Game_MusicName_FontSize))
+ {
+ if (int.Parse(strParam) > 0)
+ Game_MusicName_FontSize = int.Parse(strParam);
+ }
+ else if (strCommand == nameof(Game_MusicName_ReferencePoint))
+ {
+ Game_MusicName_ReferencePoint = (ReferencePoint)int.Parse(strParam);
+ }
+ else if (strCommand == nameof(Game_Genre_X))
+ {
+ Game_Genre_X = int.Parse(strParam);
+ }
+ else if (strCommand == nameof(Game_Genre_Y))
+ {
+ Game_Genre_Y = int.Parse(strParam);
+ }
+ else if (strCommand == nameof(Game_Lyric_X))
+ {
+ Game_Lyric_X = int.Parse(strParam);
+ }
+ else if (strCommand == nameof(Game_Lyric_Y))
+ {
+ Game_Lyric_Y = int.Parse(strParam);
+ }
+ else if (strCommand == nameof(Game_Lyric_FontName))
+ {
+ Game_Lyric_FontName = strParam;
+ }
+ else if (strCommand == nameof(Game_Lyric_FontSize))
+ {
+ if (int.Parse(strParam) > 0)
+ Game_Lyric_FontSize = int.Parse(strParam);
+ }
+ else if (strCommand == nameof(Game_Lyric_ReferencePoint))
+ {
+ Game_Lyric_ReferencePoint = (ReferencePoint)int.Parse(strParam);
+ }
+
+ else if (strCommand == nameof(Game_MusicName_ForeColor))
+ {
+ Game_MusicName_ForeColor = ColorTranslator.FromHtml(strParam);
+ }
+ else if (strCommand == nameof(Game_StageText_ForeColor))
+ {
+ Game_StageText_ForeColor = ColorTranslator.FromHtml(strParam);
+ }
+ else if (strCommand == nameof(Game_Lyric_ForeColor))
+ {
+ Game_Lyric_ForeColor = ColorTranslator.FromHtml(strParam);
+ }
+ else if (strCommand == nameof(Game_MusicName_BackColor))
+ {
+ Game_MusicName_BackColor = ColorTranslator.FromHtml(strParam);
+ }
+ else if (strCommand == nameof(Game_StageText_BackColor))
+ {
+ Game_StageText_BackColor = ColorTranslator.FromHtml(strParam);
+ }
+ else if (strCommand == nameof(Game_Lyric_BackColor))
+ {
+ Game_Lyric_BackColor = ColorTranslator.FromHtml(strParam);
+ }
+ #endregion
+ #region Chara
+ else if (strCommand == "Game_Chara_X")
+ {
+ string[] strSplit = strParam.Split(',');
+ for (int i = 0; i < 2; i++)
+ {
+ Game_Chara_X[i] = int.Parse(strSplit[i]);
+ }
+ }
+ else if (strCommand == "Game_Chara_Y")
+ {
+ string[] strSplit = strParam.Split(',');
+ for (int i = 0; i < 2; i++)
+ {
+ Game_Chara_Y[i] = int.Parse(strSplit[i]);
+ }
+ }
+ else if (strCommand == "Game_Chara_Balloon_X")
+ {
+ string[] strSplit = strParam.Split(',');
+ for (int i = 0; i < 2; i++)
+ {
+ Game_Chara_Balloon_X[i] = int.Parse(strSplit[i]);
+ }
+ }
+ else if (strCommand == "Game_Chara_Balloon_Y")
+ {
+ string[] strSplit = strParam.Split(',');
+ for (int i = 0; i < 2; i++)
+ {
+ Game_Chara_Balloon_Y[i] = int.Parse(strSplit[i]);
+ }
+ }
+ else if (strCommand == nameof(Game_Chara_Balloon_Timer))
+ {
+ if (int.Parse(strParam) > 0)
+ Game_Chara_Balloon_Timer = int.Parse(strParam);
+ }
+ else if (strCommand == nameof(Game_Chara_Balloon_Delay))
+ {
+ if (int.Parse(strParam) > 0)
+ Game_Chara_Balloon_Delay = int.Parse(strParam);
+ }
+ else if (strCommand == nameof(Game_Chara_Balloon_FadeOut))
+ {
+ if (int.Parse(strParam) > 0)
+ Game_Chara_Balloon_FadeOut = int.Parse(strParam);
+ }
+ // 繝代ち繝ｼ繝ｳ謨ｰ縺ｮ險ｭ螳壹ｯTextureLoader.cs縺ｧ蜿肴丐縺輔ｌ縺ｾ縺吶
+ else if (strCommand == "Game_Chara_Motion_Normal")
+ {
+ Game_Chara_Motion_Normal = strParam;
+ }
+ else if (strCommand == "Game_Chara_Motion_Clear")
+ {
+ Game_Chara_Motion_Clear = strParam;
+ }
+ else if (strCommand == "Game_Chara_Motion_GoGo")
+ {
+ Game_Chara_Motion_GoGo = strParam;
+ }
+ else if (strCommand == "Game_Chara_Beat_Normal")
+ {
+ ParseInt32(value => Game_Chara_Beat_Normal = value);
+ }
+ else if (strCommand == "Game_Chara_Beat_Clear")
+ {
+ ParseInt32(value => Game_Chara_Beat_Clear = value);
+ }
+ else if (strCommand == "Game_Chara_Beat_GoGo")
+ {
+ ParseInt32(value => Game_Chara_Beat_GoGo = value);
+ }
+ #endregion
+ #region Dancer
+ else if (strCommand == "Game_Dancer_X")
+ {
+ string[] strSplit = strParam.Split(',');
+ for (int i = 0; i < 5; i++)
+ {
+ Game_Dancer_X[i] = int.Parse(strSplit[i]);
+ }
+ }
+ else if (strCommand == "Game_Dancer_Y")
+ {
+ string[] strSplit = strParam.Split(',');
+ for (int i = 0; i < 5; i++)
+ {
+ Game_Dancer_Y[i] = int.Parse(strSplit[i]);
+ }
+ }
+ else if (strCommand == "Game_Dancer_Motion")
+ {
+ Game_Dancer_Motion = strParam;
+ }
+ // Game_Dancer_Ptn縺ｯTextrueLoader.cs縺ｧ蜿肴丐縺輔ｌ縺ｾ縺吶
+ else if (strCommand == "Game_Dancer_Beat")
+ {
+ ParseInt32(value => Game_Dancer_Beat = value);
+ }
+ else if (strCommand == "Game_Dancer_Gauge")
+ {
+ string[] strSplit = strParam.Split(',');
+ for (int i = 0; i < 5; i++)
+ {
+ Game_Dancer_Gauge[i] = int.Parse(strSplit[i]);
+ }
+ }
+ #endregion
+ #region Mob
+ else if (strCommand == "Game_Mob_Beat")
+ {
+ ParseInt32(value => Game_Mob_Beat = value);
+ }
+ else if (strCommand == "Game_Mob_Ptn_Beat")
+ {
+ ParseInt32(value => Game_Mob_Ptn_Beat = value);
+ }
+ #endregion
+ #region Score
+ else if (strCommand == "Game_Score_X")
+ {
+ string[] strSplit = strParam.Split(',');
+ for (int i = 0; i < 2; i++)
+ {
+ this.Game_Score_X[i] = int.Parse(strSplit[i]);
+ }
+ }
+ else if (strCommand == "Game_Score_Y")
+ {
+ string[] strSplit = strParam.Split(',');
+ for (int i = 0; i < 2; i++)
+ {
+ this.Game_Score_Y[i] = int.Parse(strSplit[i]);
+ }
+ }
+ else if (strCommand == "Game_Score_Add_X")
+ {
+ string[] strSplit = strParam.Split(',');
+ for (int i = 0; i < 2; i++)
+ {
+ this.Game_Score_Add_X[i] = int.Parse(strSplit[i]);
+ }
+ }
+ else if (strCommand == "Game_Score_Add_Y")
+ {
+ string[] strSplit = strParam.Split(',');
+ for (int i = 0; i < 2; i++)
+ {
+ this.Game_Score_Add_Y[i] = int.Parse(strSplit[i]);
+ }
+ }
+ else if (strCommand == "Game_Score_AddBonus_X")
+ {
+ string[] strSplit = strParam.Split(',');
+ for (int i = 0; i < 2; i++)
+ {
+ this.Game_Score_AddBonus_X[i] = int.Parse(strSplit[i]);
+ }
+ }
+ else if (strCommand == "Game_Score_AddBonus_Y")
+ {
+ string[] strSplit = strParam.Split(',');
+ for (int i = 0; i < 2; i++)
+ {
+ this.Game_Score_AddBonus_Y[i] = int.Parse(strSplit[i]);
+ }
+ }
+
+ else if (strCommand == "Game_Score_Padding")
+ {
+ ParseInt32(value => Game_Score_Padding = value);
+ }
+ else if (strCommand == "Game_Score_Size")
+ {
+ string[] strSplit = strParam.Split(',');
+ for (int i = 0; i < 2; i++)
+ {
+ Game_Score_Size[i] = int.Parse(strSplit[i]);
+ }
+ }
+ #endregion
+ #region Taiko
+ else if (strCommand == "Game_Taiko_NamePlate_X")
+ {
+ string[] strSplit = strParam.Split(',');
+ for (int i = 0; i < 2; i++)
+ {
+ Game_Taiko_NamePlate_X[i] = int.Parse(strSplit[i]);
+ }
+ }
+ else if (strCommand == "Game_Taiko_NamePlate_Y")
+ {
+ string[] strSplit = strParam.Split(',');
+ for (int i = 0; i < 2; i++)
+ {
+ Game_Taiko_NamePlate_Y[i] = int.Parse(strSplit[i]);
+ }
+ }
+
+ else if (strCommand == "Game_Taiko_PlayerNumber_X")
+ {
+ string[] strSplit = strParam.Split(',');
+ for (int i = 0; i < 2; i++)
+ {
+ Game_Taiko_PlayerNumber_X[i] = int.Parse(strSplit[i]);
+ }
+ }
+
+ else if (strCommand == "Game_Taiko_PlayerNumber_Y")
+ {
+ string[] strSplit = strParam.Split(',');
+ for (int i = 0; i < 2; i++)
+ {
+ Game_Taiko_PlayerNumber_Y[i] = int.Parse(strSplit[i]);
+ }
+ }
+
+ else if (strCommand == "Game_Taiko_X")
+ {
+ string[] strSplit = strParam.Split(',');
+ for (int i = 0; i < 2; i++)
+ {
+ Game_Taiko_X[i] = int.Parse(strSplit[i]);
+ }
+ }
+ else if (strCommand == "Game_Taiko_Y")
+ {
+ string[] strSplit = strParam.Split(',');
+ for (int i = 0; i < 2; i++)
+ {
+ Game_Taiko_Y[i] = int.Parse(strSplit[i]);
+ }
+ }
+ else if (strCommand == "Game_Taiko_Combo_X")
+ {
+ string[] strSplit = strParam.Split(',');
+ for (int i = 0; i < 2; i++)
+ {
+ Game_Taiko_Combo_X[i] = int.Parse(strSplit[i]);
+ }
+ }
+ else if (strCommand == "Game_Taiko_Combo_Y")
+ {
+ string[] strSplit = strParam.Split(',');
+ for (int i = 0; i < 2; i++)
+ {
+ Game_Taiko_Combo_Y[i] = int.Parse(strSplit[i]);
+ }
+ }
+ else if (strCommand == "Game_Taiko_Combo_Ex_X")
+ {
+ string[] strSplit = strParam.Split(',');
+ for (int i = 0; i < 2; i++)
+ {
+ Game_Taiko_Combo_Ex_X[i] = int.Parse(strSplit[i]);
+ }
+ }
+ else if (strCommand == "Game_Taiko_Combo_Ex_Y")
+ {
+ string[] strSplit = strParam.Split(',');
+ for (int i = 0; i < 2; i++)
+ {
+ Game_Taiko_Combo_Ex_Y[i] = int.Parse(strSplit[i]);
+ }
+ }
+ else if (strCommand == "Game_Taiko_Combo_Ex4_X")
+ {
+ string[] strSplit = strParam.Split(',');
+ for (int i = 0; i < 2; i++)
+ {
+ Game_Taiko_Combo_Ex4_X[i] = int.Parse(strSplit[i]);
+ }
+ }
+ else if (strCommand == "Game_Taiko_Combo_Ex4_Y")
+ {
+ string[] strSplit = strParam.Split(',');
+ for (int i = 0; i < 2; i++)
+ {
+ Game_Taiko_Combo_Ex4_Y[i] = int.Parse(strSplit[i]);
+ }
+ }
+ else if (strCommand == "Game_Taiko_Combo_Padding")
+ {
+ string[] strSplit = strParam.Split(',');
+ for (int i = 0; i < 3; i++)
+ {
+ Game_Taiko_Combo_Padding[i] = int.Parse(strSplit[i]);
+ }
+ }
+ else if (strCommand == "Game_Taiko_Combo_Size")
+ {
+ string[] strSplit = strParam.Split(',');
+ for (int i = 0; i < 2; i++)
+ {
+ Game_Taiko_Combo_Size[i] = int.Parse(strSplit[i]);
+ }
+ }
+ else if (strCommand == "Game_Taiko_Combo_Size_Ex")
+ {
+ string[] strSplit = strParam.Split(',');
+ for (int i = 0; i < 2; i++)
+ {
+ Game_Taiko_Combo_Size_Ex[i] = int.Parse(strSplit[i]);
+ }
+ }
+ else if (strCommand == "Game_Taiko_Combo_Scale")
+ {
+ string[] strSplit = strParam.Split(',');
+ for (int i = 0; i < 3; i++)
+ {
+ Game_Taiko_Combo_Scale[i] = float.Parse(strSplit[i]);
+ }
+ }
+ else if (strCommand == "Game_Taiko_Combo_Text_X")
+ {
+ string[] strSplit = strParam.Split(',');
+ for (int i = 0; i < 2; i++)
+ {
+ Game_Taiko_Combo_Text_X[i] = int.Parse(strSplit[i]);
+ }
+ }
+ else if (strCommand == "Game_Taiko_Combo_Text_Y")
+ {
+ string[] strSplit = strParam.Split(',');
+ for (int i = 0; i < 2; i++)
+ {
+ Game_Taiko_Combo_Text_Y[i] = int.Parse(strSplit[i]);
+ }
+ }
+ else if (strCommand == "Game_Taiko_Combo_Text_Size")
+ {
+ string[] strSplit = strParam.Split(',');
+ for (int i = 0; i < 2; i++)
+ {
+ Game_Taiko_Combo_Text_Size[i] = int.Parse(strSplit[i]);
+ }
+ }
+ else if (strCommand == nameof(Game_Taiko_Combo_Ex_IsJumping))
+ {
+ Game_Taiko_Combo_Ex_IsJumping = C螟画鋤.bONorOFF(strParam[0]);
+ }
+ #endregion
+ #region Gauge
+ else if (strCommand == "Game_Gauge_Rainbow_Timer")
+ {
+ if (int.Parse(strParam) != 0)
+ {
+ Game_Gauge_Rainbow_Timer = int.Parse(strParam);
+ }
+ }
+ #endregion
+ #region Balloon
+ else if (strCommand == "Game_Balloon_Combo_X")
+ {
+ string[] strSplit = strParam.Split(',');
+ for (int i = 0; i < 2; i++)
+ {
+ Game_Balloon_Combo_X[i] = int.Parse(strSplit[i]);
+ }
+ }
+ else if (strCommand == "Game_Balloon_Combo_Y")
+ {
+ string[] strSplit = strParam.Split(',');
+ for (int i = 0; i < 2; i++)
+ {
+ Game_Balloon_Combo_Y[i] = int.Parse(strSplit[i]);
+ }
+ }
+ else if (strCommand == "Game_Balloon_Combo_Number_X")
+ {
+ string[] strSplit = strParam.Split(',');
+ for (int i = 0; i < 2; i++)
+ {
+ Game_Balloon_Combo_Number_X[i] = int.Parse(strSplit[i]);
+ }
+ }
+ else if (strCommand == "Game_Balloon_Combo_Number_Y")
+ {
+ string[] strSplit = strParam.Split(',');
+ for (int i = 0; i < 2; i++)
+ {
+ Game_Balloon_Combo_Number_Y[i] = int.Parse(strSplit[i]);
+ }
+ }
+ else if (strCommand == "Game_Balloon_Combo_Number_Ex_X")
+ {
+ string[] strSplit = strParam.Split(',');
+ for (int i = 0; i < 2; i++)
+ {
+ Game_Balloon_Combo_Number_Ex_X[i] = int.Parse(strSplit[i]);
+ }
+ }
+ else if (strCommand == "Game_Balloon_Combo_Number_Ex_Y")
+ {
+ string[] strSplit = strParam.Split(',');
+ for (int i = 0; i < 2; i++)
+ {
+ Game_Balloon_Combo_Number_Ex_Y[i] = int.Parse(strSplit[i]);
+ }
+ }
+ else if (strCommand == "Game_Balloon_Combo_Text_X")
+ {
+ string[] strSplit = strParam.Split(',');
+ for (int i = 0; i < 2; i++)
+ {
+ Game_Balloon_Combo_Text_X[i] = int.Parse(strSplit[i]);
+ }
+ }
+ else if (strCommand == "Game_Balloon_Combo_Text_Y")
+ {
+ string[] strSplit = strParam.Split(',');
+ for (int i = 0; i < 2; i++)
+ {
+ Game_Balloon_Combo_Text_Y[i] = int.Parse(strSplit[i]);
+ }
+ }
+ else if (strCommand == "Game_Balloon_Combo_Text_Ex_X")
+ {
+ string[] strSplit = strParam.Split(',');
+ for (int i = 0; i < 2; i++)
+ {
+ Game_Balloon_Combo_Text_Ex_X[i] = int.Parse(strSplit[i]);
+ }
+ }
+ else if (strCommand == "Game_Balloon_Combo_Text_Ex_Y")
+ {
+ string[] strSplit = strParam.Split(',');
+ for (int i = 0; i < 2; i++)
+ {
+ Game_Balloon_Combo_Text_Ex_Y[i] = int.Parse(strSplit[i]);
+ }
+ }
+
+
+ else if (strCommand == "Game_Balloon_Balloon_X")
+ {
+ string[] strSplit = strParam.Split(',');
+ for (int i = 0; i < 2; i++)
+ {
+ this.Game_Balloon_Balloon_X[i] = int.Parse(strSplit[i]);
+ }
+ }
+ else if (strCommand == "Game_Balloon_Balloon_Y")
+ {
+ string[] strSplit = strParam.Split(',');
+ for (int i = 0; i < 2; i++)
+ {
+ this.Game_Balloon_Balloon_Y[i] = int.Parse(strSplit[i]);
+ }
+ }
+ else if (strCommand == "Game_Balloon_Balloon_Frame_X")
+ {
+ string[] strSplit = strParam.Split(',');
+ for (int i = 0; i < 2; i++)
+ {
+ this.Game_Balloon_Balloon_Frame_X[i] = int.Parse(strSplit[i]);
+ }
+ }
+ else if (strCommand == "Game_Balloon_Balloon_Frame_Y")
+ {
+ string[] strSplit = strParam.Split(',');
+ for (int i = 0; i < 2; i++)
+ {
+ this.Game_Balloon_Balloon_Frame_Y[i] = int.Parse(strSplit[i]);
+ }
+ }
+ else if (strCommand == "Game_Balloon_Balloon_Number_X")
+ {
+ string[] strSplit = strParam.Split(',');
+ for (int i = 0; i < 2; i++)
+ {
+ this.Game_Balloon_Balloon_Number_X[i] = int.Parse(strSplit[i]);
+ }
+ }
+ else if (strCommand == "Game_Balloon_Balloon_Number_Y")
+ {
+ string[] strSplit = strParam.Split(',');
+ for (int i = 0; i < 2; i++)
+ {
+ this.Game_Balloon_Balloon_Number_Y[i] = int.Parse(strSplit[i]);
+ }
+ }
+
+ else if (strCommand == "Game_Balloon_Roll_Frame_X")
+ {
+ string[] strSplit = strParam.Split(',');
+ for (int i = 0; i < 2; i++)
+ {
+ Game_Balloon_Roll_Frame_X[i] = int.Parse(strSplit[i]);
+ }
+ }
+ else if (strCommand == "Game_Balloon_Roll_Frame_Y")
+ {
+ string[] strSplit = strParam.Split(',');
+ for (int i = 0; i < 2; i++)
+ {
+ Game_Balloon_Roll_Frame_Y[i] = int.Parse(strSplit[i]);
+ }
+ }
+ else if (strCommand == "Game_Balloon_Roll_Number_X")
+ {
+ string[] strSplit = strParam.Split(',');
+ for (int i = 0; i < 2; i++)
+ {
+ Game_Balloon_Roll_Number_X[i] = int.Parse(strSplit[i]);
+ }
+ }
+ else if (strCommand == "Game_Balloon_Roll_Number_Y")
+ {
+ string[] strSplit = strParam.Split(',');
+ for (int i = 0; i < 2; i++)
+ {
+ Game_Balloon_Roll_Number_Y[i] = int.Parse(strSplit[i]);
+ }
+ }
+ else if (strCommand == "Game_Balloon_Number_Size")
+ {
+ string[] strSplit = strParam.Split(',');
+ for (int i = 0; i < 2; i++)
+ {
+ Game_Balloon_Number_Size[i] = int.Parse(strSplit[i]);
+ }
+ }
+ else if (strCommand == "Game_Balloon_Number_Padding")
+ {
+ ParseInt32(value => Game_Balloon_Number_Padding = value);
+ }
+ else if (strCommand == "Game_Balloon_Roll_Number_Scale")
+ {
+ ParseInt32(value => Game_Balloon_Roll_Number_Scale = value);
+ }
+ else if (strCommand == "Game_Balloon_Balloon_Number_Scale")
+ {
+ ParseInt32(value => Game_Balloon_Balloon_Number_Scale = value);
+ }
+
+ #endregion
+ #region Effects
+ else if (strCommand == nameof(Game_Effect_Roll_StartPoint_X))
+ {
+ Game_Effect_Roll_StartPoint_X = strParam.Split(',').Select(int.Parse).ToArray();
+ }
+ else if (strCommand == nameof(Game_Effect_Roll_StartPoint_Y))
+ {
+ Game_Effect_Roll_StartPoint_Y = strParam.Split(',').Select(int.Parse).ToArray();
+ }
+ else if (strCommand == nameof(Game_Effect_Roll_StartPoint_1P_X))
+ {
+ Game_Effect_Roll_StartPoint_1P_X = strParam.Split(',').Select(int.Parse).ToArray();
+ }
+ else if (strCommand == nameof(Game_Effect_Roll_StartPoint_1P_Y))
+ {
+ Game_Effect_Roll_StartPoint_1P_Y = strParam.Split(',').Select(int.Parse).ToArray();
+ }
+ else if (strCommand == nameof(Game_Effect_Roll_StartPoint_2P_X))
+ {
+ Game_Effect_Roll_StartPoint_2P_X = strParam.Split(',').Select(int.Parse).ToArray();
+ }
+ else if (strCommand == nameof(Game_Effect_Roll_StartPoint_2P_Y))
+ {
+ Game_Effect_Roll_StartPoint_2P_Y = strParam.Split(',').Select(int.Parse).ToArray();
+ }
+ else if (strCommand == nameof(Game_Effect_Roll_Speed_X))
+ {
+ Game_Effect_Roll_Speed_X = strParam.Split(',').Select(float.Parse).ToArray();
+ }
+ else if (strCommand == nameof(Game_Effect_Roll_Speed_Y))
+ {
+ Game_Effect_Roll_Speed_Y = strParam.Split(',').Select(float.Parse).ToArray();
+ }
+ else if (strCommand == nameof(Game_Effect_Roll_Speed_1P_X))
+ {
+ Game_Effect_Roll_Speed_1P_X = strParam.Split(',').Select(float.Parse).ToArray();
+ }
+ else if (strCommand == nameof(Game_Effect_Roll_Speed_1P_Y))
+ {
+ Game_Effect_Roll_Speed_1P_Y = strParam.Split(',').Select(float.Parse).ToArray();
+ }
+ else if (strCommand == nameof(Game_Effect_Roll_Speed_2P_X))
+ {
+ Game_Effect_Roll_Speed_2P_X = strParam.Split(',').Select(float.Parse).ToArray();
+ }
+ else if (strCommand == nameof(Game_Effect_Roll_Speed_2P_Y))
+ {
+ Game_Effect_Roll_Speed_2P_Y = strParam.Split(',').Select(float.Parse).ToArray();
+ }
+ else if (strCommand == nameof(Game_Effect_NotesFlash))
+ {
+ Game_Effect_NotesFlash = strParam.Split(',').Select(int.Parse).ToArray();
+ }
+ else if (strCommand == nameof(Game_Effect_NotesFlash_Timer))
+ {
+ Game_Effect_NotesFlash_Timer = int.Parse(strParam);
+ }
+ else if (strCommand == nameof(Game_Effect_GoGoSplash))
+ {
+ Game_Effect_GoGoSplash = strParam.Split(',').Select(int.Parse).ToArray();
+ }
+ else if (strCommand == nameof(Game_Effect_GoGoSplash_X))
+ {
+ Game_Effect_GoGoSplash_X = strParam.Split(',').Select(int.Parse).ToArray();
+ }
+ else if (strCommand == nameof(Game_Effect_GoGoSplash_Y))
+ {
+ Game_Effect_GoGoSplash_Y = strParam.Split(',').Select(int.Parse).ToArray();
+ }
+ else if (strCommand == nameof(Game_Effect_GoGoSplash_Rotate))
+ {
+ Game_Effect_GoGoSplash_Rotate = C螟画鋤.bONorOFF(strParam[0]);
+ }
+ else if (strCommand == nameof(Game_Effect_GoGoSplash_Timer))
+ {
+ Game_Effect_GoGoSplash_Timer = int.Parse(strParam);
+ }
+ else if (strCommand == nameof(Game_Effect_FlyingNotes_StartPoint_X))
+ {
+ Game_Effect_FlyingNotes_StartPoint_X = strParam.Split(',').Select(int.Parse).ToArray();
+ }
+ else if (strCommand == nameof(Game_Effect_FlyingNotes_StartPoint_Y))
+ {
+ Game_Effect_FlyingNotes_StartPoint_Y = strParam.Split(',').Select(int.Parse).ToArray();
+ }
+ else if (strCommand == nameof(Game_Effect_FlyingNotes_EndPoint_X))
+ {
+ Game_Effect_FlyingNotes_EndPoint_X = strParam.Split(',').Select(int.Parse).ToArray();
+ }
+ else if (strCommand == nameof(Game_Effect_FlyingNotes_EndPoint_Y))
+ {
+ Game_Effect_FlyingNotes_EndPoint_Y = strParam.Split(',').Select(int.Parse).ToArray();
+ }
+ else if (strCommand == nameof(Game_Effect_FlyingNotes_Sine))
+ {
+ Game_Effect_FlyingNotes_Sine = int.Parse(strParam);
+ }
+ else if (strCommand == nameof(Game_Effect_FlyingNotes_IsUsingEasing))
+ {
+ Game_Effect_FlyingNotes_IsUsingEasing = C螟画鋤.bONorOFF(strParam[0]);
+ }
+ else if (strCommand == nameof(Game_Effect_FlyingNotes_Timer))
+ {
+ Game_Effect_FlyingNotes_Timer = int.Parse(strParam);
+ }
+ else if (strCommand == nameof(Game_Effect_FireWorks))
+ {
+ Game_Effect_FireWorks = strParam.Split(',').Select(int.Parse).ToArray();
+ }
+ else if (strCommand == nameof(Game_Effect_FireWorks_Timer))
+ {
+ Game_Effect_FireWorks_Timer = int.Parse(strParam);
+ }
+ else if (strCommand == nameof(Game_Effect_Rainbow_Timer))
+ {
+ Game_Effect_Rainbow_Timer = int.Parse(strParam);
+ }
+ else if (strCommand == nameof(Game_Effect_HitExplosion_AddBlend))
+ {
+ Game_Effect_HitExplosion_AddBlend = C螟画鋤.bONorOFF(strParam[0]);
+ }
+ else if (strCommand == nameof(Game_Effect_HitExplosionBig_AddBlend))
+ {
+ Game_Effect_HitExplosionBig_AddBlend = C螟画鋤.bONorOFF(strParam[0]);
+ }
+ else if (strCommand == nameof(Game_Effect_FireWorks_AddBlend))
+ {
+ Game_Effect_FireWorks_AddBlend = C螟画鋤.bONorOFF(strParam[0]);
+ }
+ else if (strCommand == nameof(Game_Effect_Fire_AddBlend))
+ {
+ Game_Effect_Fire_AddBlend = C螟画鋤.bONorOFF(strParam[0]);
+ }
+ else if (strCommand == nameof(Game_Effect_GoGoSplash_AddBlend))
+ {
+ Game_Effect_GoGoSplash_AddBlend = C螟画鋤.bONorOFF(strParam[0]);
+ }
+ else if (strCommand == nameof(Game_Effect_FireWorks_Timing))
+ {
+ Game_Effect_FireWorks_Timing = int.Parse(strParam);
+ }
+ #endregion
+ #region Runner
+ else if (strCommand == "Game_Runner_Size")
+ {
+ string[] strSplit = strParam.Split(',');
+ for (int i = 0; i < 2; i++)
+ {
+ Game_Runner_Size[i] = int.Parse(strSplit[i]);
+ }
+ }
+ else if (strCommand == "Game_Runner_Ptn")
+ {
+ ParseInt32(value => Game_Runner_Ptn = value);
+ }
+ else if (strCommand == "Game_Runner_Type")
+ {
+ ParseInt32(value => Game_Runner_Type = value);
+ }
+ else if (strCommand == "Game_Runner_StartPoint_X")
+ {
+ string[] strSplit = strParam.Split(',');
+ for (int i = 0; i < 2; i++)
+ {
+ Game_Runner_StartPoint_X[i] = int.Parse(strSplit[i]);
+ }
+ }
+ else if (strCommand == "Game_Runner_StartPoint_Y")
+ {
+ string[] strSplit = strParam.Split(',');
+ for (int i = 0; i < 2; i++)
+ {
+ Game_Runner_StartPoint_Y[i] = int.Parse(strSplit[i]);
+ }
+ }
+ else if (strCommand == "Game_Runner_Timer")
+ {
+ if (int.Parse(strParam) != 0)
+ {
+ Game_Runner_Timer = int.Parse(strParam);
+ }
+ }
+ #endregion
+ #region Dan_C
+ else if (strCommand == nameof(Game_DanC_Title_ForeColor))
+ {
+ Game_DanC_Title_ForeColor = ColorTranslator.FromHtml(strParam);
+ }
+ else if (strCommand == nameof(Game_DanC_Title_BackColor))
+ {
+ Game_DanC_Title_BackColor = ColorTranslator.FromHtml(strParam);
+ }
+ else if (strCommand == nameof(Game_DanC_SubTitle_ForeColor))
+ {
+ Game_DanC_SubTitle_ForeColor = ColorTranslator.FromHtml(strParam);
+ }
+ else if (strCommand == nameof(Game_DanC_SubTitle_BackColor))
+ {
+ Game_DanC_SubTitle_BackColor = ColorTranslator.FromHtml(strParam);
+ }
+ else if (strCommand == nameof(Game_DanC_X))
+ {
+ Game_DanC_X = strParam.Split(',').Select(int.Parse).ToArray();
+ }
+ else if (strCommand == nameof(Game_DanC_Y))
+ {
+ Game_DanC_Y = strParam.Split(',').Select(int.Parse).ToArray();
+ }
+
+ else if (strCommand == nameof(Game_DanC_Size))
+ {
+ Game_DanC_Size = strParam.Split(',').Select(int.Parse).ToArray();
+ }
+
+ else if (strCommand == nameof(Game_DanC_Padding))
+ {
+ ParseInt32(value => Game_DanC_Padding = value);
+ }
+
+ else if (strCommand == nameof(Game_DanC_Offset))
+ {
+ Game_DanC_Offset = strParam.Split(',').Select(int.Parse).ToArray();
+ }
+
+ else if (strCommand == nameof(Game_DanC_Number_Size))
+ {
+ Game_DanC_Number_Size = strParam.Split(',').Select(int.Parse).ToArray();
+ }
+
+ else if (strCommand == nameof(Game_DanC_Number_Padding))
+ {
+ ParseInt32(value => Game_DanC_Number_Padding = value);
+ }
+
+ else if (strCommand == nameof(Game_DanC_Number_Small_Scale))
+ {
+ Game_DanC_Number_Small_Scale = float.Parse(strParam);
+ }
+
+ else if (strCommand == nameof(Game_DanC_Number_Small_Padding))
+ {
+ ParseInt32(value => Game_DanC_Number_Small_Padding = value);
+ }
+
+ else if (strCommand == nameof(Game_DanC_Number_XY))
+ {
+ Game_DanC_Number_XY = strParam.Split(',').Select(int.Parse).ToArray();
+ }
+ else if (strCommand == nameof(Game_DanC_Number_Small_Number_Offset))
+ {
+ Game_DanC_Number_Small_Number_Offset = strParam.Split(',').Select(int.Parse).ToArray();
+ }
+ else if (strCommand == nameof(Game_DanC_ExamType_Size))
+ {
+ Game_DanC_ExamType_Size = strParam.Split(',').Select(int.Parse).ToArray();
+ }
+ else if (strCommand == nameof(Game_DanC_ExamRange_Size))
+ {
+ Game_DanC_ExamRange_Size = strParam.Split(',').Select(int.Parse).ToArray();
+ }
+
+ else if (strCommand == nameof(Game_DanC_ExamRange_Padding))
+ {
+ ParseInt32(value => Game_DanC_ExamRange_Padding = value);
+ }
+
+ else if (strCommand == nameof(Game_DanC_Percent_Hit_Score_Padding))
+ {
+ Game_DanC_Percent_Hit_Score_Padding = strParam.Split(',').Select(int.Parse).ToArray();
+ }
+ else if (strCommand == nameof(Game_DanC_ExamUnit_Size))
+ {
+ Game_DanC_ExamUnit_Size = strParam.Split(',').Select(int.Parse).ToArray();
+ }
+ else if (strCommand == nameof(Game_DanC_Exam_Offset))
+ {
+ Game_DanC_Exam_Offset = strParam.Split(',').Select(int.Parse).ToArray();
+ }
+ else if (strCommand == nameof(Game_DanC_Dan_Plate))
+ {
+ Game_DanC_Dan_Plate = strParam.Split(',').Select(int.Parse).ToArray();
+ }
+
+ #endregion
+ #region PuchiChara
+ else if (strCommand == nameof(Game_PuchiChara_X))
+ {
+ Game_PuchiChara_X = strParam.Split(',').Select(int.Parse).ToArray();
+ }
+ else if (strCommand == nameof(Game_PuchiChara_Y))
+ {
+ Game_PuchiChara_Y = strParam.Split(',').Select(int.Parse).ToArray();
+ }
+ else if (strCommand == nameof(Game_PuchiChara_BalloonX))
+ {
+ Game_PuchiChara_BalloonX = strParam.Split(',').Select(int.Parse).ToArray();
+ }
+ else if (strCommand == nameof(Game_PuchiChara_BalloonY))
+ {
+ Game_PuchiChara_BalloonY = strParam.Split(',').Select(int.Parse).ToArray();
+ }
+ else if (strCommand == nameof(Game_PuchiChara_Scale))
+ {
+ Game_PuchiChara_Scale = strParam.Split(',').Select(float.Parse).ToArray();
+ }
+ else if (strCommand == nameof(Game_PuchiChara))
+ {
+ Game_PuchiChara = strParam.Split(',').Select(int.Parse).ToArray();
+ }
+ else if (strCommand == nameof(Game_PuchiChara_Sine))
+ {
+ ParseInt32(value => Game_PuchiChara_Sine = value);
+ }
+ else if (strCommand == nameof(Game_PuchiChara_Timer))
+ {
+ ParseInt32(value => Game_PuchiChara_Timer = value);
+ }
+ else if (strCommand == nameof(Game_PuchiChara_SineTimer))
+ {
+ Game_PuchiChara_SineTimer = double.Parse(strParam);
+ }
+ #endregion
+ #region Training
+ else if (strCommand == nameof(Game_Training_ScrollTime))
+ {
+ Game_Training_ScrollTime = int.Parse(strParam);
+ }
+ else if (strCommand == nameof(Game_Training_ProgressBar_XY))
+ {
+ Game_Training_ProgressBar_XY = strParam.Split(',').Select(int.Parse).ToArray();
+ }
+ else if (strCommand == nameof(Game_Training_GoGoPoint_Y))
+ {
+ Game_Training_GoGoPoint_Y = int.Parse(strParam);
+ }
+ else if (strCommand == nameof(Game_Training_JumpPoint_Y))
+ {
+ Game_Training_JumpPoint_Y = int.Parse(strParam);
+ }
+ else if (strCommand == nameof(Game_Training_MaxMeasureCount_XY))
+ {
+ Game_Training_MaxMeasureCount_XY = strParam.Split(',').Select(int.Parse).ToArray();
+ }
+ else if (strCommand == nameof(Game_Training_CurrentMeasureCount_XY))
+ {
+ Game_Training_CurrentMeasureCount_XY = strParam.Split(',').Select(int.Parse).ToArray();
+ }
+ else if (strCommand == nameof(Game_Training_SpeedDisplay_XY))
+ {
+ Game_Training_CurrentMeasureCount_XY = strParam.Split(',').Select(int.Parse).ToArray();
+ }
+ else if (strCommand == nameof(Game_Training_SmallNumber_Width))
+ {
+ Game_Training_SmallNumber_Width = int.Parse(strParam);
+ }
+ else if (strCommand == nameof(Game_Training_BigNumber_Width))
+ {
+ Game_Training_BigNumber_Width = int.Parse(strParam);
+ }
+ #endregion
+
+ #endregion
+ #region Result
+ else if (strCommand == nameof(Result_MusicName_X))
+ {
+ Result_MusicName_X = int.Parse(strParam);
+ }
+ else if (strCommand == nameof(Result_MusicName_Y))
+ {
+ Result_MusicName_Y = int.Parse(strParam);
+ }
+ else if (strCommand == nameof(Result_MusicName_FontSize))
+ {
+ if (int.Parse(strParam) > 0)
+ Result_MusicName_FontSize = int.Parse(strParam);
+ }
+ else if (strCommand == nameof(Result_MusicName_ReferencePoint))
+ {
+ Result_MusicName_ReferencePoint = (ReferencePoint)int.Parse(strParam);
+ }
+ else if (strCommand == nameof(Result_StageText_X))
+ {
+ Result_StageText_X = int.Parse(strParam);
+ }
+ else if (strCommand == nameof(Result_StageText_Y))
+ {
+ Result_StageText_Y = int.Parse(strParam);
+ }
+ else if (strCommand == nameof(Result_StageText_FontSize))
+ {
+ if (int.Parse(strParam) > 0)
+ Result_StageText_FontSize = int.Parse(strParam);
+ }
+ else if (strCommand == nameof(Result_StageText_ReferencePoint))
+ {
+ Result_StageText_ReferencePoint = (ReferencePoint)int.Parse(strParam);
+ }
+
+ else if (strCommand == nameof(Result_MusicName_ForeColor))
+ {
+ Result_MusicName_ForeColor = ColorTranslator.FromHtml(strParam);
+ }
+ else if (strCommand == nameof(Result_StageText_ForeColor))
+ {
+ Result_StageText_ForeColor = ColorTranslator.FromHtml(strParam);
+ }
+ //else if (strCommand == nameof(Result_StageText_ForeColor_Red))
+ //{
+ // Result_StageText_ForeColor_Red = ColorTranslator.FromHtml(strParam);
+ //}
+ else if (strCommand == nameof(Result_MusicName_BackColor))
+ {
+ Result_MusicName_BackColor = ColorTranslator.FromHtml(strParam);
+ }
+ else if (strCommand == nameof(Result_StageText_BackColor))
+ {
+ Result_StageText_BackColor = ColorTranslator.FromHtml(strParam);
+ }
+ //else if (strCommand == nameof(Result_StageText_BackColor_Red))
+ //{
+ // Result_StageText_BackColor_Red = ColorTranslator.FromHtml(strParam);
+ //}
+
+ else if (strCommand == "Result_NamePlate_X")
+ {
+ string[] strSplit = strParam.Split(',');
+ for (int i = 0; i < 2; i++)
+ {
+ Result_NamePlate_X[i] = int.Parse(strSplit[i]);
+ }
+ }
+ else if (strCommand == "Result_NamePlate_Y")
+ {
+ string[] strSplit = strParam.Split(',');
+ for (int i = 0; i < 2; i++)
+ {
+ Result_NamePlate_Y[i] = int.Parse(strSplit[i]);
+ }
+ }
+
+ else if (strCommand == nameof(Result_Dan))
+ {
+ Result_Dan = strParam.Split(',').Select(int.Parse).ToArray();
+ }
+ else if (strCommand == nameof(Result_Dan_XY))
+ {
+ Result_Dan_XY = strParam.Split(',').Select(int.Parse).ToArray();
+ }
+ else if (strCommand == nameof(Result_Dan_Plate_XY))
+ {
+ Result_Dan_Plate_XY = strParam.Split(',').Select(int.Parse).ToArray();
+ }
+
+ #endregion
+ #region Font
+ else if (strCommand == nameof(Font_Edge_Ratio)) //Config逕ｻ髱｢繧邁｡譏薙Γ繝九Η繝ｼ縺ｮ繝輔か繝ｳ繝医↓縺､縺縺ｦ(rhimm)
+ {
+ if (int.Parse(strParam) > 0)
+ Font_Edge_Ratio = int.Parse(strParam);
+ }
+ else if (strCommand == nameof(Font_Edge_Ratio_Vertical)) //TITLE繧ТUBTITLE縺ｪ縺ｩ縲∫ｸｦ縺ｫ譖ｸ縺九ｌ繧九％縺ｨ縺ｮ縺ゅｋ繝輔か繝ｳ繝医↓縺､縺縺ｦ(rhimm)
+ {
+ if (int.Parse(strParam) > 0)
+ Font_Edge_Ratio_Vertical = int.Parse(strParam);
+ }
+ else if (strCommand == nameof(Text_Correction_X))
+ {
+ Text_Correction_X = int.Parse(strParam);
+ }
+ else if (strCommand == nameof(Text_Correction_Y))
+ {
+ Text_Correction_Y = int.Parse(strParam);
+ }
+ #endregion
+ #endregion
+ }
+ continue;
+ }
+ catch (Exception exception)
+ {
+ Trace.TraceError(exception.ToString());
+ Trace.TraceError("萓句､悶′逋ｺ逕溘＠縺ｾ縺励◆縺悟ｦ逅繧堤ｶ咏ｶ壹＠縺ｾ縺吶 (6a32cc37-1527-412e-968a-512c1f0135cd)");
+ continue;
+ }
+ }
+ }
+ }
+
+ private void t蠎ｧ讓吶ｮ霑ｽ蠕楢ｨｭ螳()
+ {
+ //
+ if (bFieldBgPointOverride == true)
+ {
+
+ }
+ }
+
+ #region [ IDisposable 螳溯｣ ]
+ //-----------------
+ public void Dispose()
+ {
+ if (!this.bDisposed貂医∩)
+ {
+ for (int i = 0; i < this.n繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝画焚; i++)
+ this[i].Dispose();
+
+ this.bDisposed貂医∩ = true;
+ }
+ }
+ //-----------------
+ #endregion
+
+
+ // 縺昴ｮ莉
+
+ #region [ private ]
+ //-----------------
+ private bool bDisposed貂医∩;
+ //-----------------
+ #endregion
+
+ #region 閭梧勹(繧ｹ繧ｯ繝ｭ繝ｼ繝ｫ)
+ public int[] Background_Scroll_Y = new int[] { 0, 536 };
+ #endregion
+
+
+ #region[ 蠎ｧ讓 ]
+ //2017.08.11 kairera0467 DP螳溽畑蛹悶↓蜷代¢縺ｦint驟榊励↓螟画峩
+
+ //繝輔ぅ繝ｼ繝ｫ繝我ｽ咲ｽｮ縲X縺ｯ蛻､螳壽棧驛ｨ蛻縺ｮ菴咲ｽｮ縲Y縺ｯ繝輔ぅ繝ｼ繝ｫ繝峨ｮ譛荳企Κ縺ｮ蠎ｧ讓吶
+ //迴ｾ譎らせ縺ｧ縺ｯ繝弱ｼ繝逕ｻ蜒上ヾenotes逕ｻ蜒上∝愛螳壽棧縺碁｣蜍輔☆繧九
+ //X縺ｯ荳ｭ螟ｮ蝓ｺ貅匁緒逕ｻ縲〆縺ｯ蟾ｦ荳雁渕貅匁緒逕ｻ
+ public int[] nScrollFieldX = new int[] { 414, 414 };
+ public int[] nScrollFieldY = new int[] { 192, 368 };
+
+ //荳ｭ蠢蠎ｧ讓呎欠螳
+ public int[] nJudgePointX = new int[] { 413, 413, 413, 413 };
+ public int[] nJudgePointY = new int[] { 256, 433, 0, 0 };
+
+ //繝輔ぅ繝ｼ繝ｫ繝芽レ譎ｯ逕ｻ蜒
+ //ScrollField蠎ｧ讓吶∈縺ｮ霑ｽ蠕楢ｨｭ螳壹′蜿ｯ閭ｽ縲
+ //蛻蟯占レ譎ｯ縲√ざ繝ｼ繧ｴ繝ｼ閭梧勹縺碁｣蜍輔☆繧九(蜈ｨ縺ｦ蜷後§螟ｧ縺阪＆縲∽ｽ咲ｽｮ縺ｧ菴懈舌☆繧九％縺ｨ縲)
+ //蟾ｦ荳雁渕貅匁緒逕ｻ
+ public bool bFieldBgPointOverride = false;
+ public int[] nScrollFieldBGX = new int[] { 333, 333, 333, 333 };
+ public int[] nScrollFieldBGY = new int[] { 192, 368, 0, 0 };
+
+ //SEnotes
+ //髻ｳ隨ｦ蠎ｧ讓吶↓蜉邂
+ public int[] nSENotesY = new int[] { 131, 131 };
+
+ //蜈峨ｋ螟ｪ鮠馴Κ蛻
+ public int nMtaikoBackgroundX = 0;
+ public int nMtaikoBackgroundY = 184;
+ public int nMtaikoFieldX = 0;
+ public int nMtaikoFieldY = 184;
+ public int nMtaikoMainX = 0;
+ public int nMtaikoMainY = 0;
+
+ //繧ｳ繝ｳ繝
+ public int[] nComboNumberX = new int[] { 0, 0, 0, 0 };
+ public int[] nComboNumberY = new int[] { 212, 388, 0, 0 };
+ public int[] nComboNumberTextY = new int[] { 271, 447, 0, 0 };
+ public int[] nComboNumberTextLargeY = new int[] { 270, 446, 0, 0 };
+ public float fComboNumberSpacing = 0;
+ public float fComboNumberSpacing_l = 0;
+
+ public E髮｣譏灘ｺｦ陦ｨ遉ｺ繧ｿ繧､繝 eDiffDispMode;
+ public bool b迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ謨ｰ繧定｡ｨ遉ｺ縺励↑縺;
+
+ //繝ｪ繧ｶ繝ｫ繝育判髱｢
+ //迴ｾ蝨ｨ縺ｮ繝繝輔か繝ｫ繝亥､縺ｯ繝繝溘ｼ縺ｧ縺吶
+ public int nResultPanelP1X = 0;
+ public int nResultPanelP1Y = 0;
+ public int nResultPanelP2X = 515;
+ public int nResultPanelP2Y = 75;
+ public int nResultScoreP1X = 295;
+ public int nResultScoreP1Y = 212;
+ public int nResultJudge1_P1X = 495;
+ public int nResultJudge1_P1Y = 182;
+ public int nResultJudge2_P1X = 968;
+ public int nResultJudge2_P1Y = 174;
+
+ public int nResultNumberP1X = 490;
+ public int nResultNumberP2X = 875;
+
+ public int nResultNumberY = 188;
+ public int nResultNumberYPadding = 42;
+
+ public int nResultGaugeBaseP1X = 56;
+ public int nResultGaugeBaseP1Y = 141;
+ public int nResultGaugeBaseP2X = 555;
+ public int nResultGaugeBaseP2Y = 122;
+ public int nResultGaugeBodyP1X = 559;
+ public int nResultGaugeBodyP1Y = 125;
+ #endregion
+
+ public string[] strString繧帝榊励↓逶ｴ縺(string str)
+ {
+ string[] strArray = str.Split(',');
+ return strArray;
+ }
+
+ public enum RollColorMode
+ {
+ None, // PS4, Switch縺ｪ縺ｩ
+ All, // 譌ｧ遲蝉ｽ(譌ｧ菴懷性繧)
+ WithoutStart // 譁ｰ遲蝉ｽ
+ }
+ public enum ReferencePoint //繝繧ｯ繧ｹ繝√Ε謠冗判縺ｮ蝓ｺ貅也せ繧貞､画峩蜿ｯ閭ｽ縺ｫ縺吶ｋ縺溘ａ縺ｮ蛟､(rhimm)
+ {
+ Center,
+ Left,
+ Right
+ }
+
+ #region 譁ｰ繝ｻSkinConfig
+ #region General
+ public string Skin_Name = "Unknown";
+ public string Skin_Version = "Unknown";
+ public string Skin_Creator = "Unknown";
+ #endregion
+ #region Config
+ public int Config_ItemText_Correction_X = 0;
+ public int Config_ItemText_Correction_Y = 0;
+ #endregion
+ #region SongSelect
+ public int SongSelect_Overall_Y = 123;
+ public int SongSelect_BoxExplanation_X = 0;
+ public int SongSelect_BoxExplanation_Y = 0;
+ public int SongSelect_BoxExplanation_Interval = 30;
+ public int SongSelect_Title_X = 0;
+ public int SongSelect_Title_Y = 0;
+ public string[] SongSelect_GenreName = { "繝昴ャ繝励せ", "繧｢繝九Γ", "繧ｲ繝ｼ繝繝舌Λ繧ｨ繝繧｣", "繝翫Β繧ｳ繧ｪ繝ｪ繧ｸ繝翫Ν", "繧ｯ繝ｩ繧ｷ繝繧ｯ", "繝舌Λ繧ｨ繝繧｣", "繧ｭ繝繧ｺ", "繝懊ｼ繧ｫ繝ｭ繧､繝", "譛霑鷹♀繧薙□譖ｲ"};
+ public int[] SongSelect_NamePlate_X = new int[] { 36, 1020 };
+ public int[] SongSelect_NamePlate_Y = new int[] { 615, 615 };
+ public int[] SongSelect_Auto_X = new int[] { 60, 950 };
+ public int[] SongSelect_Auto_Y = new int[] { 650, 650 };
+ public Color SongSelect_ForeColor_JPOP = ColorTranslator.FromHtml("#FFFFFF");
+ public Color SongSelect_ForeColor_Anime = ColorTranslator.FromHtml("#FFFFFF");
+ public Color SongSelect_ForeColor_VOCALOID = ColorTranslator.FromHtml("#FFFFFF");
+ public Color SongSelect_ForeColor_Children = ColorTranslator.FromHtml("#FFFFFF");
+ public Color SongSelect_ForeColor_Variety = ColorTranslator.FromHtml("#FFFFFF");
+ public Color SongSelect_ForeColor_Classic = ColorTranslator.FromHtml("#FFFFFF");
+ public Color SongSelect_ForeColor_GameMusic = ColorTranslator.FromHtml("#FFFFFF");
+ public Color SongSelect_ForeColor_Namco = ColorTranslator.FromHtml("#FFFFFF");
+ public Color SongSelect_BackColor_JPOP = ColorTranslator.FromHtml("#01455B");
+ public Color SongSelect_BackColor_Anime = ColorTranslator.FromHtml("#99001F");
+ public Color SongSelect_BackColor_VOCALOID = ColorTranslator.FromHtml("#5B6278");
+ public Color SongSelect_BackColor_Children = ColorTranslator.FromHtml("#9D3800");
+ public Color SongSelect_BackColor_Variety = ColorTranslator.FromHtml("#366600");
+ public Color SongSelect_BackColor_Classic = ColorTranslator.FromHtml("#875600");
+ public Color SongSelect_BackColor_GameMusic = ColorTranslator.FromHtml("#412080");
+ public Color SongSelect_BackColor_Namco = ColorTranslator.FromHtml("#980E00");
+ public int SongSelect_Bar_Genre_Count,
+ SongSelect_Genre_Background_Count,
+ SongSelect_Box_Chara_Count,
+ SongSelect_Difficulty_Background_Count;
+ public string[] SongSelect_CorrectionX_Chara = { "縺薙％縺ｫX蠎ｧ讓吶ｒ陬懈ｭ｣縺励◆縺譁蟄励ｒ繧ｫ繝ｳ繝槭〒蛹ｺ蛻縺｣縺ｦ險伜･" };
+ public string[] SongSelect_CorrectionY_Chara = { "縺薙％縺ｫY蠎ｧ讓吶ｒ陬懈ｭ｣縺励◆縺譁蟄励ｒ繧ｫ繝ｳ繝槭〒蛹ｺ蛻縺｣縺ｦ險伜･" };
+ public int SongSelect_CorrectionX_Chara_Value = 0;
+ public int SongSelect_CorrectionY_Chara_Value = 0;
+ public string[] SongSelect_Rotate_Chara = { "縺薙％縺ｫ90邃蝗櫁ｻ｢縺輔○縺溘＞譁蟄励ｒ繧ｫ繝ｳ繝槭〒蛹ｺ蛻縺｣縺ｦ險伜･" };
+
+ #endregion
+ #region SongLoading
+ public int SongLoading_Plate_X = 640;
+ public int SongLoading_Plate_Y = 360;
+ public int SongLoading_Title_X = 640;
+ public int SongLoading_Title_Y = 280;
+ public int SongLoading_SubTitle_X = 640;
+ public int SongLoading_SubTitle_Y = 325;
+ public int SongLoading_Title_FontSize = 31;
+ public int SongLoading_SubTitle_FontSize = 20;
+ public ReferencePoint SongLoading_Plate_ReferencePoint = ReferencePoint.Center;
+ public ReferencePoint SongLoading_Title_ReferencePoint = ReferencePoint.Center;
+ public ReferencePoint SongLoading_SubTitle_ReferencePoint = ReferencePoint.Center;
+ public Color SongLoading_Title_ForeColor = ColorTranslator.FromHtml("#FFFFFF");
+ public Color SongLoading_Title_BackColor = ColorTranslator.FromHtml("#000000");
+ public Color SongLoading_SubTitle_ForeColor = ColorTranslator.FromHtml("#000000");
+ public Color SongLoading_SubTitle_BackColor = ColorTranslator.FromHtml("#00000000");
+ public bool SongLoading_Plate_ScreenBlend = false;
+
+ #endregion
+ #region Game
+ public bool Game_Notes_Anime = false;
+ public string Game_StageText = "1譖ｲ逶ｮ";
+ public RollColorMode Game_RollColorMode = RollColorMode.All;
+ public bool Game_JudgeFrame_AddBlend = true;
+ #region Chara
+ public int[] Game_Chara_X = new int[] { 0, 0 };
+ public int[] Game_Chara_Y = new int[] { 0, 537 };
+ public int[] Game_Chara_Balloon_X = new int[] { 240, 240, 0, 0 };
+ public int[] Game_Chara_Balloon_Y = new int[] { 0, 297, 0, 0 };
+ public int Game_Chara_Ptn_Normal,
+ Game_Chara_Ptn_GoGo,
+ Game_Chara_Ptn_Clear,
+ Game_Chara_Ptn_10combo,
+ Game_Chara_Ptn_10combo_Max,
+ Game_Chara_Ptn_GoGoStart,
+ Game_Chara_Ptn_GoGoStart_Max,
+ Game_Chara_Ptn_ClearIn,
+ Game_Chara_Ptn_SoulIn,
+ Game_Chara_Ptn_Balloon_Breaking,
+ Game_Chara_Ptn_Balloon_Broke,
+ Game_Chara_Ptn_Balloon_Miss;
+ public string Game_Chara_Motion_Normal,
+ Game_Chara_Motion_Clear,
+ Game_Chara_Motion_GoGo = "0";
+ public int Game_Chara_Beat_Normal = 1;
+ public int Game_Chara_Beat_Clear = 2;
+ public int Game_Chara_Beat_GoGo = 2;
+ public int Game_Chara_Balloon_Timer = 28;
+ public int Game_Chara_Balloon_Delay = 500;
+ public int Game_Chara_Balloon_FadeOut = 84;
+ #endregion
+ #region Dancer
+ public int[] Game_Dancer_X = new int[] { 640, 430, 856, 215, 1070 };
+ public int[] Game_Dancer_Y = new int[] { 500, 500, 500, 500, 500 };
+ public string Game_Dancer_Motion = "0";
+ public int Game_Dancer_Ptn = 0;
+ public int Game_Dancer_Beat = 8;
+ public int[] Game_Dancer_Gauge = new int[] { 0, 0, 0, 40, 80 };
+ #endregion
+ #region Mob
+ public int Game_Mob_Ptn = 1;
+ public int Game_Mob_Beat,
+ Game_Mob_Ptn_Beat = 1;
+ #endregion
+ #region CourseSymbol
+ public int[] Game_CourseSymbol_X = new int[] { 64, 64 };
+ public int[] Game_CourseSymbol_Y = new int[] { 232, 582 };
+ #endregion
+ #region PanelFont
+ public int Game_MusicName_X = 1160;
+ public int Game_MusicName_Y = 24;
+ public int Game_MusicName_FontSize = 27;
+ public ReferencePoint Game_MusicName_ReferencePoint = ReferencePoint.Center;
+ public int Game_Genre_X = 1015;
+ public int Game_Genre_Y = 70;
+ public int Game_Lyric_X = 640;
+ public int Game_Lyric_Y = 630;
+ public string Game_Lyric_FontName = "MS UI Gothic";
+ public int Game_Lyric_FontSize = 38;
+ public ReferencePoint Game_Lyric_ReferencePoint = ReferencePoint.Center;
+
+ public Color Game_MusicName_ForeColor = ColorTranslator.FromHtml("#FFFFFF");
+ public Color Game_StageText_ForeColor = ColorTranslator.FromHtml("#FFFFFF");
+ public Color Game_Lyric_ForeColor = ColorTranslator.FromHtml("#FFFFFF");
+ public Color Game_MusicName_BackColor = ColorTranslator.FromHtml("#000000");
+ public Color Game_StageText_BackColor = ColorTranslator.FromHtml("#000000");
+ public Color Game_Lyric_BackColor = ColorTranslator.FromHtml("#0000FF");
+
+ #endregion
+ #region Score
+ public int[] Game_Score_X = new int[] { 20, 20, 0, 0 };
+ public int[] Game_Score_Y = new int[] { 226, 530, 0, 0 };
+ public int[] Game_Score_Add_X = new int[] { 20, 20, 0, 0 };
+ public int[] Game_Score_Add_Y = new int[] { 186, 570, 0, 0 };
+ public int[] Game_Score_AddBonus_X = new int[] { 20, 20, 0, 0 };
+ public int[] Game_Score_AddBonus_Y = new int[] { 136, 626, 0, 0 };
+ public int Game_Score_Padding = 20;
+ public int[] Game_Score_Size = new int[] { 24, 40 };
+ #endregion
+ #region Taiko
+ public int[] Game_Taiko_NamePlate_X = new int[] { 0, 0 };
+ public int[] Game_Taiko_NamePlate_Y = new int[] { 300, 380 };
+ public int[] Game_Taiko_PlayerNumber_X = new int[] { 4, 4 };
+ public int[] Game_Taiko_PlayerNumber_Y = new int[] { 233, 435 };
+ public int[] Game_Taiko_X = new int[] { 190, 190 };
+ public int[] Game_Taiko_Y = new int[] { 190, 368 };
+ public int[] Game_Taiko_Combo_X = new int[] { 267, 267 };
+ public int[] Game_Taiko_Combo_Y = new int[] { 272, 447 };
+ public int[] Game_Taiko_Combo_Ex_X = new int[] { 267, 267 };
+ public int[] Game_Taiko_Combo_Ex_Y = new int[] { 274, 451 };
+ public int[] Game_Taiko_Combo_Ex4_X = new int[] { 267, 267 };
+ public int[] Game_Taiko_Combo_Ex4_Y = new int[] { 269, 447 };
+ public int[] Game_Taiko_Combo_Padding = new int[] { 34, 34, 30 };
+ public int[] Game_Taiko_Combo_Size = new int[] { 40, 48 };
+ public int[] Game_Taiko_Combo_Size_Ex = new int[] { 40, 48 };
+ public float[] Game_Taiko_Combo_Scale = new float[] { 1.0f, 1.0f, 0.9f };
+ public int[] Game_Taiko_Combo_Text_X = new int[] { 268, 268 };
+ public int[] Game_Taiko_Combo_Text_Y = new int[] { 298, 475 };
+ public int[] Game_Taiko_Combo_Text_Size = new int[] { 100, 50 };
+ public bool Game_Taiko_Combo_Ex_IsJumping = true;
+ #endregion
+ #region Gauge
+ public int Game_Gauge_Rainbow_Ptn;
+ public int Game_Gauge_Dan_Rainbow_Ptn;
+ public int Game_Gauge_Rainbow_Timer = 50;
+ #endregion
+ #region Balloon
+ public int[] Game_Balloon_Combo_X = new int[] { 253, 253 };
+ public int[] Game_Balloon_Combo_Y = new int[] { -11, 538 };
+ public int[] Game_Balloon_Combo_Number_X = new int[] { 257, 257 };
+ public int[] Game_Balloon_Combo_Number_Y = new int[] { 54, 603 };
+ public int[] Game_Balloon_Combo_Number_Ex_X = new int[] { 297, 297 };
+ public int[] Game_Balloon_Combo_Number_Ex_Y = new int[] { 54, 603 };
+ public int[] Game_Balloon_Combo_Text_X = new int[] { 440, 440 };
+ public int[] Game_Balloon_Combo_Text_Y = new int[] { 85, 634 };
+ public int[] Game_Balloon_Combo_Text_Ex_X = new int[] { 440, 440 };
+ public int[] Game_Balloon_Combo_Text_Ex_Y = new int[] { 85, 594 };
+
+ public int[] Game_Balloon_Balloon_X = new int[] { 382, 382 };
+ public int[] Game_Balloon_Balloon_Y = new int[] { 115, 290 };
+ public int[] Game_Balloon_Balloon_Frame_X = new int[] { 382, 382 };
+ public int[] Game_Balloon_Balloon_Frame_Y = new int[] { 80, 260 };
+ public int[] Game_Balloon_Balloon_Number_X = new int[] { 486, 486 };
+ public int[] Game_Balloon_Balloon_Number_Y = new int[] { 187, 373 };
+ public int[] Game_Balloon_Roll_Frame_X = new int[] { 218, 218 };
+ public int[] Game_Balloon_Roll_Frame_Y = new int[] { -3, 514 };
+ public int[] Game_Balloon_Roll_Number_X = new int[] { 376, 376 };
+ public int[] Game_Balloon_Roll_Number_Y = new int[] { 122, 633 };
+ public int[] Game_Balloon_Number_Size = new int[] { 63, 75 };
+ public int Game_Balloon_Number_Padding = 55;
+ public float Game_Balloon_Roll_Number_Scale = 1.000f;
+ public float Game_Balloon_Balloon_Number_Scale = 0.879f;
+ #endregion
+ #region Effects
+ public int[] Game_Effect_Roll_StartPoint_X = new int[] { 56, -10, 200, 345, 100, 451, 600, 260, -30, 534, 156, 363 };
+ public int[] Game_Effect_Roll_StartPoint_Y = new int[] { 720 };
+ public int[] Game_Effect_Roll_StartPoint_1P_X = new int[] { 56, -10, 200, 345, 100, 451, 600, 260, -30, 534, 156, 363 };
+ public int[] Game_Effect_Roll_StartPoint_1P_Y = new int[] { 240 };
+ public int[] Game_Effect_Roll_StartPoint_2P_X = new int[] { 56, -10, 200, 345, 100, 451, 600, 260, -30, 534, 156, 363 };
+ public int[] Game_Effect_Roll_StartPoint_2P_Y = new int[] { 360 };
+ public float[] Game_Effect_Roll_Speed_X = new float[] { 0.6f };
+ public float[] Game_Effect_Roll_Speed_Y = new float[] { -0.6f };
+ public float[] Game_Effect_Roll_Speed_1P_X = new float[] { 0.6f };
+ public float[] Game_Effect_Roll_Speed_1P_Y = new float[] { -0.6f };
+ public float[] Game_Effect_Roll_Speed_2P_X = new float[] { 0.6f };
+ public float[] Game_Effect_Roll_Speed_2P_Y = new float[] { 0.6f };
+ public int Game_Effect_Roll_Ptn;
+ public int[] Game_Effect_NotesFlash = new int[] { 180, 180, 16 }; // Width, Height, Ptn
+ public int Game_Effect_NotesFlash_Timer = 20;
+ public int[] Game_Effect_GoGoSplash = new int[] { 300, 400, 30 };
+ public int[] Game_Effect_GoGoSplash_X = new int[] { 120, 300, 520, 760, 980, 1160 };
+ public int[] Game_Effect_GoGoSplash_Y = new int[] { 740, 730, 720, 720, 730, 740 };
+ public bool Game_Effect_GoGoSplash_Rotate = true;
+ public int Game_Effect_GoGoSplash_Timer = 18;
+ // super-flying-notes AioiLight
+ public int[] Game_Effect_FlyingNotes_StartPoint_X = new int[] { 414, 414 };
+ public int[] Game_Effect_FlyingNotes_StartPoint_Y = new int[] { 260, 434 };
+ public int[] Game_Effect_FlyingNotes_EndPoint_X = new int[] { 1222, 1222 }; // 1P, 2P
+ public int[] Game_Effect_FlyingNotes_EndPoint_Y = new int[] { 164, 554 };
+
+ public int Game_Effect_FlyingNotes_Sine = 220;
+ public bool Game_Effect_FlyingNotes_IsUsingEasing = true;
+ public int Game_Effect_FlyingNotes_Timer = 4;
+ public int[] Game_Effect_FireWorks = new int[] { 180, 180, 30 };
+ public int Game_Effect_FireWorks_Timer = 5;
+ public int Game_Effect_Rainbow_Timer = 8;
+
+ public bool Game_Effect_HitExplosion_AddBlend = true;
+ public bool Game_Effect_HitExplosionBig_AddBlend = true;
+ public bool Game_Effect_FireWorks_AddBlend = true;
+ public bool Game_Effect_Fire_AddBlend = true;
+ public bool Game_Effect_GoGoSplash_AddBlend = true;
+ public int Game_Effect_FireWorks_Timing = 8;
+ #endregion
+ #region Runner
+ public int[] Game_Runner_Size = new int[] { 60, 125 };
+ public int Game_Runner_Ptn = 48;
+ public int Game_Runner_Type = 4;
+ public int[] Game_Runner_StartPoint_X = new int[] { 175, 175 };
+ public int[] Game_Runner_StartPoint_Y = new int[] { 40, 560 };
+ public int Game_Runner_Timer = 16;
+ #endregion
+ #region PuchiChara
+ public int[] Game_PuchiChara_X = new int[] { 100, 100 };
+ public int[] Game_PuchiChara_Y = new int[] { 140, 600 };
+ public int[] Game_PuchiChara_BalloonX = new int[] { 300, 300 };
+ public int[] Game_PuchiChara_BalloonY = new int[] { 240, 500 };
+ public float[] Game_PuchiChara_Scale = new float[] { 0.7f, 1.0f }; // 騾壼ｸｸ譎ゅ 縺ｵ縺縺帙ｓ騾｣謇捺凾
+ public int[] Game_PuchiChara = new int[] { 180, 180, 2 }; // Width, Height, Ptn
+ public int Game_PuchiChara_Sine = 20;
+ public int Game_PuchiChara_Timer = 4800;
+ public double Game_PuchiChara_SineTimer = 2;
+ #endregion
+ #region Dan-C
+ public Color Game_DanC_Title_ForeColor = ColorTranslator.FromHtml("#FFFFFF");
+ public Color Game_DanC_Title_BackColor = ColorTranslator.FromHtml("#000000");
+ public Color Game_DanC_SubTitle_ForeColor = ColorTranslator.FromHtml("#FFFFFF");
+ public Color Game_DanC_SubTitle_BackColor = ColorTranslator.FromHtml("#000000");
+
+ public int[] Game_DanC_Size = new int[] { 1006, 92 };
+ public int[] Game_DanC_Number_Size = new int[] { 48, 58 };
+ public int[] Game_DanC_Small_Number_Size = new int[] { 24, 29 };
+ public int[] Game_DanC_MiniNumber_Size = new int[] { 23, 28 };
+ public int[] Game_DanC_ExamType_Size = new int[] { 247, 28 };
+ public int[] Game_DanC_ExamRange_Size = new int[] { 54, 30 };
+ public int[] Game_DanC_ExamUnit_Size = new int[] { 30, 36 };
+
+ public int[] Game_DanC_Offset = new int[] { 259, 27 };
+ public int[] Game_DanC_Number_Small_Number_Offset = new int[] { 285, 38 };
+ public int[] Game_DanC_Exam_Offset = new int[] { 222, 27 };
+
+ public int[] Game_DanC_X = new int[] { 807, 70, 70, 70 }; // 329, 437
+ public int[] Game_DanC_Y = new int[] { 116, 292, 292, 292 }; // { 116, 190, 236, 292 };
+ public int[] Game_DanC_Number_XY = new int[] { 214, 67 };
+ public int[] Game_DanC_Dan_Plate = new int[] { 149, 416 };
+
+ public int Game_DanC_Padding = 9;
+ public int Game_DanC_Number_Padding = 35;
+ public int Game_DanC_Number_Small_Padding = 41;
+ public int Game_DanC_ExamRange_Padding = 49;
+ public int[] Game_DanC_Percent_Hit_Score_Padding = new int[] { 20, 20, 20 };
+
+ public float Game_DanC_Number_Small_Scale = 0.92f;
+ public float Game_DanC_Exam_Number_Scale = 0.47f;
+
+ #endregion
+ #region Training
+ public int Game_Training_ScrollTime = 350;
+ public int[] Game_Training_ProgressBar_XY = { 333, 378 };
+ public int Game_Training_GoGoPoint_Y = 396;
+ public int Game_Training_JumpPoint_Y = 375;
+ public int[] Game_Training_MaxMeasureCount_XY = { 284, 377 };
+ public int[] Game_Training_CurrentMeasureCount_XY = { 254, 370 };
+ public int[] Game_Training_SpeedDisplay_XY = { 110, 370 };
+ public int Game_Training_SmallNumber_Width = 17;
+ public int Game_Training_BigNumber_Width = 20;
+ #endregion
+
+ #endregion
+ #region Result
+ public int Result_MusicName_X = 640;
+ public int Result_MusicName_Y = 30;
+ public int Result_MusicName_FontSize = 25;
+ public ReferencePoint Result_MusicName_ReferencePoint = ReferencePoint.Center;
+ public int Result_StageText_X = 230;
+ public int Result_StageText_Y = 6;
+ public int Result_StageText_FontSize = 30;
+ public ReferencePoint Result_StageText_ReferencePoint = ReferencePoint.Left;
+
+ public Color Result_MusicName_ForeColor = ColorTranslator.FromHtml("#FFFFFF");
+ public Color Result_StageText_ForeColor = ColorTranslator.FromHtml("#FFFFFF");
+ //public Color Result_StageText_ForeColor_Red = ColorTranslator.FromHtml("#FFFFFF");
+ public Color Result_MusicName_BackColor = ColorTranslator.FromHtml("#000000");
+ public Color Result_StageText_BackColor = ColorTranslator.FromHtml("#000000");
+ //public Color Result_StageText_BackColor_Red = ColorTranslator.FromHtml("#FF0000");
+
+ public int[] Result_NamePlate_X = new int[] { 6, 260 };
+ public int[] Result_NamePlate_Y = new int[] { 611, 611 };
+
+ public int[] Result_Dan = new int[] { 500, 500 };
+ public int[] Result_Dan_XY = new int[] { 100, 0 };
+ public int[] Result_Dan_Plate_XY = new int[] { 149, 416 };
+ #endregion
+ #region Font
+ public int Font_Edge_Ratio = 30;
+ public int Font_Edge_Ratio_Vertical = 30;
+ public int Text_Correction_X = 0;
+ public int Text_Correction_Y = 0;
+ #endregion
+ #endregion
+ }
+}
\ No newline at end of file
diff --git a/TJAPlayer3/Common/CVeirticalSongNameFont.cs b/TJAPlayer3/Common/CVeirticalSongNameFont.cs
new file mode 100644
index 00000000..ef110efb
--- /dev/null
+++ b/TJAPlayer3/Common/CVeirticalSongNameFont.cs
@@ -0,0 +1,35 @@
+ｻｿusing System;
+using System.Collections.Generic;
+using System.Text;
+using System.IO;
+using System.Runtime.InteropServices;
+using System.Drawing;
+using System.Drawing.Drawing2D;
+using System.Diagnostics;
+using SlimDX;
+using FDK;
+
+namespace TJAPlayer3
+{
+ public class CVerticalSongNameFont
+ {
+ //蠢隕√↑蛟､
+ //_繧ｿ繧､繝医Ν
+ //_繧ｵ繝悶ち繧､繝医Ν(縺ｨ繧翫≠縺医★譛蛻昴ｯ辟｡縺励〒騾ｲ繧√ｋ)
+ //_
+ //_
+ //_
+
+
+
+
+
+
+
+ #region [ private ]
+ //-----------------
+ private const string str蝗櫁ｻ｢縺輔○繧区枚蟄 = "縲後搾ｽ橸ｼ茨ｼ峨ｼ-~ｼ坂樞()縲翫宮}<>縲弱充]窶ｦ";
+ //-----------------
+ #endregion
+ }
+}
diff --git a/TJAPlayer3/Common/ConfigIniToSongGainControllerBinder.cs b/TJAPlayer3/Common/ConfigIniToSongGainControllerBinder.cs
new file mode 100644
index 00000000..2e2e604f
--- /dev/null
+++ b/TJAPlayer3/Common/ConfigIniToSongGainControllerBinder.cs
@@ -0,0 +1,38 @@
+ｻｿusing FDK;
+
+namespace TJAPlayer3
+{
+ ///
+ /// The ConfigIniToSongGainControllerBinder allows for SONGVOL and/or other
+ /// properties related to the Gain levels applied to song preview and
+ /// playback, to be applied conditionally based on settings flowing from
+ /// ConfigIni. This binder class allows that to take place without either
+ /// ConfigIni or SongGainController having awareness of one another.
+ /// See those classes properties, methods, and events for more details.
+ ///
+ internal static class ConfigIniToSongGainControllerBinder
+ {
+ internal static void Bind(CConfigIni configIni, SongGainController songGainController)
+ {
+ songGainController.ApplyLoudnessMetadata = configIni.ApplyLoudnessMetadata;
+ songGainController.TargetLoudness = new Lufs(configIni.TargetLoudness);
+ songGainController.ApplySongVol = configIni.ApplySongVol;
+
+ configIni.PropertyChanged += (sender, args) =>
+ {
+ switch (args.PropertyName)
+ {
+ case nameof(CConfigIni.ApplyLoudnessMetadata):
+ songGainController.ApplyLoudnessMetadata = configIni.ApplyLoudnessMetadata;
+ break;
+ case nameof(CConfigIni.TargetLoudness):
+ songGainController.TargetLoudness = new Lufs(configIni.TargetLoudness);
+ break;
+ case nameof(CConfigIni.ApplySongVol):
+ songGainController.ApplySongVol = configIni.ApplySongVol;
+ break;
+ }
+ };
+ }
+ }
+}
\ No newline at end of file
diff --git a/TJAPlayer3/Common/ConfigIniToSoundGroupLevelControllerBinder.cs b/TJAPlayer3/Common/ConfigIniToSoundGroupLevelControllerBinder.cs
new file mode 100644
index 00000000..2ebca6be
--- /dev/null
+++ b/TJAPlayer3/Common/ConfigIniToSoundGroupLevelControllerBinder.cs
@@ -0,0 +1,67 @@
+ｻｿusing System;
+using FDK;
+
+namespace TJAPlayer3
+{
+ ///
+ /// The ConfigIniToSoundGroupLevelControllerBinder allows for updated sound
+ /// group level values, and keyboard sound level adjustment increment
+ /// values, to flow between CConfigIni and the SoundGroupLevelController
+ /// without either of those two classes being aware of one another.
+ /// See those classes properties, methods, and events for more details.
+ ///
+ internal static class ConfigIniToSoundGroupLevelControllerBinder
+ {
+ internal static void Bind(CConfigIni configIni, SoundGroupLevelController soundGroupLevelController)
+ {
+ soundGroupLevelController.SetLevel(ESoundGroup.SoundEffect, configIni.SoundEffectLevel);
+ soundGroupLevelController.SetLevel(ESoundGroup.Voice, configIni.VoiceLevel);
+ soundGroupLevelController.SetLevel(ESoundGroup.SongPreview, configIni.SongPlaybackLevel);
+ soundGroupLevelController.SetLevel(ESoundGroup.SongPlayback, configIni.SongPlaybackLevel);
+ soundGroupLevelController.SetKeyboardSoundLevelIncrement(configIni.KeyboardSoundLevelIncrement);
+
+ configIni.PropertyChanged += (sender, args) =>
+ {
+ switch (args.PropertyName)
+ {
+ case nameof(CConfigIni.SoundEffectLevel):
+ soundGroupLevelController.SetLevel(ESoundGroup.SoundEffect, configIni.SoundEffectLevel);
+ break;
+ case nameof(CConfigIni.VoiceLevel):
+ soundGroupLevelController.SetLevel(ESoundGroup.Voice, configIni.VoiceLevel);
+ break;
+ case nameof(CConfigIni.SongPreviewLevel):
+ soundGroupLevelController.SetLevel(ESoundGroup.SongPreview, configIni.SongPlaybackLevel);
+ break;
+ case nameof(CConfigIni.SongPlaybackLevel):
+ soundGroupLevelController.SetLevel(ESoundGroup.SongPlayback, configIni.SongPlaybackLevel);
+ break;
+ case nameof(CConfigIni.KeyboardSoundLevelIncrement):
+ soundGroupLevelController.SetKeyboardSoundLevelIncrement(configIni.KeyboardSoundLevelIncrement);
+ break;
+ }
+ };
+
+ soundGroupLevelController.LevelChanged += (sender, args) =>
+ {
+ switch (args.SoundGroup)
+ {
+ case ESoundGroup.SoundEffect:
+ configIni.SoundEffectLevel = args.Level;
+ break;
+ case ESoundGroup.Voice:
+ configIni.VoiceLevel = args.Level;
+ break;
+ case ESoundGroup.SongPreview:
+ configIni.SongPlaybackLevel = args.Level;
+ break;
+ case ESoundGroup.SongPlayback:
+ configIni.SongPlaybackLevel = args.Level;
+ break;
+ default:
+ throw new ArgumentOutOfRangeException();
+ }
+ };
+ }
+ }
+}
diff --git a/TJAPlayer3/Common/ConfigManager.cs b/TJAPlayer3/Common/ConfigManager.cs
new file mode 100644
index 00000000..5200e802
--- /dev/null
+++ b/TJAPlayer3/Common/ConfigManager.cs
@@ -0,0 +1,56 @@
+ｻｿusing System.Text;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Converters;
+using Newtonsoft.Json.Serialization;
+
+namespace TJAPlayer3
+{
+ ///
+ /// 險ｭ螳壹ヵ繧｡繧､繝ｫ蜈･蜃ｺ蜉帙け繝ｩ繧ｹ縲
+ ///
+ public static class ConfigManager
+ {
+ private static readonly JsonSerializerSettings Settings =
+ new JsonSerializerSettings()
+ {
+ ObjectCreationHandling = ObjectCreationHandling.Auto,
+ DefaultValueHandling = DefaultValueHandling.Include,
+ ContractResolver = new CamelCasePropertyNamesContractResolver(),
+ Converters = new StringEnumConverter[] { new StringEnumConverter() }
+ };
+
+ ///
+ /// 險ｭ螳壹ヵ繧｡繧､繝ｫ縺ｮ隱ｭ縺ｿ霎ｼ縺ｿ繧定｡後＞縺ｾ縺吶ゅヵ繧｡繧､繝ｫ縺悟ｭ伜惠縺励↑縺九▲縺溷ｴ蜷医√◎縺ｮ繧ｯ繝ｩ繧ｹ縺ｮ譁ｰ隕上う繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ繧定ｿ斐＠縺ｾ縺吶
+ ///
+ /// 繧ｷ繝ｪ繧｢繝ｩ繧､繧ｺ縺励◆繧ｯ繝ｩ繧ｹ縲
+ /// 繝輔ぃ繧､繝ｫ蜷阪
+ /// 繝繧ｷ繝ｪ繧｢繝ｩ繧､繧ｺ邨先棡縲
+ public static T GetConfig(string filePath) where T : new()
+ {
+ var json = "";
+ if (!System.IO.File.Exists(filePath))
+ {
+ // 繝輔ぃ繧､繝ｫ縺悟ｭ伜惠縺励↑縺縺ｮ縺ｧ
+ SaveConfig(new T(), filePath);
+ }
+ using (var stream = new System.IO.StreamReader(filePath, Encoding.UTF8))
+ {
+ json = stream.ReadToEnd();
+ }
+ return JsonConvert.DeserializeObject(json, Settings);
+ }
+
+ ///
+ /// 險ｭ螳壹ヵ繧｡繧､繝ｫ縺ｮ譖ｸ縺崎ｾｼ縺ｿ繧定｡後＞縺ｾ縺吶
+ ///
+ /// 繧ｷ繝ｪ繧｢繝ｩ繧､繧ｺ縺吶ｋ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縲
+ /// 繝輔ぃ繧､繝ｫ蜷阪
+ public static void SaveConfig(object obj, string filePath)
+ {
+ using (var stream = new System.IO.StreamWriter(filePath, false, Encoding.UTF8))
+ {
+ stream.Write(JsonConvert.SerializeObject(obj, Formatting.Indented, Settings));
+ }
+ }
+ }
+}
diff --git a/TJAPlayer3/Common/C螳壽焚.cs b/TJAPlayer3/Common/C螳壽焚.cs
new file mode 100644
index 00000000..5b5aa8e5
--- /dev/null
+++ b/TJAPlayer3/Common/C螳壽焚.cs
@@ -0,0 +1,774 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Runtime.InteropServices;
+
+namespace TJAPlayer3
+{
+
+ ///
+ /// 髮｣譏灘ｺｦ縲
+ ///
+ public enum Difficulty
+ {
+ Easy,
+ Normal,
+ Hard,
+ Oni,
+ Edit,
+ Tower,
+ Dan,
+ Total
+ }
+
+ public enum EScrollMode
+ {
+ Normal,
+ BMSCROLL,
+ HBSCROLL
+ }
+ public enum E繧ｸ繝｣繝ｳ繝ｫ
+ {
+ None = 0,
+ JPOP = 1,
+ 繧ｲ繝ｼ繝 = 2,
+ 繝翫Β繧ｳ = 3,
+ 繧ｯ繝ｩ繧ｷ繝繧ｯ = 4,
+ 繝舌Λ繧ｨ繝繧｣ = 5,
+ 縺ｩ縺繧医≧ = 6,
+ 繝懊ｼ繧ｫ繝ｭ繧､繝 = 7,
+ 繧｢繝九Γ = 8
+ }
+ public enum EGame
+ {
+ OFF = 0,
+ 螳瑚ｵｰ蜿ｩ縺阪″繧翫∪繧ｷ繝ｧ繝ｼ = 1,
+ 螳瑚ｵｰ蜿ｩ縺阪″繧翫∪繧ｷ繝ｧ繝ｼ豼霎 = 2
+ }
+ public enum E髮｣譏灘ｺｦ陦ｨ遉ｺ繧ｿ繧､繝
+ {
+ OFF = 0,
+ n譖ｲ逶ｮ縺ｫ陦ｨ遉ｺ = 1,
+ mtaiko縺ｫ逕ｻ蜒上〒陦ｨ遉ｺ = 2,
+ }
+ public enum E繝繝ｼ繧ｯ繝｢繝ｼ繝
+ {
+ OFF,
+ HALF,
+ FULL
+ }
+ public enum EWindowMovieMode
+ {
+ OFF = 0,
+ 蟾ｦ荳 = 1,
+ 荳ｭ螟ｮ荳 = 2
+ }
+ public enum E繝繝｡繝ｼ繧ｸ繝ｬ繝吶Ν
+ {
+ 蟆代↑縺 = 0,
+ 譎ｮ騾 = 1,
+ 螟ｧ縺阪＞ = 2
+ }
+ public enum E繝代ャ繝 // 貍泌･冗畑縺ｮenum縲ゅ％縺薙ｒ菫ｮ豁｣縺吶ｋ縺ｨ縺阪ｯ縲∵ｬ｡縺ｫ蜃ｺ縺ｦ縺上ｋ EKeyConfigPad 縺ｨ E繝代ャ繝宇lag 繧ゅそ繝繝医〒菫ｮ豁｣縺吶ｋ縺薙→縲
+ {
+ HH = 0,
+ R = 0,
+ SD = 1,
+ G = 1,
+ BD = 2,
+ B = 2,
+ HT = 3,
+ Pick = 3,
+ LT = 4,
+ Wail = 4,
+ FT = 5,
+ Cancel = 5,
+ CY = 6,
+ Decide = 6,
+ HHO = 7,
+ RD = 8,
+ LC = 9,
+ LP = 10, // #27029 2012.1.4 from
+ LBD = 11,
+ LRed = 12,
+ RRed = 13,
+ LBlue = 14,
+ RBlue = 15,
+ LRed2P = 16,
+ RRed2P = 17,
+ LBlue2P = 18,
+ RBlue2P = 19,
+ MAX, // 髢逡ｪ逕ｨ縺ｨ縺励※螳夂ｾｩ
+ UNKNOWN = 99
+ }
+ public enum EKeyConfigPad // #24609 繧ｭ繝ｼ繧ｳ繝ｳ繝輔ぅ繧ｰ縺ｧ菴ｿ縺enum縲Ｄapture隕∫ｴ縺ゅｊ縲
+ {
+ HH = E繝代ャ繝.HH,
+ R = E繝代ャ繝.R,
+ SD = E繝代ャ繝.SD,
+ G = E繝代ャ繝.G,
+ BD = E繝代ャ繝.BD,
+ B = E繝代ャ繝.B,
+ HT = E繝代ャ繝.HT,
+ Pick = E繝代ャ繝.Pick,
+ LT = E繝代ャ繝.LT,
+ Wail = E繝代ャ繝.Wail,
+ FT = E繝代ャ繝.FT,
+ Cancel = E繝代ャ繝.Cancel,
+ CY = E繝代ャ繝.CY,
+ Decide = E繝代ャ繝.Decide,
+ HHO = E繝代ャ繝.HHO,
+ RD = E繝代ャ繝.RD,
+ LC = E繝代ャ繝.LC,
+ LP = E繝代ャ繝.LP, // #27029 2012.1.4 from
+ LBD = E繝代ャ繝.LBD,
+ LRed = E繝代ャ繝.LRed,
+ RRed = E繝代ャ繝.RRed,
+ LBlue = E繝代ャ繝.LBlue,
+ RBlue = E繝代ャ繝.RBlue,
+ LRed2P = E繝代ャ繝.LRed2P,
+ RRed2P = E繝代ャ繝.RRed2P,
+ LBlue2P = E繝代ャ繝.LBlue2P,
+ RBlue2P = E繝代ャ繝.RBlue2P,
+ Capture,
+ UNKNOWN = E繝代ャ繝.UNKNOWN
+ }
+ [Flags]
+ public enum E繝代ャ繝宇lag // #24063 2011.1.16 yyagi 繧ｳ繝槭Φ繝牙･蜉帷畑 繝代ャ繝牙･蜉帙ｮ繝輔Λ繧ｰ蛹
+ {
+ None = 0,
+ HH = 1,
+ R = 1,
+ SD = 2,
+ G = 2,
+ B = 4,
+ BD = 4,
+ HT = 8,
+ Pick = 8,
+ LT = 16,
+ Wail = 16,
+ FT = 32,
+ Cancel = 32,
+ CY = 64,
+ Decide = 128,
+ HHO = 128,
+ RD = 256,
+ LC = 512,
+ LP = 1024, // #27029
+ LBD = 2048,
+ LRed = 0,
+ RRed = 1,
+ LBlue = 2,
+ RBlue = 4,
+ LRed2P = 8,
+ RRed2P = 16,
+ LBlue2P = 32,
+ RBlue2P = 64,
+ UNKNOWN = 4096
+ }
+ public enum E繝ｩ繝ｳ繝繝繝｢繝ｼ繝
+ {
+ OFF,
+ RANDOM,
+ MIRROR,
+ SUPERRANDOM,
+ HYPERRANDOM
+ }
+ public enum E讌ｽ蝎ｨ繝代ｼ繝 // 縺薙％繧剃ｿｮ豁｣縺吶ｋ縺ｨ縺阪ｯ縲√そ繝繝医〒谺｡縺ｮ EKeyConfigPart 繧ゆｿｮ豁｣縺吶ｋ縺薙→縲
+ {
+ DRUMS = 0,
+ GUITAR = 1,
+ BASS = 2,
+ TAIKO = 3,
+ UNKNOWN = 99
+ }
+ public enum EKeyConfigPart // : E讌ｽ蝎ｨ繝代ｼ繝
+ {
+ DRUMS = E讌ｽ蝎ｨ繝代ｼ繝.DRUMS,
+ GUITAR = E讌ｽ蝎ｨ繝代ｼ繝.GUITAR,
+ BASS = E讌ｽ蝎ｨ繝代ｼ繝.BASS,
+ TAIKO = E讌ｽ蝎ｨ繝代ｼ繝.TAIKO,
+ SYSTEM,
+ UNKNOWN = E讌ｽ蝎ｨ繝代ｼ繝.UNKNOWN
+ }
+
+ public enum E謇薙■蛻縺第凾縺ｮ蜀咲函縺ｮ蜆ｪ蜈磯菴
+ {
+ Chip縺訓ad繧医ｊ蜆ｪ蜈,
+ Pad縺靴hip繧医ｊ蜆ｪ蜈
+ }
+ internal enum E蜈･蜉帙ョ繝舌う繧ｹ
+ {
+ 繧ｭ繝ｼ繝懊ｼ繝 = 0,
+ MIDI蜈･蜉 = 1,
+ 繧ｸ繝ｧ繧､繝代ャ繝 = 2,
+ 繝槭え繧ｹ = 3,
+ 荳肴 = -1
+ }
+ public enum E蛻､螳
+ {
+ Perfect = 0,
+ Great = 1,
+ Good = 2,
+ Poor = 3,
+ Miss = 4,
+ Bad = 5,
+ Auto
+ }
+ internal enum E蛻､螳壽枚蟄苓｡ｨ遉ｺ菴咲ｽｮ
+ {
+ 陦ｨ遉ｺOFF,
+ 繝ｬ繝ｼ繝ｳ荳,
+ 蛻､螳壹Λ繧､繝ｳ荳,
+ 繧ｳ繝ｳ繝應ｸ
+ }
+ internal enum E蛻､螳壻ｽ咲ｽｮ
+ {
+ 讓呎ｺ = 0,
+ Lower,
+ MAX
+ }
+ internal enum E蛻､螳夊｡ｨ遉ｺ蜆ｪ蜈亥ｺｦ
+ {
+ Chip繧医ｊ荳,
+ Chip繧医ｊ荳
+ }
+ internal enum EAVI遞ｮ蛻･
+ {
+ Unknown,
+ AVI,
+ AVIPAN
+ }
+ internal enum EBGA遞ｮ蛻･
+ {
+ Unknown,
+ BMP,
+ BMPTEX,
+ BGA,
+ BGAPAN
+ }
+ internal enum EFIFO繝｢繝ｼ繝
+ {
+ 繝輔ぉ繝ｼ繝峨う繝ｳ,
+ 繝輔ぉ繝ｼ繝峨い繧ｦ繝
+ }
+ internal enum E繝ｬ繝ｼ繝ｳ
+ {
+ LC = 0,
+ HH,
+ SD,
+ BD,
+ HT,
+ LT,
+ FT,
+ CY,
+ LP,
+ RD, // 蟆譚･縺ｮ迢ｬ遶九Ξ繝ｼ繝ｳ蛹/迢ｬ遶帰UTO險ｭ螳壹ｒ隕玖ｶ翫＠縺ｦ霑ｽ蜉
+ LBD = 10,
+ Guitar, // AUTO繝ｬ繝ｼ繝ｳ蛻､螳壹ｒ螳ｹ譏薙↓縺吶ｋ縺溘ａ縲∽ｾｿ螳應ｸ雁ｮ夂ｾｩ縺励※縺翫￥(譛ｪ菴ｿ逕ｨ)
+ Bass, // (譛ｪ菴ｿ逕ｨ)
+ GtR,
+ GtG,
+ GtB,
+ GtPick,
+ GtW,
+ BsR,
+ BsG,
+ BsB,
+ BsPick,
+ BsW,
+ MAX, // 隕∫ｴ謨ｰ蜿門ｾ励ｮ縺溘ａ縺ｮ螳夂ｾｩ ("BGM"縺ｯ菴ｿ繧上↑縺蜑肴署縺ｧ)
+ BGM
+ }
+ internal enum E繝ｬ繝ｼ繝ｳ謨ｰ
+ {
+ 迚ｩ逅 = 8, // LC, HH, SD, BD, HT, LT, FT, CY
+ 隲也炊 = 10, // LC, HO, HC, SD, BD, HT, LT, FT, RC, RD
+ DTXG迚ｩ逅 = 10, // LC, HH, LP, SD, BD, HT, LT, FT, CY, RD
+ DTXG隲也炊 = 12 // LC, HO, HC, LP, LB, SD, BD, HT, LT, FT, CY, RD
+ }
+ internal enum E繝ｭ繧ｰ蜃ｺ蜉
+ {
+ OFF,
+ ON騾壼ｸｸ,
+ ON隧ｳ邏ｰ縺ゅｊ
+ }
+ internal enum E貍泌･冗判髱｢縺ｮ謌ｻ繧雁､
+ {
+ 邯咏ｶ,
+ 貍泌･丈ｸｭ譁ｭ,
+ 繧ｹ繝繝ｼ繧ｸ螟ｱ謨,
+ 繧ｹ繝繝ｼ繧ｸ繧ｯ繝ｪ繧｢,
+ 蜀崎ｪｭ霎ｼ_蜀肴ｼ泌･,
+ 蜀肴ｼ泌･
+ }
+ internal enum E譖ｲ隱ｭ霎ｼ逕ｻ髱｢縺ｮ謌ｻ繧雁､
+ {
+ 邯咏ｶ = 0,
+ 隱ｭ霎ｼ螳御ｺ,
+ 隱ｭ霎ｼ荳ｭ豁｢
+ }
+
+ public enum ENoteState
+ {
+ none,
+ wait,
+ perfect,
+ grade,
+ bad
+ }
+
+ public enum E騾｣謇鉄tate
+ {
+ none,
+ roll,
+ rollB,
+ balloon,
+ potato
+ }
+
+ public enum E繧ｹ繝繝ｫ繧ｹ繝｢繝ｼ繝
+ {
+ OFF = 0,
+ DORON = 1,
+ STEALTH = 2
+ }
+
+ ///
+ /// 騾乗弱メ繝繝励ｮ遞ｮ鬘
+ ///
+ public enum EInvisible
+ {
+ OFF, // 繝√ャ繝励ｒ騾乗主喧縺励↑縺
+ SEMI, // Poor/Miss譎ゅ□縺代∽ｸ譎ら噪縺ｫ騾乗手ｧ｣髯､縺吶ｋ
+ FULL // 繝√ャ繝励ｒ蟶ｸ縺ｫ騾乗主喧縺吶ｋ
+ }
+
+ ///
+ /// Drum/Guitar/Bass 縺ｮ蛟､繧呈桶縺豎守畑縺ｮ讒矩菴薙
+ ///
+ /// 蛟､縺ｮ蝙九
+ [Serializable]
+ [StructLayout( LayoutKind.Sequential )]
+ public struct STDGBVALUE // index縺ｯE讌ｽ蝎ｨ繝代ｼ繝医→荳閾ｴ縺輔○繧九％縺ｨ
+ {
+ public T Drums;
+ public T Guitar;
+ public T Bass;
+ public T Taiko;
+ public T Unknown;
+ public T this[ int index ]
+ {
+ get
+ {
+ switch( index )
+ {
+ case (int) E讌ｽ蝎ｨ繝代ｼ繝.DRUMS:
+ return this.Drums;
+
+ case (int) E讌ｽ蝎ｨ繝代ｼ繝.GUITAR:
+ return this.Guitar;
+
+ case (int) E讌ｽ蝎ｨ繝代ｼ繝.BASS:
+ return this.Bass;
+
+ case (int) E讌ｽ蝎ｨ繝代ｼ繝.TAIKO:
+ return this.Taiko;
+
+ case (int) E讌ｽ蝎ｨ繝代ｼ繝.UNKNOWN:
+ return this.Unknown;
+ }
+ throw new IndexOutOfRangeException();
+ }
+ set
+ {
+ switch( index )
+ {
+ case (int) E讌ｽ蝎ｨ繝代ｼ繝.DRUMS:
+ this.Drums = value;
+ return;
+
+ case (int) E讌ｽ蝎ｨ繝代ｼ繝.GUITAR:
+ this.Guitar = value;
+ return;
+
+ case (int) E讌ｽ蝎ｨ繝代ｼ繝.BASS:
+ this.Bass = value;
+ return;
+
+ case (int) E讌ｽ蝎ｨ繝代ｼ繝.TAIKO:
+ this.Taiko = value;
+ return;
+
+ case (int) E讌ｽ蝎ｨ繝代ｼ繝.UNKNOWN:
+ this.Unknown = value;
+ return;
+ }
+ throw new IndexOutOfRangeException();
+ }
+ }
+ }
+
+ ///
+ /// 繝ｬ繝ｼ繝ｳ縺ｮ蛟､繧呈桶縺豎守畑縺ｮ讒矩菴薙ょ玲嫌蝙"E繝峨Λ繝繝ｬ繝ｼ繝ｳ"縺ｫ貅匁侠縲
+ ///
+ /// 蛟､縺ｮ蝙九
+ [StructLayout( LayoutKind.Sequential )]
+ public struct STLANEVALUE
+ {
+ public T LC;
+ public T HH;
+ public T SD;
+ public T LP;
+ public T LBD;
+ public T BD;
+ public T HT;
+ public T LT;
+ public T FT;
+ public T CY;
+ public T RD;
+ public T Guitar;
+ public T Bass;
+ public T GtR;
+ public T GtG;
+ public T GtB;
+ public T GtPick;
+ public T GtW;
+ public T BsR;
+ public T BsG;
+ public T BsB;
+ public T BsPick;
+ public T BsW;
+ public T BGM;
+
+ public T this[ int index ]
+ {
+ get
+ {
+ switch ( index )
+ {
+ case (int) E繝ｬ繝ｼ繝ｳ.LC:
+ return this.LC;
+ case (int) E繝ｬ繝ｼ繝ｳ.HH:
+ return this.HH;
+ case (int) E繝ｬ繝ｼ繝ｳ.SD:
+ return this.SD;
+ case (int) E繝ｬ繝ｼ繝ｳ.LP:
+ return this.LP;
+ case (int) E繝ｬ繝ｼ繝ｳ.LBD:
+ return this.LBD;
+ case (int) E繝ｬ繝ｼ繝ｳ.BD:
+ return this.BD;
+ case (int) E繝ｬ繝ｼ繝ｳ.HT:
+ return this.HT;
+ case (int) E繝ｬ繝ｼ繝ｳ.LT:
+ return this.LT;
+ case (int) E繝ｬ繝ｼ繝ｳ.FT:
+ return this.FT;
+ case (int) E繝ｬ繝ｼ繝ｳ.CY:
+ return this.CY;
+ case (int) E繝ｬ繝ｼ繝ｳ.RD:
+ return this.RD;
+ case (int) E繝ｬ繝ｼ繝ｳ.Guitar:
+ return this.Guitar;
+ case (int) E繝ｬ繝ｼ繝ｳ.Bass:
+ return this.Bass;
+ case (int) E繝ｬ繝ｼ繝ｳ.GtR:
+ return this.GtR;
+ case (int) E繝ｬ繝ｼ繝ｳ.GtG:
+ return this.GtG;
+ case (int) E繝ｬ繝ｼ繝ｳ.GtB:
+ return this.GtB;
+ case (int) E繝ｬ繝ｼ繝ｳ.GtPick:
+ return this.GtPick;
+ case (int) E繝ｬ繝ｼ繝ｳ.GtW:
+ return this.GtW;
+ case (int) E繝ｬ繝ｼ繝ｳ.BsR:
+ return this.BsR;
+ case (int) E繝ｬ繝ｼ繝ｳ.BsG:
+ return this.BsG;
+ case (int) E繝ｬ繝ｼ繝ｳ.BsB:
+ return this.BsB;
+ case (int) E繝ｬ繝ｼ繝ｳ.BsPick:
+ return this.BsPick;
+ case (int) E繝ｬ繝ｼ繝ｳ.BsW:
+ return this.BsW;
+ }
+ throw new IndexOutOfRangeException();
+ }
+ set
+ {
+ switch ( index )
+ {
+ case (int) E繝ｬ繝ｼ繝ｳ.LC:
+ this.LC = value;
+ return;
+ case (int) E繝ｬ繝ｼ繝ｳ.HH:
+ this.HH = value;
+ return;
+ case (int) E繝ｬ繝ｼ繝ｳ.SD:
+ this.SD = value;
+ return;
+ case (int) E繝ｬ繝ｼ繝ｳ.LP:
+ this.LP = value;
+ return;
+ case (int) E繝ｬ繝ｼ繝ｳ.LBD:
+ this.LBD = value;
+ return;
+ case (int) E繝ｬ繝ｼ繝ｳ.BD:
+ this.BD = value;
+ return;
+ case (int) E繝ｬ繝ｼ繝ｳ.HT:
+ this.HT = value;
+ return;
+ case (int) E繝ｬ繝ｼ繝ｳ.LT:
+ this.LT = value;
+ return;
+ case (int) E繝ｬ繝ｼ繝ｳ.FT:
+ this.FT = value;
+ return;
+ case (int) E繝ｬ繝ｼ繝ｳ.CY:
+ this.CY = value;
+ return;
+ case (int) E繝ｬ繝ｼ繝ｳ.RD:
+ this.RD = value;
+ return;
+ case (int) E繝ｬ繝ｼ繝ｳ.Guitar:
+ this.Guitar = value;
+ return;
+ case (int) E繝ｬ繝ｼ繝ｳ.Bass:
+ this.Bass = value;
+ return;
+ case (int) E繝ｬ繝ｼ繝ｳ.GtR:
+ this.GtR = value;
+ return;
+ case (int) E繝ｬ繝ｼ繝ｳ.GtG:
+ this.GtG = value;
+ return;
+ case (int) E繝ｬ繝ｼ繝ｳ.GtB:
+ this.GtB = value;
+ return;
+ case (int) E繝ｬ繝ｼ繝ｳ.GtPick:
+ this.GtPick = value;
+ return;
+ case (int) E繝ｬ繝ｼ繝ｳ.GtW:
+ this.GtW = value;
+ return;
+ case (int) E繝ｬ繝ｼ繝ｳ.BsR:
+ this.BsR = value;
+ return;
+ case (int) E繝ｬ繝ｼ繝ｳ.BsG:
+ this.BsG = value;
+ return;
+ case (int) E繝ｬ繝ｼ繝ｳ.BsB:
+ this.BsB = value;
+ return;
+ case (int) E繝ｬ繝ｼ繝ｳ.BsPick:
+ this.BsPick = value;
+ return;
+ case (int) E繝ｬ繝ｼ繝ｳ.BsW:
+ this.BsW = value;
+ return;
+ }
+ throw new IndexOutOfRangeException();
+ }
+ }
+ }
+
+
+ [StructLayout( LayoutKind.Sequential )]
+ public struct STAUTOPLAY // E繝ｬ繝ｼ繝ｳ縺ｨindex繧剃ｸ閾ｴ縺輔○繧九％縺ｨ
+ {
+ public bool LC; // 0
+ public bool HH; // 1
+ public bool SD; // 2
+ public bool BD; // 3
+ public bool HT; // 4
+ public bool LT; // 5
+ public bool FT; // 6
+ public bool CY; // 7
+ public bool LP;
+ public bool RD; // 8
+ public bool LBD;
+ public bool Guitar; // 9 (not used)
+ public bool Bass; // 10 (not used)
+ public bool GtR; // 11
+ public bool GtG; // 12
+ public bool GtB; // 13
+ public bool GtPick; // 14
+ public bool GtW; // 15
+ public bool BsR; // 16
+ public bool BsG; // 17
+ public bool BsB; // 18
+ public bool BsPick; // 19
+ public bool BsW; // 20
+ public bool this[ int index ]
+ {
+ get
+ {
+ switch ( index )
+ {
+ case (int) E繝ｬ繝ｼ繝ｳ.LC:
+ return this.LC;
+ case (int) E繝ｬ繝ｼ繝ｳ.HH:
+ return this.HH;
+ case (int) E繝ｬ繝ｼ繝ｳ.SD:
+ return this.SD;
+ case (int) E繝ｬ繝ｼ繝ｳ.BD:
+ return this.BD;
+ case (int) E繝ｬ繝ｼ繝ｳ.HT:
+ return this.HT;
+ case (int) E繝ｬ繝ｼ繝ｳ.LT:
+ return this.LT;
+ case (int) E繝ｬ繝ｼ繝ｳ.FT:
+ return this.FT;
+ case (int) E繝ｬ繝ｼ繝ｳ.CY:
+ return this.CY;
+ case (int) E繝ｬ繝ｼ繝ｳ.LP:
+ return this.LP;
+ case (int) E繝ｬ繝ｼ繝ｳ.RD:
+ return this.RD;
+ case (int) E繝ｬ繝ｼ繝ｳ.LBD:
+ return this.LBD;
+ case (int) E繝ｬ繝ｼ繝ｳ.Guitar:
+ if ( !this.GtR ) return false;
+ if ( !this.GtG ) return false;
+ if ( !this.GtB ) return false;
+ if ( !this.GtPick ) return false;
+ if ( !this.GtW ) return false;
+ return true;
+ case (int) E繝ｬ繝ｼ繝ｳ.Bass:
+ if ( !this.BsR ) return false;
+ if ( !this.BsG ) return false;
+ if ( !this.BsB) return false;
+ if ( !this.BsPick ) return false;
+ if ( !this.BsW ) return false;
+ return true;
+ case (int) E繝ｬ繝ｼ繝ｳ.GtR:
+ return this.GtR;
+ case (int) E繝ｬ繝ｼ繝ｳ.GtG:
+ return this.GtG;
+ case (int) E繝ｬ繝ｼ繝ｳ.GtB:
+ return this.GtB;
+ case (int) E繝ｬ繝ｼ繝ｳ.GtPick:
+ return this.GtPick;
+ case (int) E繝ｬ繝ｼ繝ｳ.GtW:
+ return this.GtW;
+ case (int) E繝ｬ繝ｼ繝ｳ.BsR:
+ return this.BsR;
+ case (int) E繝ｬ繝ｼ繝ｳ.BsG:
+ return this.BsG;
+ case (int) E繝ｬ繝ｼ繝ｳ.BsB:
+ return this.BsB;
+ case (int) E繝ｬ繝ｼ繝ｳ.BsPick:
+ return this.BsPick;
+ case (int) E繝ｬ繝ｼ繝ｳ.BsW:
+ return this.BsW;
+ }
+ throw new IndexOutOfRangeException();
+ }
+ set
+ {
+ switch ( index )
+ {
+ case (int) E繝ｬ繝ｼ繝ｳ.LC:
+ this.LC = value;
+ return;
+ case (int) E繝ｬ繝ｼ繝ｳ.HH:
+ this.HH = value;
+ return;
+ case (int) E繝ｬ繝ｼ繝ｳ.SD:
+ this.SD = value;
+ return;
+ case (int) E繝ｬ繝ｼ繝ｳ.BD:
+ this.BD = value;
+ return;
+ case (int) E繝ｬ繝ｼ繝ｳ.HT:
+ this.HT = value;
+ return;
+ case (int) E繝ｬ繝ｼ繝ｳ.LT:
+ this.LT = value;
+ return;
+ case (int) E繝ｬ繝ｼ繝ｳ.FT:
+ this.FT = value;
+ return;
+ case (int) E繝ｬ繝ｼ繝ｳ.CY:
+ this.CY = value;
+ return;
+ case (int) E繝ｬ繝ｼ繝ｳ.LP:
+ this.LP = value;
+ return;
+ case (int) E繝ｬ繝ｼ繝ｳ.RD:
+ this.RD = value;
+ return;
+ case (int) E繝ｬ繝ｼ繝ｳ.LBD:
+ this.LBD = value;
+ return;
+ case (int) E繝ｬ繝ｼ繝ｳ.Guitar:
+ this.GtR = this.GtG = this.GtB = this.GtPick = this.GtW = value;
+ return;
+ case (int) E繝ｬ繝ｼ繝ｳ.Bass:
+ this.BsR = this.BsG = this.BsB = this.BsPick = this.BsW = value;
+ return;
+ case (int) E繝ｬ繝ｼ繝ｳ.GtR:
+ this.GtR = value;
+ return;
+ case (int) E繝ｬ繝ｼ繝ｳ.GtG:
+ this.GtG = value;
+ return;
+ case (int) E繝ｬ繝ｼ繝ｳ.GtB:
+ this.GtB = value;
+ return;
+ case (int) E繝ｬ繝ｼ繝ｳ.GtPick:
+ this.GtPick = value;
+ return;
+ case (int) E繝ｬ繝ｼ繝ｳ.GtW:
+ this.GtW = value;
+ return;
+ case (int) E繝ｬ繝ｼ繝ｳ.BsR:
+ this.BsR = value;
+ return;
+ case (int) E繝ｬ繝ｼ繝ｳ.BsG:
+ this.BsG = value;
+ return;
+ case (int) E繝ｬ繝ｼ繝ｳ.BsB:
+ this.BsB = value;
+ return;
+ case (int) E繝ｬ繝ｼ繝ｳ.BsPick:
+ this.BsPick = value;
+ return;
+ case (int) E繝ｬ繝ｼ繝ｳ.BsW:
+ this.BsW = value;
+ return;
+ }
+ throw new IndexOutOfRangeException();
+ }
+ }
+ }
+
+ #region[Ver.K霑ｽ蜉]
+ public enum E繝ｬ繝ｼ繝ｳ繧ｿ繧､繝
+ {
+ TypeA,
+ TypeB,
+ TypeC,
+ TypeD
+ }
+ public enum E繝溘Λ繝ｼ
+ {
+ TypeA,
+ TypeB
+ }
+ public enum EClipDispType
+ {
+ 閭梧勹縺ｮ縺ｿ = 1,
+ 繧ｦ繧｣繝ｳ繝峨え縺ｮ縺ｿ = 2,
+ 荳｡譁ｹ = 3,
+ OFF = 0
+ }
+ #endregion
+
+ internal class C螳壽焚
+ {
+ }
+}
diff --git a/TJAPlayer3/Common/C譁蟄励さ繝ｳ繧ｽ繝ｼ繝ｫ.cs b/TJAPlayer3/Common/C譁蟄励さ繝ｳ繧ｽ繝ｼ繝ｫ.cs
new file mode 100644
index 00000000..262ee656
--- /dev/null
+++ b/TJAPlayer3/Common/C譁蟄励さ繝ｳ繧ｽ繝ｼ繝ｫ.cs
@@ -0,0 +1,128 @@
+ｻｿusing System;
+using System.Collections.Generic;
+using System.Text;
+using System.Drawing;
+using FDK;
+
+namespace TJAPlayer3
+{
+ internal class C譁蟄励さ繝ｳ繧ｽ繝ｼ繝ｫ : CActivity
+ {
+ // 螳壽焚
+
+ public enum E繝輔か繝ｳ繝育ｨｮ蛻･
+ {
+ 逋ｽ,
+ 襍､,
+ 轣ｰ,
+ 逋ｽ邏ｰ,
+ 襍､邏ｰ,
+ 轣ｰ邏ｰ
+ }
+ public enum E驟咲ｽｮ
+ {
+ 蟾ｦ隧ｰ,
+ 荳ｭ螟ｮ,
+ 蜿ｳ隧ｰ
+ }
+
+
+ // 繝｡繧ｽ繝繝
+
+ public void tPrint( int x, int y, E繝輔か繝ｳ繝育ｨｮ蛻･ font, string str闍ｱ謨ｰ蟄玲枚蟄怜 )
+ {
+ if( !base.b豢ｻ諤ｧ蛹悶＠縺ｦ縺ｪ縺 && !string.IsNullOrEmpty( str闍ｱ謨ｰ蟄玲枚蟄怜 ) )
+ {
+ int BOL = x;
+ for( int i = 0; i < str闍ｱ謨ｰ蟄玲枚蟄怜.Length; i++ )
+ {
+ char ch = str闍ｱ謨ｰ蟄玲枚蟄怜夕 i ];
+ if( ch == '\n' )
+ {
+ x = BOL;
+ y += nFontHeight;
+ }
+ else
+ {
+ int index = str陦ｨ險伜庄閭ｽ譁蟄.IndexOf( ch );
+ if( index < 0 )
+ {
+ x += nFontWidth;
+ }
+ else
+ {
+ if( this.tx繝輔か繝ｳ繝8x16[ (int) ( (int) font / (int) E繝輔か繝ｳ繝育ｨｮ蛻･.逋ｽ邏ｰ ) ] != null )
+ {
+ this.tx繝輔か繝ｳ繝8x16[ (int) ( (int) font / (int) E繝輔か繝ｳ繝育ｨｮ蛻･.逋ｽ邏ｰ ) ].t2D謠冗判( TJAPlayer3.app.Device, x, y, this.rc譁蟄励ｮ遏ｩ蠖｢鬆伜沺[ (int) ( (int) font % (int) E繝輔か繝ｳ繝育ｨｮ蛻･.逋ｽ邏ｰ ), index ] );
+ }
+ x += nFontWidth;
+ }
+ }
+ }
+ }
+ }
+
+
+ // CActivity 螳溯｣
+
+ public override void On豢ｻ諤ｧ蛹()
+ {
+ this.rc譁蟄励ｮ遏ｩ蠖｢鬆伜沺 = new Rectangle[3, str陦ｨ險伜庄閭ｽ譁蟄.Length ];
+ for( int i = 0; i < 3; i++ )
+ {
+ for (int j = 0; j < str陦ｨ險伜庄閭ｽ譁蟄.Length; j++)
+ {
+ const int regionX = 128, regionY = 16;
+ this.rc譁蟄励ｮ遏ｩ蠖｢鬆伜沺[ i, j ].X = ( ( i / 2 ) * regionX ) + ( ( j % regionY ) * nFontWidth );
+ this.rc譁蟄励ｮ遏ｩ蠖｢鬆伜沺[ i, j ].Y = ( ( i % 2 ) * regionX ) + ( ( j / regionY ) * nFontHeight );
+ this.rc譁蟄励ｮ遏ｩ蠖｢鬆伜沺[ i, j ].Width = nFontWidth;
+ this.rc譁蟄励ｮ遏ｩ蠖｢鬆伜沺[ i, j ].Height = nFontHeight;
+ }
+ }
+ base.On豢ｻ諤ｧ蛹();
+ }
+ public override void On髱樊ｴｻ諤ｧ蛹()
+ {
+ if( this.rc譁蟄励ｮ遏ｩ蠖｢鬆伜沺 != null )
+ this.rc譁蟄励ｮ遏ｩ蠖｢鬆伜沺 = null;
+
+ base.On髱樊ｴｻ諤ｧ蛹();
+ }
+ public override void OnManaged繝ｪ繧ｽ繝ｼ繧ｹ縺ｮ菴懈()
+ {
+ if( !base.b豢ｻ諤ｧ蛹悶＠縺ｦ縺ｪ縺 )
+ {
+ this.tx繝輔か繝ｳ繝8x16[ 0 ] = TJAPlayer3.Tx.TxC(@"Console_Font.png");
+ this.tx繝輔か繝ｳ繝8x16[ 1 ] = TJAPlayer3.Tx.TxC(@"Console_Font_Small.png");
+ base.OnManaged繝ｪ繧ｽ繝ｼ繧ｹ縺ｮ菴懈();
+ }
+ }
+ public override void OnManaged繝ｪ繧ｽ繝ｼ繧ｹ縺ｮ隗｣謾ｾ()
+ {
+ if( !base.b豢ｻ諤ｧ蛹悶＠縺ｦ縺ｪ縺 )
+ {
+ for( int i = 0; i < 2; i++ )
+ {
+ if( this.tx繝輔か繝ｳ繝8x16[ i ] != null )
+ {
+ this.tx繝輔か繝ｳ繝8x16[ i ].Dispose();
+ this.tx繝輔か繝ｳ繝8x16[ i ] = null;
+ }
+ }
+ base.OnManaged繝ｪ繧ｽ繝ｼ繧ｹ縺ｮ隗｣謾ｾ();
+ }
+ }
+
+
+ // 縺昴ｮ莉
+
+ #region [ private ]
+ //-----------------
+ private Rectangle[,] rc譁蟄励ｮ遏ｩ蠖｢鬆伜沺;
+ private const string str陦ｨ險伜庄閭ｽ譁蟄 = " !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~ ";
+ private const int nFontWidth = 8, nFontHeight = 16;
+ private CTexture[] tx繝輔か繝ｳ繝8x16 = new CTexture[ 2 ];
+ //-----------------
+ #endregion
+ }
+}
diff --git a/TJAPlayer3/Common/Discord.cs b/TJAPlayer3/Common/Discord.cs
new file mode 100644
index 00000000..d806ba8c
--- /dev/null
+++ b/TJAPlayer3/Common/Discord.cs
@@ -0,0 +1,180 @@
+ｻｿusing System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace TJAPlayer3
+{
+ public static class DiscordRpc
+ {
+ [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Auto)]
+ public delegate void ReadyCallback();
+
+ [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Auto)]
+ public delegate void DisconnectedCallback(int errorCode, string message);
+
+ [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Auto)]
+ public delegate void ErrorCallback(int errorCode, string message);
+
+ public struct EventHandlers
+ {
+ public ReadyCallback readyCallback;
+ public DisconnectedCallback disconnectedCallback;
+ public ErrorCallback errorCallback;
+ }
+
+ [Serializable, StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
+ public struct RichPresence
+ {
+ public IntPtr state;
+ public IntPtr details;
+ public long startTimestamp;
+ public long endTimestamp;
+ public IntPtr largeImageKey;
+ public IntPtr largeImageText;
+ public IntPtr smallImageKey;
+ public IntPtr smallImageText;
+ public IntPtr partyId;
+ public int partySize;
+ public int partyMax;
+ public IntPtr matchSecret;
+ public IntPtr joinSecret;
+ public IntPtr spectateSecret;
+ public bool instance;
+ }
+
+ [DllImport("discord-rpc", EntryPoint = "Discord_Initialize", CallingConvention = CallingConvention.Cdecl)]
+ public static extern void Initialize(string applicationId, ref EventHandlers handlers, bool autoRegister, string optionalSteamId);
+
+ [DllImport("discord-rpc", EntryPoint = "Discord_Shutdown", CallingConvention = CallingConvention.Cdecl)]
+ public static extern void Shutdown();
+
+ [DllImport("discord-rpc", EntryPoint = "Discord_RunCallbacks", CallingConvention = CallingConvention.Cdecl)]
+ public static extern void RunCallbacks();
+
+ [DllImport("discord-rpc", EntryPoint = "Discord_UpdatePresence", CallingConvention = CallingConvention.Cdecl)]
+ public static extern void UpdatePresence(ref RichPresence presence);
+
+ [DllImport("discord-rpc", EntryPoint = "Discord_ClearPresence", CallingConvention = CallingConvention.Cdecl)]
+ public static extern void ClearPresence();
+
+ [DllImport("discord-rpc", EntryPoint = "Discord_UpdateHandlers", CallingConvention = CallingConvention.Cdecl)]
+ public static extern void UpdateHandlers(ref EventHandlers handlers);
+ }
+
+ public static class Discord
+ {
+
+ private static readonly List _buffers = new List(10);
+
+ ///
+ /// Discord Rich Presence縺ｮ蛻晄悄蛹悶ｒ縺励∪縺吶
+ ///
+ /// Discord API縺ｮ繧ｯ繝ｩ繧､繧｢繝ｳ繝ID縲
+ public static void Initialize(string clientId)
+ {
+ var handlers = new DiscordRpc.EventHandlers();
+ handlers.readyCallback = ReadyCallback;
+ handlers.disconnectedCallback += DisconnectedCallback;
+ handlers.errorCallback += ErrorCallback;
+
+ DiscordRpc.Initialize(clientId, ref handlers, true, null);
+
+ }
+
+ ///
+ /// Discord Rich Presence縺ｮ譖ｴ譁ｰ繧偵＠縺ｾ縺吶
+ ///
+ /// 迴ｾ蝨ｨ縺ｮ隱ｬ譏弱
+ /// 迴ｾ蝨ｨ縺ｮ迥ｶ諷九
+ /// 髢句ｧ区凾髢(Unix譎る俣)
+ /// 邨ゆｺ譎る俣(Unix譎る俣)
+ /// 蟆上＆縺ｪ繧｢繧､繧ｳ繝ｳ逕ｨ繧ｭ繝ｼ縲
+ /// 蟆上＆縺ｪ繧｢繧､繧ｳ繝ｳ縺ｮ繝繝ｼ繝ｫ繝√ャ繝励↓陦ｨ遉ｺ縺吶ｋ繝繧ｭ繧ｹ繝医
+ public static void UpdatePresence(string details, string state, long startTimeStamp = 0, long endTimeStamp = 0, string smallImageKey = null, string smallImageText = null)
+ {
+ var presence = new DiscordRpc.RichPresence();
+ presence.details = StrToPtr(details);
+ presence.state = StrToPtr(state);
+
+ if (startTimeStamp != 0) presence.startTimestamp = startTimeStamp;
+ if (endTimeStamp != 0) presence.endTimestamp = endTimeStamp;
+ presence.largeImageKey = StrToPtr("rewrite");
+ presence.largeImageText = StrToPtr("Ver." + TJAPlayer3.VERSION);
+ if (!string.IsNullOrEmpty(smallImageKey)) presence.smallImageKey = StrToPtr(smallImageKey);
+ if (!string.IsNullOrEmpty(smallImageText)) presence.smallImageText = StrToPtr(smallImageText);
+
+ DiscordRpc.UpdatePresence(ref presence);
+ FreeMem();
+ }
+
+ ///
+ /// Discord Rich Presence縺ｮ繧ｷ繝｣繝繝医ム繧ｦ繝ｳ繧定｡後＞縺ｾ縺吶
+ /// 邨ゆｺ譎ゅ↓蠢縺壼他縺ｳ蜃ｺ縺吝ｿ隕√′縺ゅｊ縺ｾ縺吶
+ ///
+ public static void Shutdown()
+ {
+ DiscordRpc.Shutdown();
+ Trace.TraceInformation("[Discord] Shutdowned.");
+ }
+
+ private static void ReadyCallback()
+ {
+ Trace.TraceInformation("[Discord] Ready.");
+ }
+
+ ///
+ /// Discord縺ｨ縺ｮ謗･邯壹′蛻譁ｭ縺輔ｌ縺溷ｴ蜷亥他縺ｳ蜃ｺ縺輔ｌ縺ｾ縺吶
+ ///
+ /// 繧ｨ繝ｩ繝ｼ繧ｳ繝ｼ繝峨
+ /// 繧ｨ繝ｩ繝ｼ繝｡繝繧ｻ繝ｼ繧ｸ縲
+ private static void DisconnectedCallback(int errorCode, string message)
+ {
+ Trace.TraceInformation("[Discord] Disconnected.");
+ }
+
+ ///
+ /// Discord縺ｨ縺ｮ謗･邯壹〒繧ｨ繝ｩ繝ｼ縺檎匱逕溘＠縺溷ｴ蜷亥他縺ｳ蜃ｺ縺輔ｌ縺ｾ縺吶
+ ///
+ /// 繧ｨ繝ｩ繝ｼ繧ｳ繝ｼ繝峨
+ /// 繧ｨ繝ｩ繝ｼ繝｡繝繧ｻ繝ｼ繧ｸ縲
+ private static void ErrorCallback(int errorCode, string message)
+ {
+ Trace.TraceInformation("[Discord] Error occured: {0} {1}", errorCode, message);
+ }
+
+ // string蝙九ｮ譁蟄怜励ｒ繝昴う繝ｳ繧ｿ縺ｧ蜿らｧ縺輔○繧九ｈ縺縺ｫ縺吶ｋ縺溘ａ縺ｮ繝｡繧ｽ繝繝峨
+ private static IntPtr StrToPtr(string input)
+ {
+ if (string.IsNullOrEmpty(input)) return IntPtr.Zero;
+ var convbytecnt = Encoding.UTF8.GetByteCount(input);
+ var buffer = Marshal.AllocHGlobal(convbytecnt + 1);
+ for (int i = 0; i < convbytecnt + 1; i++)
+ {
+ Marshal.WriteByte(buffer, i, 0);
+ }
+ _buffers.Add(buffer);
+ Marshal.Copy(Encoding.UTF8.GetBytes(input), 0, buffer, convbytecnt);
+ return buffer;
+ }
+
+ internal static void FreeMem()
+ {
+ for (var i = _buffers.Count - 1; i >= 0; i--)
+ {
+ Marshal.FreeHGlobal(_buffers[i]);
+ _buffers.RemoveAt(i);
+ }
+ }
+
+ ///
+ /// 迴ｾ蝨ｨ縺ｮUnix譎る俣繧値ong蝙九〒霑斐＠縺ｾ縺吶
+ ///
+ /// Unix譎る俣縲
+ public static long GetUnixTime()
+ {
+ return (long)(DateTime.UtcNow - new DateTime(1970, 1, 1)).Ticks / 10000000;
+ }
+ }
+}
diff --git a/TJAPlayer3/Common/Easing.cs b/TJAPlayer3/Common/Easing.cs
new file mode 100644
index 00000000..dc863fea
--- /dev/null
+++ b/TJAPlayer3/Common/Easing.cs
@@ -0,0 +1,117 @@
+ｻｿusing System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using TJAPlayer3;
+using FDK;
+
+namespace TJAPlayer3
+{
+ class Easing
+ {
+ public int EaseIn(CCounter counter, int startPoint, int endPoint, CalcType type)
+ {
+ StartPoint = startPoint;
+ EndPoint = endPoint;
+ Sa = EndPoint - StartPoint;
+ TimeMs = (int)counter.n邨ゆｺ蛟､;
+ Type = type;
+ CounterValue = counter.n迴ｾ蝨ｨ縺ｮ蛟､;
+
+ switch (Type)
+ {
+ case CalcType.Quadratic: //Quadratic
+ CounterValue /= TimeMs;
+ Value = Sa * CounterValue * CounterValue + StartPoint;
+ break;
+ case CalcType.Cubic: //Cubic
+ CounterValue /= TimeMs;
+ Value = Sa * CounterValue * CounterValue * CounterValue + StartPoint;
+ break;
+ case CalcType.Quartic: //Quartic
+ CounterValue /= TimeMs;
+ Value = Sa * CounterValue * CounterValue * CounterValue * CounterValue + StartPoint;
+ break;
+ case CalcType.Quintic: //Quintic
+ CounterValue /= TimeMs;
+ Value = Sa * CounterValue * CounterValue * CounterValue * CounterValue * CounterValue + StartPoint;
+ break;
+ case CalcType.Sinusoidal: //Sinusoidal
+ Value = -Sa * Math.Cos(CounterValue / TimeMs * (Math.PI / 2)) + Sa + StartPoint;
+ break;
+ case CalcType.Exponential: //Exponential
+ Value = Sa * Math.Pow(2, 10 * (CounterValue / TimeMs - 1)) + StartPoint;
+ break;
+ case CalcType.Circular: //Circular
+ CounterValue /= TimeMs;
+ Value = -Sa * (Math.Sqrt(1 - CounterValue * CounterValue) - 1) + StartPoint;
+ break;
+ }
+
+ return (int)Value;
+ }
+ public int EaseOut(CCounter counter, int startPoint, int endPoint, CalcType type)
+ {
+ StartPoint = startPoint;
+ EndPoint = endPoint;
+ Sa = EndPoint - StartPoint;
+ TimeMs = (int)counter.n邨ゆｺ蛟､;
+ Type = type;
+ CounterValue = counter.n迴ｾ蝨ｨ縺ｮ蛟､;
+
+ switch (Type)
+ {
+ case CalcType.Quadratic: //Quadratic
+ CounterValue /= TimeMs;
+ Value = -Sa * CounterValue * (CounterValue - 2) + StartPoint;
+ break;
+ case CalcType.Cubic: //Cubic
+ CounterValue /= TimeMs;
+ CounterValue--;
+ Value = Sa * (CounterValue * CounterValue * CounterValue + 1) + StartPoint;
+ break;
+ case CalcType.Quartic: //Quartic
+ CounterValue /= TimeMs;
+ CounterValue--;
+ Value = -Sa * (CounterValue * CounterValue * CounterValue * CounterValue - 1) + StartPoint;
+ break;
+ case CalcType.Quintic: //Quintic
+ CounterValue /= TimeMs;
+ CounterValue--;
+ Value = Sa * (CounterValue * CounterValue * CounterValue * CounterValue * CounterValue + 1) + StartPoint;
+ break;
+ case CalcType.Sinusoidal: //Sinusoidal
+ Value = Sa * Math.Sin(CounterValue / TimeMs * (Math.PI / 2)) + StartPoint;
+ break;
+ case CalcType.Exponential: //Exponential
+ Value = Sa * (-Math.Pow(2, -10 * CounterValue / TimeMs) + 1) + StartPoint;
+ break;
+ case CalcType.Circular: //Circular
+ CounterValue /= TimeMs;
+ CounterValue--;
+ Value = Sa * Math.Sqrt(1 - CounterValue * CounterValue) + StartPoint;
+ break;
+ }
+
+ return (int)Value;
+ }
+
+ private int StartPoint;
+ private int EndPoint;
+ private int Sa;
+ private int TimeMs;
+ private CalcType Type;
+ private double CounterValue;
+ private double Value;
+ public enum CalcType
+ {
+ Quadratic,
+ Cubic,
+ Quartic,
+ Quintic,
+ Sinusoidal,
+ Exponential,
+ Circular
+ }
+ }
+}
\ No newline at end of file
diff --git a/TJAPlayer3/Common/KeyboardSoundGroupLevelControlHandler.cs b/TJAPlayer3/Common/KeyboardSoundGroupLevelControlHandler.cs
new file mode 100644
index 00000000..10c24063
--- /dev/null
+++ b/TJAPlayer3/Common/KeyboardSoundGroupLevelControlHandler.cs
@@ -0,0 +1,63 @@
+ｻｿusing FDK;
+
+namespace TJAPlayer3
+{
+ ///
+ /// KeyboardSoundGroupLevelControlHandler is called by the song selection
+ /// and song play stages when handling keyboard input. By delegating to
+ /// this class they are able to support a centrally-managed and consistent
+ /// set of keyboard shortcuts for dynamically adjusting four sound group
+ /// levels:
+ /// - sound effect level, via Ctrl and either of the Minus or Equals keys
+ /// - voice level, via Shift and either of the Minus or Equals keys
+ /// - song preview and song playback level, via the Minus or Equals key
+ ///
+ /// When the sound group levels are adjusted in this manner, the
+ /// SoundGroupLevelController (and handlers bound to its events) ensure
+ /// that both the sound object group levels are updated and the application
+ /// configuration is updated. See ConfigIniToSoundGroupLevelControllerBinder
+ /// for more details on the latter.
+ ///
+ internal static class KeyboardSoundGroupLevelControlHandler
+ {
+ internal static void Handle(
+ IInputDevice keyboard,
+ SoundGroupLevelController soundGroupLevelController,
+ CSkin skin,
+ bool isSongPreview)
+ {
+ var isAdjustmentPositive = keyboard.b繧ｭ繝ｼ縺梧款縺輔ｌ縺((int)SlimDXKeys.Key.RightBracket);
+ if (!(isAdjustmentPositive || keyboard.b繧ｭ繝ｼ縺梧款縺輔ｌ縺((int)SlimDXKeys.Key.LeftBracket)))
+ {
+ return;
+ }
+
+ ESoundGroup soundGroup;
+ CSkin.C繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝 繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝 = null;
+
+ if (keyboard.b繧ｭ繝ｼ縺梧款縺輔ｌ縺ｦ縺繧((int)SlimDXKeys.Key.LeftControl) ||
+ keyboard.b繧ｭ繝ｼ縺梧款縺輔ｌ縺ｦ縺繧((int)SlimDXKeys.Key.RightControl))
+ {
+ soundGroup = ESoundGroup.SoundEffect;
+ 繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝 = skin.sound豎ｺ螳夐浹;
+ }
+ else if (keyboard.b繧ｭ繝ｼ縺梧款縺輔ｌ縺ｦ縺繧((int)SlimDXKeys.Key.LeftShift) ||
+ keyboard.b繧ｭ繝ｼ縺梧款縺輔ｌ縺ｦ縺繧((int)SlimDXKeys.Key.RightShift))
+ {
+ soundGroup = ESoundGroup.Voice;
+ 繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝 = skin.sound繧ｲ繝ｼ繝髢句ｧ矩浹;
+ }
+ else if (isSongPreview)
+ {
+ soundGroup = ESoundGroup.SongPlayback;
+ }
+ else
+ {
+ soundGroup = ESoundGroup.SongPlayback;
+ }
+
+ soundGroupLevelController.AdjustLevel(soundGroup, isAdjustmentPositive);
+ 繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝?.t蜀咲函縺吶ｋ();
+ }
+ }
+}
diff --git a/TJAPlayer3/Common/NamePlateConfig.cs b/TJAPlayer3/Common/NamePlateConfig.cs
new file mode 100644
index 00000000..bd26bf80
--- /dev/null
+++ b/TJAPlayer3/Common/NamePlateConfig.cs
@@ -0,0 +1,35 @@
+ｻｿusing System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Windows.Forms;
+
+namespace TJAPlayer3
+{
+ class NamePlateConfig
+ {
+ public void tNamePlateConfig()
+ {
+ if (!File.Exists("NamePlate.json"))
+ ConfigManager.SaveConfig(data, "NamePlate.json");
+
+ data = ConfigManager.GetConfig(@"NamePlate.json");
+ }
+
+ public class Data
+ {
+ public string[] Name = { "縺ｩ繧薙■繧繧", "縺九▲縺｡繧繧" };
+ public string[] Title = { "縺ｩ繧薙■繧繧薙〒縺吶ｈｼ", "縺九▲縺｡繧繧薙〒縺吶ｈｼ" };
+ public string[] Dan = { "驕比ｺｺ", "驕比ｺｺ" };
+
+ public bool[] DanGold = { false, true };
+
+ public int[] DanType = { 1, 2 };
+ public int[] TitleType = { 1, 2 };
+ }
+
+ public Data data = new Data();
+ }
+}
diff --git a/TJAPlayer3/Common/Program.cs b/TJAPlayer3/Common/Program.cs
new file mode 100644
index 00000000..34237244
--- /dev/null
+++ b/TJAPlayer3/Common/Program.cs
@@ -0,0 +1,244 @@
+ｻｿusing System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Text;
+using System.Runtime.InteropServices;
+using System.Threading;
+using System.Diagnostics;
+using System.Windows.Forms;
+using System.IO;
+using FDK;
+using System.Reflection;
+
+namespace TJAPlayer3
+{
+ internal class Program
+ {
+ #region [ 莠碁崎ｵｷ蜍輔メ繧ｧ繝繧ｯ縲．LL蟄伜惠繝√ぉ繝繧ｯ ]
+ //-----------------------------
+ private static Mutex mutex莠碁崎ｵｷ蜍暮亟豁｢逕ｨ;
+
+ private static bool tDLL縺ｮ蟄伜惠繝√ぉ繝繧ｯ( string strDll蜷, string str蟄伜惠縺励↑縺縺ｨ縺阪↓陦ｨ遉ｺ縺吶ｋ繧ｨ繝ｩ繝ｼ譁蟄怜曜p, string str蟄伜惠縺励↑縺縺ｨ縺阪↓陦ｨ遉ｺ縺吶ｋ繧ｨ繝ｩ繝ｼ譁蟄怜容n, bool bLoadDllCheck )
+ {
+ string str蟄伜惠縺励↑縺縺ｨ縺阪↓陦ｨ遉ｺ縺吶ｋ繧ｨ繝ｩ繝ｼ譁蟄怜 = ( CultureInfo.CurrentUICulture.TwoLetterISOLanguageName == "ja" ) ?
+ str蟄伜惠縺励↑縺縺ｨ縺阪↓陦ｨ遉ｺ縺吶ｋ繧ｨ繝ｩ繝ｼ譁蟄怜曜p : str蟄伜惠縺励↑縺縺ｨ縺阪↓陦ｨ遉ｺ縺吶ｋ繧ｨ繝ｩ繝ｼ譁蟄怜容n;
+ if ( bLoadDllCheck )
+ {
+ IntPtr hModule = LoadLibrary( strDll蜷 ); // 螳滄圀縺ｫLoadDll()縺励※繝√ぉ繝繧ｯ縺吶ｋ
+ if ( hModule == IntPtr.Zero )
+ {
+ MessageBox.Show( str蟄伜惠縺励↑縺縺ｨ縺阪↓陦ｨ遉ｺ縺吶ｋ繧ｨ繝ｩ繝ｼ譁蟄怜, "DTXMania runtime error", MessageBoxButtons.OK, MessageBoxIcon.Hand );
+ return false;
+ }
+ FreeLibrary( hModule );
+ }
+ else
+ { // 蜊倡ｴ斐↓繝輔ぃ繧､繝ｫ縺ｮ蟄伜惠譛臥┌繧偵メ繧ｧ繝繧ｯ縺吶ｋ縺縺 (繝励Ο繧ｸ繧ｧ繧ｯ繝医〒縲悟盾辣ｧ縲阪＠縺ｦ縺縺溘ｊ縲√い繝ｳ繝槭ロ繝ｼ繧ｸ繝峨↑DLL縺梧囓鮟吶Μ繝ｳ繧ｯ縺輔ｌ繧九ｂ縺ｮ縺ｯ縺薙■繧)
+ string path = Path.Combine( System.IO.Directory.GetCurrentDirectory(), strDll蜷 );
+ if ( !File.Exists( path ) )
+ {
+ MessageBox.Show( str蟄伜惠縺励↑縺縺ｨ縺阪↓陦ｨ遉ｺ縺吶ｋ繧ｨ繝ｩ繝ｼ譁蟄怜, "DTXMania runtime error", MessageBoxButtons.OK, MessageBoxIcon.Hand );
+ return false;
+ }
+ }
+ return true;
+ }
+ private static bool tDLL縺ｮ蟄伜惠繝√ぉ繝繧ｯ( string strDll蜷, string str蟄伜惠縺励↑縺縺ｨ縺阪↓陦ｨ遉ｺ縺吶ｋ繧ｨ繝ｩ繝ｼ譁蟄怜曜p, string str蟄伜惠縺励↑縺縺ｨ縺阪↓陦ｨ遉ｺ縺吶ｋ繧ｨ繝ｩ繝ｼ譁蟄怜容n )
+ {
+ return true;
+ //return tDLL縺ｮ蟄伜惠繝√ぉ繝繧ｯ( strDll蜷, str蟄伜惠縺励↑縺縺ｨ縺阪↓陦ｨ遉ｺ縺吶ｋ繧ｨ繝ｩ繝ｼ譁蟄怜曜p, str蟄伜惠縺励↑縺縺ｨ縺阪↓陦ｨ遉ｺ縺吶ｋ繧ｨ繝ｩ繝ｼ譁蟄怜容n, false );
+ }
+
+ #region [DllImport]
+ [DllImport( "kernel32", CharSet = CharSet.Unicode, SetLastError = true )]
+ internal static extern void FreeLibrary( IntPtr hModule );
+
+ [DllImport( "kernel32", CharSet = CharSet.Unicode, SetLastError = true )]
+ internal static extern IntPtr LoadLibrary( string lpFileName );
+ #endregion
+ //-----------------------------
+ #endregion
+
+ [STAThread]
+ static void Main()
+ {
+ mutex莠碁崎ｵｷ蜍暮亟豁｢逕ｨ = new Mutex( false, "DTXManiaMutex" );
+
+ if ( mutex莠碁崎ｵｷ蜍暮亟豁｢逕ｨ.WaitOne( 0, false ) )
+ {
+ string newLine = Environment.NewLine;
+ bool bDLLnotfound = false;
+
+ Trace.WriteLine( "Current Directory: " + Environment.CurrentDirectory );
+ Trace.WriteLine( "EXE縺ｮ縺ゅｋ繝輔か繝ｫ繝: " + Path.GetDirectoryName( Application.ExecutablePath ) );
+
+ Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
+
+
+ #region [DLL縺ｮ蟄伜惠繝√ぉ繝繧ｯ]
+ if ( !tDLL縺ｮ蟄伜惠繝√ぉ繝繧ｯ( "dll\\SlimDX" + TJAPlayer3.SLIMDXDLL + ".dll",
+ "SlimDX" + TJAPlayer3.SLIMDXDLL + ".dll 縺ｾ縺溘ｯ縺昴ｮ萓晏ｭ倥☆繧掬ll縺悟ｭ伜惠縺励∪縺帙ｓ縲" + newLine + "DTXMania繧偵ム繧ｦ繝ｳ繝ｭ繝ｼ繝峨＠縺ｪ縺翫＠縺ｦ縺上□縺輔＞縲",
+ "SlimDX" + TJAPlayer3.SLIMDXDLL + ".dll, or its depended DLL, is not found." + newLine + "Please download DTXMania again."
+ ) ) bDLLnotfound = true;
+ if ( !tDLL縺ｮ蟄伜惠繝√ぉ繝繧ｯ( "dll\\FDK.dll",
+ "FDK.dll 縺ｾ縺溘ｯ縺昴ｮ萓晏ｭ倥☆繧掬ll縺悟ｭ伜惠縺励∪縺帙ｓ縲" + newLine + "DTXMania繧偵ム繧ｦ繝ｳ繝ｭ繝ｼ繝峨＠縺ｪ縺翫＠縺ｦ縺上□縺輔＞縲",
+ "FDK.dll, or its depended DLL, is not found." + newLine + "Please download DTXMania again."
+ ) ) bDLLnotfound = true;
+ if ( !tDLL縺ｮ蟄伜惠繝√ぉ繝繧ｯ( "dll\\xadec.dll",
+ "xadec.dll 縺悟ｭ伜惠縺励∪縺帙ｓ縲" + newLine + "DTXMania繧偵ム繧ｦ繝ｳ繝ｭ繝ｼ繝峨＠縺ｪ縺翫＠縺ｦ縺上□縺輔＞縲",
+ "xadec.dll is not found." + newLine + "Please download DTXMania again."
+ ) ) bDLLnotfound = true;
+ if ( !tDLL縺ｮ蟄伜惠繝√ぉ繝繧ｯ( "dll\\SoundDecoder.dll",
+ "SoundDecoder.dll 縺ｾ縺溘ｯ縺昴ｮ萓晏ｭ倥☆繧掬ll縺悟ｭ伜惠縺励∪縺帙ｓ縲" + newLine + "DTXMania繧偵ム繧ｦ繝ｳ繝ｭ繝ｼ繝峨＠縺ｪ縺翫＠縺ｦ縺上□縺輔＞縲",
+ "SoundDecoder.dll, or its depended DLL, is not found." + newLine + "Please download DTXMania again."
+ ) ) bDLLnotfound = true;
+ if ( !tDLL縺ｮ蟄伜惠繝√ぉ繝繧ｯ( TJAPlayer3.D3DXDLL,
+ TJAPlayer3.D3DXDLL + " 縺悟ｭ伜惠縺励∪縺帙ｓ縲" + newLine + "DirectX Redist 繝輔か繝ｫ繝縺ｮ DXSETUP.exe 繧貞ｮ溯｡後＠縲" + newLine + "蠢隕√↑ DirectX 繝ｩ繝ｳ繧ｿ繧､繝繧偵う繝ｳ繧ｹ繝医ｼ繝ｫ縺励※縺上□縺輔＞縲",
+ TJAPlayer3.D3DXDLL + " is not found." + newLine + "Please execute DXSETUP.exe in \"DirectX Redist\" folder, to install DirectX runtimes required for DTXMania.",
+ true
+ ) ) bDLLnotfound = true;
+ if ( !tDLL縺ｮ蟄伜惠繝√ぉ繝繧ｯ( "dll\\bass.dll",
+ "bass.dll 縺悟ｭ伜惠縺励∪縺帙ｓ縲" + newLine + "DTXMania繧偵ム繧ｦ繝ｳ繝ｭ繝ｼ繝峨＠縺ｪ縺翫＠縺ｦ縺上□縺輔＞縲",
+ "baas.dll is not found." + newLine + "Please download DTXMania again."
+ ) ) bDLLnotfound = true;
+ if ( !tDLL縺ｮ蟄伜惠繝√ぉ繝繧ｯ( "dll\\Bass.Net.dll",
+ "Bass.Net.dll 縺悟ｭ伜惠縺励∪縺帙ｓ縲" + newLine + "DTXMania繧偵ム繧ｦ繝ｳ繝ｭ繝ｼ繝峨＠縺ｪ縺翫＠縺ｦ縺上□縺輔＞縲",
+ "Bass.Net.dll is not found." + newLine + "Please download DTXMania again."
+ ) ) bDLLnotfound = true;
+ if ( !tDLL縺ｮ蟄伜惠繝√ぉ繝繧ｯ( "dll\\bassmix.dll",
+ "bassmix.dll 繧定ｪｭ縺ｿ霎ｼ繧√∪縺帙ｓ縲Ｃassmix.dll 縺 bass.dll 縺悟ｭ伜惠縺励∪縺帙ｓ縲" + newLine + "DTXMania繧偵ム繧ｦ繝ｳ繝ｭ繝ｼ繝峨＠縺ｪ縺翫＠縺ｦ縺上□縺輔＞縲",
+ "bassmix.dll is not loaded. bassmix.dll or bass.dll must not exist." + newLine + "Please download DTXMania again."
+ ) ) bDLLnotfound = true;
+ if ( !tDLL縺ｮ蟄伜惠繝√ぉ繝繧ｯ( "dll\\bassasio.dll",
+ "bassasio.dll 繧定ｪｭ縺ｿ霎ｼ繧√∪縺帙ｓ縲Ｃassasio.dll 縺 bass.dll 縺悟ｭ伜惠縺励∪縺帙ｓ縲" + newLine + "DTXMania繧偵ム繧ｦ繝ｳ繝ｭ繝ｼ繝峨＠縺ｪ縺翫＠縺ｦ縺上□縺輔＞縲",
+ "bassasio.dll is not loaded. bassasio.dll or bass.dll must not exist." + newLine + "Please download DTXMania again."
+ ) ) bDLLnotfound = true;
+ if ( !tDLL縺ｮ蟄伜惠繝√ぉ繝繧ｯ( "dll\\basswasapi.dll",
+ "basswasapi.dll 繧定ｪｭ縺ｿ霎ｼ繧√∪縺帙ｓ縲Ｃasswasapi.dll 縺 bass.dll 縺悟ｭ伜惠縺励∪縺帙ｓ縲" + newLine + "DTXMania繧偵ム繧ｦ繝ｳ繝ｭ繝ｼ繝峨＠縺ｪ縺翫＠縺ｦ縺上□縺輔＞縲",
+ "basswasapi.dll is not loaded. basswasapi.dll or bass.dll must not exist." + newLine + "Please download DTXMania again."
+ ) ) bDLLnotfound = true;
+ if ( !tDLL縺ｮ蟄伜惠繝√ぉ繝繧ｯ( "dll\\bass_fx.dll",
+ "bass_fx.dll 繧定ｪｭ縺ｿ霎ｼ繧√∪縺帙ｓ縲Ｃass_fx.dll 縺 bass.dll 縺悟ｭ伜惠縺励∪縺帙ｓ縲" + newLine + "DTXMania繧偵ム繧ｦ繝ｳ繝ｭ繝ｼ繝峨＠縺ｪ縺翫＠縺ｦ縺上□縺輔＞縲",
+ "bass_fx.dll is not loaded. bass_fx.dll or bass.dll must not exist." + newLine + "Please download DTXMania again."
+ ) ) bDLLnotfound = true;
+ if ( !tDLL縺ｮ蟄伜惠繝√ぉ繝繧ｯ( "dll\\DirectShowLib-2005.dll",
+ "DirectShowLib-2005.dll 縺悟ｭ伜惠縺励∪縺帙ｓ縲" + newLine + "DTXMania繧偵ム繧ｦ繝ｳ繝ｭ繝ｼ繝峨＠縺ｪ縺翫＠縺ｦ縺上□縺輔＞縲",
+ "DirectShowLib-2005.dll is not found." + newLine + "Please download DTXMania again."
+ ) ) bDLLnotfound = true;
+ #endregion
+ if ( !bDLLnotfound )
+ {
+#if DEBUG && TEST_ENGLISH
+ Thread.CurrentThread.CurrentCulture = new CultureInfo( "en-US" );
+#endif
+
+ DWM.EnableComposition( false ); // Disable AeroGrass temporally
+
+ // BEGIN #23670 2010.11.13 from: 繧ｭ繝｣繝繝√＆繧後↑縺萓句､悶ｯ謾ｾ蜃ｺ縺帙★縺ｫ縲√Ο繧ｰ縺ｫ隧ｳ邏ｰ繧貞ｺ蜉帙☆繧九
+ // BEGIM #24606 2011.03.08 from: DEBUG 譎ゅｯ萓句､也匱逕溽ｮ謇繧堤峩謗･繝繝舌ャ繧ｰ縺ｧ縺阪ｋ繧医≧縺ｫ縺吶ｋ縺溘ａ縲∽ｾ句､悶ｒ繧ｭ繝｣繝繝√＠縺ｪ縺繧医≧縺ｫ縺吶ｋ縲
+#if !DEBUG
+ try
+#endif
+ {
+ using ( var mania = new TJAPlayer3() )
+ mania.Run();
+
+ Trace.WriteLine( "" );
+ Trace.WriteLine( "驕翫ｓ縺ｧ縺上ｌ縺ｦ縺ゅｊ縺後→縺ｼ" );
+ }
+#if !DEBUG
+ catch( Exception e )
+ {
+ Trace.WriteLine( "" );
+ Trace.Write( e.ToString() );
+ Trace.WriteLine( "" );
+ Trace.WriteLine( "繧ｨ繝ｩ繝ｼ縺繧ｴ繝｡繝ｳｼｼ域ｶ" );
+ AssemblyName asmApp = Assembly.GetExecutingAssembly().GetName();
+ MessageBox.Show( "繧ｨ繝ｩ繝ｼ縺檎匱逕溘＠縺ｾ縺励◆縲\n" +
+ e.ToString(), asmApp.Name + " Ver." + asmApp.Version.ToString().Substring(0, asmApp.Version.ToString().Length - 2) + " Error", MessageBoxButtons.OK, MessageBoxIcon.Error ); // #23670 2011.2.28 yyagi to show error dialog
+ }
+#endif
+ // END #24606 2011.03.08 from
+ // END #23670 2010.11.13 from
+
+ if ( Trace.Listeners.Count > 1 )
+ Trace.Listeners.RemoveAt( 1 );
+ }
+
+ // BEGIN #24615 2011.03.09 from: Mutex.WaitOne() 縺 true 繧定ｿ斐＠縺溷ｴ蜷医ｯ縲｀utex 縺ｮ繝ｪ繝ｪ繝ｼ繧ｹ縺悟ｿ隕√〒縺ゅｋ縲
+
+ mutex莠碁崎ｵｷ蜍暮亟豁｢逕ｨ.ReleaseMutex();
+ mutex莠碁崎ｵｷ蜍暮亟豁｢逕ｨ = null;
+
+ // END #24615 2011.03.09 from
+ }
+ else // DTXMania縺梧里縺ｫ襍ｷ蜍穂ｸｭ
+ {
+
+ // 竊 蠑墓焚縺0蛟九ｮ譎ゅｯ縺昴ｮ縺ｾ縺ｾ邨ゆｺ
+ // 1蛟( 繧ｳ繝ｳ繝代け繝医Δ繝ｼ繝 or DTXV -S) 縺2蛟 (DTXV -Nxxx 繝輔ぃ繧､繝ｫ蜷)縺ｮ縺ｨ縺阪ｯ縲√◎縺ｮ繝励Ο繧ｻ繧ｹ縺ｫ繧ｳ繝槭Φ繝峨Λ繧､繝ｳ繧剃ｸｸ縲謚輔£縺ｦ邨ゆｺ縺吶ｋ
+
+ for ( int i = 0; i < 5; i++ ) // 讀懃ｴ｢邨先棡縺ｮ繝上Φ繝峨Ν縺兄ero縺ｫ縺ｪ繧九％縺ｨ縺後≠繧九ｮ縺ｧ縲200ms髢馴囈縺ｧ5蝗槭Μ繝医Λ繧､縺吶ｋ
+ {
+ #region [ 譌｢縺ｫ襍ｷ蜍穂ｸｭ縺ｮDTXMania繝励Ο繧ｻ繧ｹ繧呈､懃ｴ｢縺吶ｋ縲]
+ // 縺薙ｮ繧繧頑婿縺縺ｨ縲ヾhowInTaskbar=false縺ｧ繧ｿ繧ｹ繧ｯ繝舌ｼ縺ｫ陦ｨ遉ｺ縺輔ｌ縺ｪ縺繝代ち繝ｼ繝ｳ縺ｮ譎ゅ↓讀懃ｴ｢縺ｫ螟ｱ謨励☆繧九ｈ縺縺縺
+ // DTXMania縺ｧ縺昴ｮ繝代ち繝ｼ繝ｳ縺ｯ縺ｪ縺ｼ溘ｮ縺ｧ縺薙ｮ縺ｾ縺ｾ縺縺上
+ // FindWindow繧剃ｽｿ縺医ｰ縺薙ｮ繝代ち繝ｼ繝ｳ縺ｫ繧ょｯｾ蠢懊〒縺阪ｋ縺後，#縺ｧ繝薙Ν繝峨☆繧九い繝励Μ縺ｯ繧ｦ繧､繝ｳ繝峨え繧ｯ繝ｩ繧ｹ蜷阪ｒ閾ｪ蜑肴欠螳壹〒縺阪↑縺縺ｮ縺ｧ縲√％繧後ｯ菴ｿ繧上↑縺縲
+
+ Process current = Process.GetCurrentProcess();
+ Process[] running = Process.GetProcessesByName( current.ProcessName );
+ Process target = null;
+ //IntPtr hWnd = FindWindow( null, "DTXMania .NET style release " + CDTXMania.VERSION );
+
+ foreach ( Process p in running )
+ {
+ if ( p.Id != current.Id ) // 繝励Ο繧ｻ繧ｹ蜷阪ｯ蜷後§縺ｧ縺九▽縲√励Ο繧ｻ繧ｹID縺瑚ｪ蛻閾ｪ霄ｫ縺ｨ縺ｯ逡ｰ縺ｪ繧九ｂ縺ｮ繧呈爾縺
+ {
+ if ( p.MainModule.FileName == current.MainModule.FileName && p.MainWindowHandle != IntPtr.Zero )
+ {
+ target = p;
+ break;
+ }
+ }
+ }
+ #endregion
+
+ #region [ 襍ｷ蜍穂ｸｭ縺ｮDTXMania縺後＞繧後ｰ縲√◎縺ｮ繝励Ο繧ｻ繧ｹ縺ｫ繧ｳ繝槭Φ繝峨Λ繧､繝ｳ繧呈兜縺偵ｋ ]
+ if ( target != null )
+ {
+ string[] commandLineArgs = Environment.GetCommandLineArgs();
+ if ( commandLineArgs != null && commandLineArgs.Length > 1 )
+ {
+ string arg = null;
+ for ( int j = 1; j < commandLineArgs.Length; j++ )
+ {
+ if ( j == 1 )
+ {
+ arg += commandLineArgs[ j ];
+ }
+ else
+ {
+ arg += " " + "\"" + commandLineArgs[ j ] + "\"";
+ }
+ }
+
+//Trace.TraceInformation( "Message=" + arg + ", len(w/o null)=" + arg.Length );
+
+ if ( arg != null )
+ {
+ FDK.CSendMessage.sendmessage( target.MainWindowHandle, current.MainWindowHandle, arg );
+ }
+ }
+ break;
+ }
+ #endregion
+ else
+ {
+ Trace.TraceInformation( "繝｡繝繧ｻ繝ｼ繧ｸ騾∽ｿ｡蜈医ｮ繝励Ο繧ｻ繧ｹ縺瑚ｦ九▽縺九ｉ縺壹5蝗槭Μ繝医Λ繧､縺励∪縺吶" );
+ Thread.Sleep( 200 );
+ }
+ }
+ }
+ }
+ }
+}
diff --git a/TJAPlayer3/Common/TJAPlayer3.cs b/TJAPlayer3/Common/TJAPlayer3.cs
new file mode 100644
index 00000000..628cbefd
--- /dev/null
+++ b/TJAPlayer3/Common/TJAPlayer3.cs
@@ -0,0 +1,2990 @@
+ｻｿusing System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Text;
+using System.Windows.Forms;
+using System.Drawing;
+using System.Diagnostics;
+using System.IO;
+using System.Threading;
+using System.Net.NetworkInformation;
+using System.Runtime.Serialization.Formatters.Binary;
+using SlimDX;
+using SlimDX.Direct3D9;
+using FDK;
+using SampleFramework;
+using System.Reflection;
+using System.Threading.Tasks;
+using System.Linq;
+
+namespace TJAPlayer3
+{
+ internal class TJAPlayer3 : Game
+ {
+ // 繝励Ο繝代ユ繧｣
+ #region [ properties ]
+ public static readonly string VERSION = Assembly.GetExecutingAssembly().GetName().Version.ToString().Substring(0, Assembly.GetExecutingAssembly().GetName().Version.ToString().Length - 2);
+ public static readonly string AppDisplayThreePartVersion = GetAppDisplayThreePartVersion();
+ public static readonly string AppNumericThreePartVersion = GetAppNumericThreePartVersion();
+
+ private static string GetAppDisplayThreePartVersion()
+ {
+ return $"v{GetAppNumericThreePartVersion()}";
+ }
+
+ private static string GetAppNumericThreePartVersion()
+ {
+ var version = Assembly.GetExecutingAssembly().GetName().Version;
+
+ return $"{version.Major}.{version.Minor}.{version.Build}";
+ }
+
+ public static readonly string AppInformationalVersion =
+ Assembly
+ .GetExecutingAssembly()
+ .GetCustomAttributes(typeof(AssemblyInformationalVersionAttribute), false)
+ .Cast()
+ .FirstOrDefault()
+ ?.InformationalVersion
+ ?? $"{GetAppDisplayThreePartVersion()} (unknown informational version)";
+ public static readonly string SLIMDXDLL = "c_net20x86_Jun2010";
+ public static readonly string D3DXDLL = "d3dx9_43.dll"; // June 2010
+ //public static readonly string D3DXDLL = "d3dx9_42.dll"; // February 2010
+ //public static readonly string D3DXDLL = "d3dx9_41.dll"; // March 2009
+
+ public static TJAPlayer3 app
+ {
+ get;
+ private set;
+ }
+ public static C譁蟄励さ繝ｳ繧ｽ繝ｼ繝ｫ act譁蟄励さ繝ｳ繧ｽ繝ｼ繝ｫ
+ {
+ get;
+ private set;
+ }
+ public static bool b繧ｳ繝ｳ繝代け繝医Δ繝ｼ繝
+ {
+ get;
+ private set;
+ }
+ public static CConfigIni ConfigIni
+ {
+ get;
+ private set;
+ }
+ public static CDTX DTX
+ {
+ get
+ {
+ return dtx[ 0 ];
+ }
+ set
+ {
+ if( ( dtx[ 0 ] != null ) && ( app != null ) )
+ {
+ dtx[ 0 ].On髱樊ｴｻ諤ｧ蛹();
+ app.list繝医ャ繝励Ξ繝吶ΝActivities.Remove( dtx[ 0 ] );
+ }
+ dtx[ 0 ] = value;
+ if( ( dtx[ 0 ] != null ) && ( app != null ) )
+ {
+ app.list繝医ャ繝励Ξ繝吶ΝActivities.Add( dtx[ 0 ] );
+ }
+ }
+ }
+ public static CDTX DTX_2P
+ {
+ get
+ {
+ return dtx[ 1 ];
+ }
+ set
+ {
+ if( ( dtx[ 1 ] != null ) && ( app != null ) )
+ {
+ dtx[ 1 ].On髱樊ｴｻ諤ｧ蛹();
+ app.list繝医ャ繝励Ξ繝吶ΝActivities.Remove( dtx[ 1 ] );
+ }
+ dtx[ 1 ] = value;
+ if( ( dtx[ 1 ] != null ) && ( app != null ) )
+ {
+ app.list繝医ャ繝励Ξ繝吶ΝActivities.Add( dtx[ 1 ] );
+ }
+ }
+ }
+
+ public static bool IsPerformingCalibration;
+
+ public static CFPS FPS
+ {
+ get;
+ private set;
+ }
+ public static CInput邂｡逅 Input邂｡逅
+ {
+ get;
+ private set;
+ }
+ #region [ 蜈･蜉帷ｯ蝗ｲms ]
+ public static int nPerfect遽蝗ｲms
+ {
+ get
+ {
+ if( stage驕ｸ譖ｲ.r遒ｺ螳壹＆繧後◆譖ｲ != null )
+ {
+ C譖ｲ繝ｪ繧ｹ繝医ヮ繝ｼ繝 c譖ｲ繝ｪ繧ｹ繝医ヮ繝ｼ繝 = stage驕ｸ譖ｲ.r遒ｺ螳壹＆繧後◆譖ｲ.r隕ｪ繝弱ｼ繝;
+ if( ( ( c譖ｲ繝ｪ繧ｹ繝医ヮ繝ｼ繝 != null ) && ( c譖ｲ繝ｪ繧ｹ繝医ヮ繝ｼ繝.e繝弱ｼ繝臥ｨｮ蛻･ == C譖ｲ繝ｪ繧ｹ繝医ヮ繝ｼ繝.E繝弱ｼ繝臥ｨｮ蛻･.BOX ) ) && ( c譖ｲ繝ｪ繧ｹ繝医ヮ繝ｼ繝.nPerfect遽蝗ｲms >= 0 ) )
+ {
+ return c譖ｲ繝ｪ繧ｹ繝医ヮ繝ｼ繝.nPerfect遽蝗ｲms;
+ }
+ }
+ return ConfigIni.n繝偵ャ繝育ｯ蝗ｲms.Perfect;
+ }
+ }
+ public static int nGreat遽蝗ｲms
+ {
+ get
+ {
+ if( stage驕ｸ譖ｲ.r遒ｺ螳壹＆繧後◆譖ｲ != null )
+ {
+ C譖ｲ繝ｪ繧ｹ繝医ヮ繝ｼ繝 c譖ｲ繝ｪ繧ｹ繝医ヮ繝ｼ繝 = stage驕ｸ譖ｲ.r遒ｺ螳壹＆繧後◆譖ｲ.r隕ｪ繝弱ｼ繝;
+ if( ( ( c譖ｲ繝ｪ繧ｹ繝医ヮ繝ｼ繝 != null ) && ( c譖ｲ繝ｪ繧ｹ繝医ヮ繝ｼ繝.e繝弱ｼ繝臥ｨｮ蛻･ == C譖ｲ繝ｪ繧ｹ繝医ヮ繝ｼ繝.E繝弱ｼ繝臥ｨｮ蛻･.BOX ) ) && ( c譖ｲ繝ｪ繧ｹ繝医ヮ繝ｼ繝.nGreat遽蝗ｲms >= 0 ) )
+ {
+ return c譖ｲ繝ｪ繧ｹ繝医ヮ繝ｼ繝.nGreat遽蝗ｲms;
+ }
+ }
+ return ConfigIni.n繝偵ャ繝育ｯ蝗ｲms.Great;
+ }
+ }
+ public static int nGood遽蝗ｲms
+ {
+ get
+ {
+ if( stage驕ｸ譖ｲ.r遒ｺ螳壹＆繧後◆譖ｲ != null )
+ {
+ C譖ｲ繝ｪ繧ｹ繝医ヮ繝ｼ繝 c譖ｲ繝ｪ繧ｹ繝医ヮ繝ｼ繝 = stage驕ｸ譖ｲ.r遒ｺ螳壹＆繧後◆譖ｲ.r隕ｪ繝弱ｼ繝;
+ if( ( ( c譖ｲ繝ｪ繧ｹ繝医ヮ繝ｼ繝 != null ) && ( c譖ｲ繝ｪ繧ｹ繝医ヮ繝ｼ繝.e繝弱ｼ繝臥ｨｮ蛻･ == C譖ｲ繝ｪ繧ｹ繝医ヮ繝ｼ繝.E繝弱ｼ繝臥ｨｮ蛻･.BOX ) ) && ( c譖ｲ繝ｪ繧ｹ繝医ヮ繝ｼ繝.nGood遽蝗ｲms >= 0 ) )
+ {
+ return c譖ｲ繝ｪ繧ｹ繝医ヮ繝ｼ繝.nGood遽蝗ｲms;
+ }
+ }
+ return ConfigIni.n繝偵ャ繝育ｯ蝗ｲms.Good;
+ }
+ }
+ public static int nPoor遽蝗ｲms
+ {
+ get
+ {
+ if( stage驕ｸ譖ｲ.r遒ｺ螳壹＆繧後◆譖ｲ != null )
+ {
+ C譖ｲ繝ｪ繧ｹ繝医ヮ繝ｼ繝 c譖ｲ繝ｪ繧ｹ繝医ヮ繝ｼ繝 = stage驕ｸ譖ｲ.r遒ｺ螳壹＆繧後◆譖ｲ.r隕ｪ繝弱ｼ繝;
+ if( ( ( c譖ｲ繝ｪ繧ｹ繝医ヮ繝ｼ繝 != null ) && ( c譖ｲ繝ｪ繧ｹ繝医ヮ繝ｼ繝.e繝弱ｼ繝臥ｨｮ蛻･ == C譖ｲ繝ｪ繧ｹ繝医ヮ繝ｼ繝.E繝弱ｼ繝臥ｨｮ蛻･.BOX ) ) && ( c譖ｲ繝ｪ繧ｹ繝医ヮ繝ｼ繝.nPoor遽蝗ｲms >= 0 ) )
+ {
+ return c譖ｲ繝ｪ繧ｹ繝医ヮ繝ｼ繝.nPoor遽蝗ｲms;
+ }
+ }
+ return ConfigIni.n繝偵ャ繝育ｯ蝗ｲms.Poor;
+ }
+ }
+ #endregion
+ public static CPad Pad
+ {
+ get;
+ private set;
+ }
+ public static Random Random
+ {
+ get;
+ private set;
+ }
+ public static CSkin Skin
+ {
+ get;
+ private set;
+ }
+ public static CSongs邂｡逅 Songs邂｡逅
+ {
+ get;
+ set; // 2012.1.26 yyagi private隗｣髯､ CStage襍ｷ蜍輔〒縺ｮdesirialize隱ｭ縺ｿ霎ｼ縺ｿ縺ｮ縺溘ａ
+ }
+ public static CEnumSongs EnumSongs
+ {
+ get;
+ private set;
+ }
+ public static CActEnumSongs actEnumSongs
+ {
+ get;
+ private set;
+ }
+ public static CActScanningLoudness actScanningLoudness
+ {
+ get;
+ private set;
+ }
+ public static CActFlushGPU actFlushGPU
+ {
+ get;
+ private set;
+ }
+
+ public static CSound邂｡逅 Sound邂｡逅
+ {
+ get;
+ private set;
+ }
+
+ public static SongGainController SongGainController
+ {
+ get;
+ private set;
+ }
+
+ public static SoundGroupLevelController SoundGroupLevelController
+ {
+ get;
+ private set;
+ }
+
+ public static CNamePlate NamePlate
+ {
+ get;
+ private set;
+ }
+
+ public static NamePlateConfig NamePlateConfig
+ {
+ get;
+ private set;
+ }
+
+ public static CStage襍ｷ蜍 stage襍ｷ蜍
+ {
+ get;
+ private set;
+ }
+ public static CStage繧ｿ繧､繝医Ν stage繧ｿ繧､繝医Ν
+ {
+ get;
+ private set;
+ }
+// public static CStage繧ｪ繝励す繝ｧ繝ｳ stage繧ｪ繝励す繝ｧ繝ｳ
+// {
+// get;
+// private set;
+// }
+ public static CStage繧ｳ繝ｳ繝輔ぅ繧ｰ stage繧ｳ繝ｳ繝輔ぅ繧ｰ
+ {
+ get;
+ private set;
+ }
+ public static CStage驕ｸ譖ｲ stage驕ｸ譖ｲ
+ {
+ get;
+ private set;
+ }
+ public static CStage谿ｵ菴埼∈謚 stage谿ｵ菴埼∈謚
+ {
+ get;
+ private set;
+ }
+ public static CStage譖ｲ隱ｭ縺ｿ霎ｼ縺ｿ stage譖ｲ隱ｭ縺ｿ霎ｼ縺ｿ
+ {
+ get;
+ private set;
+ }
+ public static CStage貍泌･上ラ繝ｩ繝逕ｻ髱｢ stage貍泌･上ラ繝ｩ繝逕ｻ髱｢
+ {
+ get;
+ private set;
+ }
+ public static CStage邨先棡 stage邨先棡
+ {
+ get;
+ private set;
+ }
+ public static CStageChangeSkin stageChangeSkin
+ {
+ get;
+ private set;
+ }
+ public static CStage邨ゆｺ stage邨ゆｺ
+ {
+ get;
+ private set;
+ }
+ public static CStage r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ = null;
+ public static CStage r逶ｴ蜑阪ｮ繧ｹ繝繝ｼ繧ｸ = null;
+ public static string strEXE縺ｮ縺ゅｋ繝輔か繝ｫ繝
+ {
+ get;
+ private set;
+ }
+ public static string str繧ｳ繝ｳ繝代け繝医Δ繝ｼ繝峨ヵ繧｡繧､繝ｫ
+ {
+ get;
+ private set;
+ }
+ public static CTimer Timer
+ {
+ get;
+ private set;
+ }
+ public static Format TextureFormat = Format.A8R8G8B8;
+ internal static IPluginActivity act迴ｾ蝨ｨ蜈･蜉帙ｒ蜊譛我ｸｭ縺ｮ繝励Λ繧ｰ繧､繝ｳ = null;
+ public bool bApplicationActive
+ {
+ get;
+ private set;
+ }
+ public bool b谺｡縺ｮ繧ｿ繧､繝溘Φ繧ｰ縺ｧ蝙ら峩蟶ｰ邱壼酔譛溷繧頑崛縺医ｒ陦後≧
+ {
+ get;
+ set;
+ }
+ public bool b谺｡縺ｮ繧ｿ繧､繝溘Φ繧ｰ縺ｧ蜈ｨ逕ｻ髱｢_繧ｦ繧｣繝ｳ繝峨え蛻繧頑崛縺医ｒ陦後≧
+ {
+ get;
+ set;
+ }
+ public DeviceCache Device
+ {
+ get { return base.GraphicsDeviceManager.Direct3D9.Device; }
+ }
+ public CPluginHost PluginHost
+ {
+ get;
+ private set;
+ }
+ public List list繝励Λ繧ｰ繧､繝ｳ = new List();
+ public struct STPlugin
+ {
+ public IPluginActivity plugin;
+ public string str繝励Λ繧ｰ繧､繝ｳ繝輔か繝ｫ繝;
+ public string str繧｢繧ｻ繝ｳ繝悶Μ邁｡譏灘錐;
+ public Version Version;
+ }
+ private static Size currentClientSize // #23510 2010.10.27 add yyagi to keep current window size
+ {
+ get;
+ set;
+ }
+ // public static CTimer ct;
+ public IntPtr WindowHandle // 2012.10.24 yyagi; to add ASIO support
+ {
+ get { return base.Window.Handle; }
+ }
+ public static CDTXVmode DTXVmode // #28821 2014.1.23 yyagi
+ {
+ get;
+ set;
+ }
+
+ #endregion
+
+ // 繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ
+
+ public TJAPlayer3()
+ {
+ TJAPlayer3.app = this;
+ this.t襍ｷ蜍募ｦ逅();
+ }
+
+
+ // 繝｡繧ｽ繝繝
+
+ public void t蜈ｨ逕ｻ髱｢_繧ｦ繧｣繝ｳ繝峨え繝｢繝ｼ繝牙繧頑崛縺()
+ {
+#if WindowedFullscreen
+ if ( ConfigIni != null )
+#else
+ DeviceSettings settings = base.GraphicsDeviceManager.CurrentSettings.Clone();
+ if ( ( ConfigIni != null ) && ( ConfigIni.b繧ｦ繧｣繝ｳ繝峨え繝｢繝ｼ繝 != settings.Windowed ) )
+#endif
+ {
+#if !WindowedFullscreen
+ settings.Windowed = ConfigIni.b繧ｦ繧｣繝ｳ繝峨え繝｢繝ｼ繝;
+#endif
+ if ( ConfigIni.b繧ｦ繧｣繝ｳ繝峨え繝｢繝ｼ繝 == false ) // #23510 2010.10.27 yyagi: backup current window size before going fullscreen mode
+ {
+ currentClientSize = this.Window.ClientSize;
+ ConfigIni.n繧ｦ繧､繝ｳ繝峨えwidth = this.Window.ClientSize.Width;
+ ConfigIni.n繧ｦ繧､繝ｳ繝峨えheight = this.Window.ClientSize.Height;
+// FDK.CTaskBar.ShowTaskBar( false );
+ }
+#if !WindowedFullscreen
+ base.GraphicsDeviceManager.ChangeDevice( settings );
+#endif
+ if ( ConfigIni.b繧ｦ繧｣繝ｳ繝峨え繝｢繝ｼ繝 == true ) // #23510 2010.10.27 yyagi: to resume window size from backuped value
+ {
+#if WindowedFullscreen
+ // #30666 2013.2.2 yyagi Don't use Fullscreen mode becasue NVIDIA GeForce is
+ // tend to delay drawing on Fullscreen mode. So DTXMania uses Maximized window
+ // in spite of using fullscreen mode.
+ app.Window.WindowState = FormWindowState.Normal;
+ app.Window.FormBorderStyle = FormBorderStyle.Sizable;
+ app.Window.WindowState = FormWindowState.Normal;
+#endif
+ base.Window.ClientSize =
+ new Size( currentClientSize.Width, currentClientSize.Height );
+ base.Window.Icon = Properties.Resources.tjap3;
+// FDK.CTaskBar.ShowTaskBar( true );
+ }
+#if WindowedFullscreen
+ else
+ {
+ app.Window.WindowState = FormWindowState.Normal;
+ app.Window.FormBorderStyle = FormBorderStyle.None;
+ app.Window.WindowState = FormWindowState.Maximized;
+ }
+ if ( ConfigIni.b繧ｦ繧｣繝ｳ繝峨え繝｢繝ｼ繝 )
+ {
+ if ( !this.b繝槭え繧ｹ繧ｫ繝ｼ繧ｽ繝ｫ陦ｨ遉ｺ荳ｭ )
+ {
+ Cursor.Show();
+ this.b繝槭え繧ｹ繧ｫ繝ｼ繧ｽ繝ｫ陦ｨ遉ｺ荳ｭ = true;
+ }
+ }
+ else if ( this.b繝槭え繧ｹ繧ｫ繝ｼ繧ｽ繝ｫ陦ｨ遉ｺ荳ｭ )
+ {
+ Cursor.Hide();
+ this.b繝槭え繧ｹ繧ｫ繝ｼ繧ｽ繝ｫ陦ｨ遉ｺ荳ｭ = false;
+ }
+#endif
+ }
+ }
+
+ #region [ #24609 繝ｪ繧ｶ繝ｫ繝育判蜒上ｒpng縺ｧ菫晏ｭ倥☆繧 ] // #24609 2011.3.14 yyagi; to save result screen in case BestRank or HiSkill.
+ ///
+ /// 繝ｪ繧ｶ繝ｫ繝育判蜒上ｮ繧ｭ繝｣繝励メ繝｣縺ｨ菫晏ｭ倥
+ ///
+ /// 菫晏ｭ倥☆繧九ヵ繧｡繧､繝ｫ蜷(繝輔Ν繝代せ)
+ public bool SaveResultScreen( string strFullPath )
+ {
+ string strSavePath = Path.GetDirectoryName( strFullPath );
+ if ( !Directory.Exists( strSavePath ) )
+ {
+ try
+ {
+ Directory.CreateDirectory( strSavePath );
+ }
+ catch
+ {
+ Trace.TraceError(ToString());
+ Trace.TraceError( "萓句､悶′逋ｺ逕溘＠縺ｾ縺励◆縺悟ｦ逅繧堤ｶ咏ｶ壹＠縺ｾ縺吶 (0bfe6bff-2a56-4df4-9333-2df26d9b765b)" );
+ return false;
+ }
+ }
+
+ // http://www.gamedev.net/topic/594369-dx9slimdxati-incorrect-saving-surface-to-file/
+ using ( Surface pSurface = TJAPlayer3.app.Device.GetRenderTarget( 0 ) )
+ {
+ Surface.ToFile( pSurface, strFullPath, ImageFileFormat.Png );
+ }
+ return true;
+ }
+ #endregion
+
+ // Game 螳溯｣
+
+ protected override void Initialize()
+ {
+// new GCBeep();
+ //sw.Start();
+ //swlist1 = new List( 8192 );
+ //swlist2 = new List( 8192 );
+ //swlist3 = new List( 8192 );
+ //swlist4 = new List( 8192 );
+ //swlist5 = new List( 8192 );
+ if ( this.list繝医ャ繝励Ξ繝吶ΝActivities != null )
+ {
+ foreach( CActivity activity in this.list繝医ャ繝励Ξ繝吶ΝActivities )
+ activity.OnManaged繝ｪ繧ｽ繝ｼ繧ｹ縺ｮ菴懈();
+ }
+
+ foreach( STPlugin st in this.list繝励Λ繧ｰ繧､繝ｳ )
+ {
+ Directory.SetCurrentDirectory( st.str繝励Λ繧ｰ繧､繝ｳ繝輔か繝ｫ繝 );
+ st.plugin.OnManaged繝ｪ繧ｽ繝ｼ繧ｹ縺ｮ菴懈();
+ Directory.SetCurrentDirectory( TJAPlayer3.strEXE縺ｮ縺ゅｋ繝輔か繝ｫ繝 );
+ }
+#if GPUFlushAfterPresent
+ FrameEnd += dtxmania_FrameEnd;
+#endif
+ }
+#if GPUFlushAfterPresent
+ void dtxmania_FrameEnd( object sender, EventArgs e ) // GraphicsDeviceManager.game_FrameEnd()蠕後↓螳溯｡後＆繧後ｋ
+ { // 竊 Present()逶ｴ蠕後↓GPU繧巽lush縺吶ｋ
+ // 竊 逕ｻ髱｢縺ｮ繧ｫ繧ｯ繝繧ｭ縺碁ｻ逋ｺ縺励◆縺溘ａ縲√％縺薙〒縺ｮFlush縺ｯ陦後ｏ縺ｪ縺
+ actFlushGPU.On騾ｲ陦梧緒逕ｻ(); // Flush GPU
+ }
+#endif
+ protected override void LoadContent()
+ {
+ if ( ConfigIni.b繧ｦ繧｣繝ｳ繝峨え繝｢繝ｼ繝 )
+ {
+ if( !this.b繝槭え繧ｹ繧ｫ繝ｼ繧ｽ繝ｫ陦ｨ遉ｺ荳ｭ )
+ {
+ Cursor.Show();
+ this.b繝槭え繧ｹ繧ｫ繝ｼ繧ｽ繝ｫ陦ｨ遉ｺ荳ｭ = true;
+ }
+ }
+ else if( this.b繝槭え繧ｹ繧ｫ繝ｼ繧ｽ繝ｫ陦ｨ遉ｺ荳ｭ )
+ {
+ Cursor.Hide();
+ this.b繝槭え繧ｹ繧ｫ繝ｼ繧ｽ繝ｫ陦ｨ遉ｺ荳ｭ = false;
+ }
+ this.Device.SetTransform(TransformState.View, Matrix.LookAtLH(new Vector3(0f, 0f, (float)(-SampleFramework.GameWindowSize.Height / 2 * Math.Sqrt(3.0))), new Vector3(0f, 0f, 0f), new Vector3(0f, 1f, 0f)));
+ this.Device.SetTransform(TransformState.Projection, Matrix.PerspectiveFovLH(C螟画鋤.DegreeToRadian((float)60f), ((float)this.Device.Viewport.Width) / ((float)this.Device.Viewport.Height), -100f, 100f));
+ this.Device.SetRenderState(RenderState.Lighting, false);
+ this.Device.SetRenderState( RenderState.ZEnable, false );
+ this.Device.SetRenderState( RenderState.AntialiasedLineEnable, false );
+ this.Device.SetRenderState( RenderState.AlphaTestEnable, true );
+ this.Device.SetRenderState( RenderState.AlphaRef, 10 );
+
+ this.Device.SetRenderState( RenderState.MultisampleAntialias, true );
+ this.Device.SetSamplerState( 0, SamplerState.MinFilter, TextureFilter.Linear );
+ this.Device.SetSamplerState( 0, SamplerState.MagFilter, TextureFilter.Linear );
+
+ this.Device.SetRenderState( RenderState.AlphaFunc, Compare.Greater );
+ this.Device.SetRenderState( RenderState.AlphaBlendEnable, true );
+ this.Device.SetRenderState( RenderState.SourceBlend, Blend.SourceAlpha );
+ this.Device.SetRenderState( RenderState.DestinationBlend, Blend.InverseSourceAlpha );
+ this.Device.SetTextureStageState( 0, TextureStage.AlphaOperation, TextureOperation.Modulate );
+ this.Device.SetTextureStageState( 0, TextureStage.AlphaArg1, 2 );
+ this.Device.SetTextureStageState( 0, TextureStage.AlphaArg2, 1 );
+
+ if( this.list繝医ャ繝励Ξ繝吶ΝActivities != null )
+ {
+ foreach( CActivity activity in this.list繝医ャ繝励Ξ繝吶ΝActivities )
+ activity.OnUnmanaged繝ｪ繧ｽ繝ｼ繧ｹ縺ｮ菴懈();
+ }
+
+ foreach( STPlugin st in this.list繝励Λ繧ｰ繧､繝ｳ )
+ {
+ Directory.SetCurrentDirectory( st.str繝励Λ繧ｰ繧､繝ｳ繝輔か繝ｫ繝 );
+ st.plugin.OnUnmanaged繝ｪ繧ｽ繝ｼ繧ｹ縺ｮ菴懈();
+ Directory.SetCurrentDirectory( TJAPlayer3.strEXE縺ｮ縺ゅｋ繝輔か繝ｫ繝 );
+ }
+ }
+ protected override void UnloadContent()
+ {
+ if( this.list繝医ャ繝励Ξ繝吶ΝActivities != null )
+ {
+ foreach( CActivity activity in this.list繝医ャ繝励Ξ繝吶ΝActivities )
+ activity.OnUnmanaged繝ｪ繧ｽ繝ｼ繧ｹ縺ｮ隗｣謾ｾ();
+ }
+
+ foreach( STPlugin st in this.list繝励Λ繧ｰ繧､繝ｳ )
+ {
+ Directory.SetCurrentDirectory( st.str繝励Λ繧ｰ繧､繝ｳ繝輔か繝ｫ繝 );
+ st.plugin.OnUnmanaged繝ｪ繧ｽ繝ｼ繧ｹ縺ｮ隗｣謾ｾ();
+ Directory.SetCurrentDirectory( TJAPlayer3.strEXE縺ｮ縺ゅｋ繝輔か繝ｫ繝 );
+ }
+ }
+ protected override void OnExiting( EventArgs e )
+ {
+ CPowerManagement.tEnableMonitorSuspend(); // 繧ｹ繝ｪ繝ｼ繝玲椛豁｢迥ｶ諷九ｒ隗｣髯､
+ this.t邨ゆｺ蜃ｦ逅();
+ base.OnExiting( e );
+ }
+ protected override void Update( GameTime gameTime )
+ {
+ }
+ protected override void Draw( GameTime gameTime )
+ {
+ Sound邂｡逅?.t蜀咲函荳ｭ縺ｮ蜃ｦ逅繧偵☆繧();
+ Timer?.t譖ｴ譁ｰ();
+ CSound邂｡逅.rc貍泌･冗畑繧ｿ繧､繝?.t譖ｴ譁ｰ();
+ Input邂｡逅?.t繝昴ｼ繝ｪ繝ｳ繧ｰ( this.bApplicationActive, TJAPlayer3.ConfigIni.b繝舌ャ繝輔ぃ蜈･蜉帙ｒ陦後≧ );
+ FPS?.t繧ｫ繧ｦ繝ｳ繧ｿ譖ｴ譁ｰ();
+
+ if( this.Device == null )
+ return;
+
+ if ( this.bApplicationActive ) // DTXMania譛ｬ菴楢ｵｷ蜍穂ｸｭ縺ｮ譛ｬ菴/繝｢繝九ち縺ｮ逵髮ｻ蜉帙Δ繝ｼ繝臥ｧｻ陦後ｒ謚第ｭ｢
+ CPowerManagement.tDisableMonitorSuspend();
+
+ // #xxxxx 2013.4.8 yyagi; sleep縺ｮ謖ｿ蜈･菴咲ｽｮ繧偵・ndScneneｽ霸resent髢薙°繧峨。eginScene蜑阪↓遘ｻ蜍輔よ緒逕ｻ驕蟒ｶ繧貞ｰ上＆縺上☆繧九◆繧√
+ #region [ 繧ｹ繝ｪ繝ｼ繝 ]
+ if ( ConfigIni.n繝輔Ξ繝ｼ繝豈弱せ繝ｪ繝ｼ繝洋s >= 0 ) // #xxxxx 2011.11.27 yyagi
+ {
+ Thread.Sleep( ConfigIni.n繝輔Ξ繝ｼ繝豈弱せ繝ｪ繝ｼ繝洋s );
+ }
+ #endregion
+
+ #region [ DTXCreator縺九ｉ縺ｮ謖遉ｺ ]
+ if ( this.Window.IsReceivedMessage ) // 繧ｦ繧､繝ｳ繝峨え繝｡繝繧ｻ繝ｼ繧ｸ縺ｧ縲
+ {
+ string strMes = this.Window.strMessage;
+ this.Window.IsReceivedMessage = false;
+
+ if ( strMes != null )
+ {
+ DTXVmode.ParseArguments( strMes );
+
+ if ( DTXVmode.Enabled )
+ {
+ b繧ｳ繝ｳ繝代け繝医Δ繝ｼ繝 = true;
+ str繧ｳ繝ｳ繝代け繝医Δ繝ｼ繝峨ヵ繧｡繧､繝ｫ = DTXVmode.filename;
+ if ( DTXVmode.Command == CDTXVmode.ECommand.Preview )
+ {
+ // preview sound縺ｮ蜀咲函
+ string strPreviewFilename = DTXVmode.previewFilename;
+//Trace.TraceInformation( "Preview Filename=" + DTXVmode.previewFilename );
+ try
+ {
+ if ( this.previewSound != null )
+ {
+ this.previewSound.t繧ｵ繧ｦ繝ｳ繝峨ｒ蛛懈ｭ｢縺吶ｋ();
+ this.previewSound.Dispose();
+ this.previewSound = null;
+ }
+ this.previewSound = TJAPlayer3.Sound邂｡逅.t繧ｵ繧ｦ繝ｳ繝峨ｒ逕滓舌☆繧( strPreviewFilename, ESoundGroup.SongPlayback );
+
+ // 2018-08-23 twopointzero: DTXVmode previewVolume will always set
+ // Gain since in this mode it should override the application of
+ // SONGVOL or any other Gain source regardless of configuration.
+ this.previewSound.SetGain(DTXVmode.previewVolume);
+
+ this.previewSound.n菴咲ｽｮ = DTXVmode.previewPan;
+ this.previewSound.t蜀咲函繧帝幕蟋九☆繧();
+ Trace.TraceInformation( "DTXC縺九ｉ縺ｮ謖遉ｺ縺ｧ縲√し繧ｦ繝ｳ繝峨ｒ逕滓舌＠縺ｾ縺励◆縲({0})", strPreviewFilename );
+ }
+ catch
+ {
+ Trace.TraceError(ToString());
+ Trace.TraceError( "DTXC縺九ｉ縺ｮ謖遉ｺ縺ｧ縺ｮ縲√し繧ｦ繝ｳ繝峨ｮ逕滓舌↓螟ｱ謨励＠縺ｾ縺励◆縲({0})", strPreviewFilename );
+ if ( this.previewSound != null )
+ {
+ this.previewSound.Dispose();
+ }
+ this.previewSound = null;
+ }
+ }
+ }
+ }
+ }
+ #endregion
+
+ this.Device.BeginScene();
+ this.Device.Clear( ClearFlags.ZBuffer | ClearFlags.Target, Color.Black, 1f, 0 );
+
+ if( r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ != null )
+ {
+ this.n騾ｲ陦梧緒逕ｻ縺ｮ謌ｻ繧雁､ = ( r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ != null ) ? r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ.On騾ｲ陦梧緒逕ｻ() : 0;
+
+ #region [ 繝励Λ繧ｰ繧､繝ｳ縺ｮ騾ｲ陦梧緒逕ｻ ]
+ //---------------------
+ foreach( STPlugin sp in this.list繝励Λ繧ｰ繧､繝ｳ )
+ {
+ Directory.SetCurrentDirectory( sp.str繝励Λ繧ｰ繧､繝ｳ繝輔か繝ｫ繝 );
+
+ if( TJAPlayer3.act迴ｾ蝨ｨ蜈･蜉帙ｒ蜊譛我ｸｭ縺ｮ繝励Λ繧ｰ繧､繝ｳ == null || TJAPlayer3.act迴ｾ蝨ｨ蜈･蜉帙ｒ蜊譛我ｸｭ縺ｮ繝励Λ繧ｰ繧､繝ｳ == sp.plugin )
+ sp.plugin.On騾ｲ陦梧緒逕ｻ(TJAPlayer3.Pad, TJAPlayer3.Input邂｡逅.Keyboard );
+ else
+ sp.plugin.On騾ｲ陦梧緒逕ｻ( null, null );
+
+ Directory.SetCurrentDirectory( TJAPlayer3.strEXE縺ｮ縺ゅｋ繝輔か繝ｫ繝 );
+ }
+ //---------------------
+ #endregion
+
+
+ CScoreIni scoreIni = null;
+
+ if ( Control.IsKeyLocked( Keys.CapsLock ) ) // #30925 2013.3.11 yyagi; capslock=ON譎ゅｯ縲・numSongs縺励↑縺繧医≧縺ｫ縺励※縲∬ｵｷ蜍戊ｲ闕ｷ縺ｨASIO縺ｮ髻ｳ蛻繧後ｮ髢｢菫ゅｒ遒ｺ隱阪☆繧
+ { // 竊 songs.db遲峨ｮ譖ｸ縺崎ｾｼ縺ｿ譎ゅ□縺ｨ髻ｳ蛻繧後☆繧九▲縺ｽ縺
+ actEnumSongs.On髱樊ｴｻ諤ｧ蛹();
+ EnumSongs.SongListEnumCompletelyDone();
+ TJAPlayer3.stage驕ｸ譖ｲ.bIsEnumeratingSongs = false;
+ }
+ #region [ 譖ｲ讀懃ｴ｢繧ｹ繝ｬ繝繝峨ｮ襍ｷ蜍/邨ゆｺ ] // 縺薙％縺ｫ"Enumerating Songs..."陦ｨ遉ｺ繧帝寔邏
+ if ( !TJAPlayer3.b繧ｳ繝ｳ繝代け繝医Δ繝ｼ繝 )
+ {
+ actEnumSongs.On騾ｲ陦梧緒逕ｻ(); // "Enumerating Songs..."繧｢繧､繧ｳ繝ｳ縺ｮ謠冗判
+ }
+ switch ( r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ.e繧ｹ繝繝ｼ繧ｸID )
+ {
+ case CStage.E繧ｹ繝繝ｼ繧ｸ.繧ｿ繧､繝医Ν:
+ case CStage.E繧ｹ繝繝ｼ繧ｸ.繧ｳ繝ｳ繝輔ぅ繧ｰ:
+ case CStage.E繧ｹ繝繝ｼ繧ｸ.驕ｸ譖ｲ:
+ case CStage.E繧ｹ繝繝ｼ繧ｸ.譖ｲ隱ｭ縺ｿ霎ｼ縺ｿ:
+ if ( EnumSongs != null )
+ {
+ #region [ (迚ｹ螳壽擅莉ｶ譎) 譖ｲ讀懃ｴ｢繧ｹ繝ｬ繝繝峨ｮ襍ｷ蜍廟髢句ｧ ]
+ if ( r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ.e繧ｹ繝繝ｼ繧ｸID == CStage.E繧ｹ繝繝ｼ繧ｸ.繧ｿ繧､繝医Ν &&
+ r逶ｴ蜑阪ｮ繧ｹ繝繝ｼ繧ｸ.e繧ｹ繝繝ｼ繧ｸID == CStage.E繧ｹ繝繝ｼ繧ｸ.襍ｷ蜍 &&
+ this.n騾ｲ陦梧緒逕ｻ縺ｮ謌ｻ繧雁､ == (int) CStage繧ｿ繧､繝医Ν.E謌ｻ繧雁､.邯咏ｶ &&
+ !EnumSongs.IsSongListEnumStarted )
+ {
+ actEnumSongs.On豢ｻ諤ｧ蛹();
+ TJAPlayer3.stage驕ｸ譖ｲ.bIsEnumeratingSongs = true;
+ EnumSongs.Init(); // 蜿門ｾ励＠縺滓峇謨ｰ繧偵∵眠繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｫ繧ゆｸ弱∴繧
+ EnumSongs.StartEnumFromDisk(); // 譖ｲ讀懃ｴ｢繧ｹ繝ｬ繝繝峨ｮ襍ｷ蜍廟髢句ｧ
+ }
+ #endregion
+
+ #region [ 譖ｲ讀懃ｴ｢縺ｮ荳ｭ譁ｭ縺ｨ蜀埼幕 ]
+ if ( r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ.e繧ｹ繝繝ｼ繧ｸID == CStage.E繧ｹ繝繝ｼ繧ｸ.驕ｸ譖ｲ && !EnumSongs.IsSongListEnumCompletelyDone )
+ {
+ switch ( this.n騾ｲ陦梧緒逕ｻ縺ｮ謌ｻ繧雁､ )
+ {
+ case 0: // 菴輔ｂ縺ｪ縺
+ //if ( CDTXMania.stage驕ｸ譖ｲ.bIsEnumeratingSongs )
+ if ( !TJAPlayer3.stage驕ｸ譖ｲ.bIsPlayingPremovie )
+ {
+ EnumSongs.Resume(); // #27060 2012.2.6 yyagi 荳ｭ豁｢縺励※縺縺溘ヰ繝繧ｯ繧ｰ繝ｩ繝ｳ繝画峇讀懃ｴ｢繧貞埼幕
+ EnumSongs.IsSlowdown = false;
+ }
+ else
+ {
+ // EnumSongs.Suspend(); // #27060 2012.3.2 yyagi #PREMOVIE蜀咲函荳ｭ縺ｯ譖ｲ讀懃ｴ｢繧剃ｽ朱溷喧
+ EnumSongs.IsSlowdown = true;
+ }
+ actEnumSongs.On豢ｻ諤ｧ蛹();
+ break;
+
+ case 2: // 譖ｲ豎ｺ螳
+ EnumSongs.Suspend(); // #27060 繝舌ャ繧ｯ繧ｰ繝ｩ繧ｦ繝ｳ繝峨ｮ譖ｲ讀懃ｴ｢繧剃ｸ譎ょ●豁｢
+ actEnumSongs.On髱樊ｴｻ諤ｧ蛹();
+ break;
+ }
+ }
+ #endregion
+
+ #region [ 譖ｲ謗｢邏｢荳ｭ譁ｭ蠕縺｡蠕讖 ]
+ if ( r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ.e繧ｹ繝繝ｼ繧ｸID == CStage.E繧ｹ繝繝ｼ繧ｸ.譖ｲ隱ｭ縺ｿ霎ｼ縺ｿ && !EnumSongs.IsSongListEnumCompletelyDone &&
+ EnumSongs.thDTXFileEnumerate != null ) // #28700 2012.6.12 yyagi; at Compact mode, enumerating thread does not exist.
+ {
+ EnumSongs.WaitUntilSuspended(); // 蠢ｵ縺ｮ縺溘ａ縲∵峇讀懃ｴ｢縺御ｸ譎ゆｸｭ譁ｭ縺輔ｌ繧九∪縺ｧ蠕讖
+ }
+ #endregion
+
+ #region [ 譖ｲ讀懃ｴ｢縺悟ｮ御ｺ縺励◆繧峨∝ｮ滄圀縺ｮ譖ｲ繝ｪ繧ｹ繝医↓蜿肴丐縺吶ｋ ]
+ // CStage驕ｸ譖ｲ.On豢ｻ諤ｧ蛹() 縺ｫ蝗槭＠縺滓婿縺後＞縺縺九↑ｼ
+ if ( EnumSongs.IsSongListEnumerated )
+ {
+ actEnumSongs.On髱樊ｴｻ諤ｧ蛹();
+ TJAPlayer3.stage驕ｸ譖ｲ.bIsEnumeratingSongs = false;
+
+ bool bRemakeSongTitleBar = ( r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ.e繧ｹ繝繝ｼ繧ｸID == CStage.E繧ｹ繝繝ｼ繧ｸ.驕ｸ譖ｲ ) ? true : false;
+ TJAPlayer3.stage驕ｸ譖ｲ.Refresh( EnumSongs.Songs邂｡逅, bRemakeSongTitleBar );
+ EnumSongs.SongListEnumCompletelyDone();
+ }
+ #endregion
+ }
+ break;
+ }
+ #endregion
+
+ switch ( r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ.e繧ｹ繝繝ｼ繧ｸID )
+ {
+ case CStage.E繧ｹ繝繝ｼ繧ｸ.菴輔ｂ縺励↑縺:
+ break;
+
+ case CStage.E繧ｹ繝繝ｼ繧ｸ.襍ｷ蜍:
+ #region [ *** ]
+ //-----------------------------
+ if( this.n騾ｲ陦梧緒逕ｻ縺ｮ謌ｻ繧雁､ != 0 )
+ {
+ if( !b繧ｳ繝ｳ繝代け繝医Δ繝ｼ繝 )
+ {
+ r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ.On髱樊ｴｻ諤ｧ蛹();
+ Trace.TraceInformation( "----------------------" );
+ Trace.TraceInformation( "笆 繧ｿ繧､繝医Ν" );
+ stage繧ｿ繧､繝医Ν.On豢ｻ諤ｧ蛹();
+ r逶ｴ蜑阪ｮ繧ｹ繝繝ｼ繧ｸ = r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ;
+ r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ = stage繧ｿ繧､繝医Ν;
+ }
+ else
+ {
+ r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ.On髱樊ｴｻ諤ｧ蛹();
+ Trace.TraceInformation( "----------------------" );
+ Trace.TraceInformation( "笆 譖ｲ隱ｭ縺ｿ霎ｼ縺ｿ" );
+ stage譖ｲ隱ｭ縺ｿ霎ｼ縺ｿ.On豢ｻ諤ｧ蛹();
+ r逶ｴ蜑阪ｮ繧ｹ繝繝ｼ繧ｸ = r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ;
+ r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ = stage譖ｲ隱ｭ縺ｿ霎ｼ縺ｿ;
+ }
+ foreach( STPlugin pg in this.list繝励Λ繧ｰ繧､繝ｳ )
+ {
+ Directory.SetCurrentDirectory( pg.str繝励Λ繧ｰ繧､繝ｳ繝輔か繝ｫ繝 );
+ pg.plugin.On繧ｹ繝繝ｼ繧ｸ螟画峩();
+ Directory.SetCurrentDirectory( TJAPlayer3.strEXE縺ｮ縺ゅｋ繝輔か繝ｫ繝 );
+ }
+
+ this.t繧ｬ繝吶ｼ繧ｸ繧ｳ繝ｬ繧ｯ繧ｷ繝ｧ繝ｳ繧貞ｮ溯｡後☆繧();
+ }
+ //-----------------------------
+ #endregion
+ break;
+
+ case CStage.E繧ｹ繝繝ｼ繧ｸ.繧ｿ繧､繝医Ν:
+ #region [ *** ]
+ //-----------------------------
+ switch( this.n騾ｲ陦梧緒逕ｻ縺ｮ謌ｻ繧雁､ )
+ {
+ case (int)CStage繧ｿ繧､繝医Ν.E謌ｻ繧雁､.GAMESTART:
+ #region [ 驕ｸ譖ｲ蜃ｦ逅縺ｸ ]
+ //-----------------------------
+ r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ.On髱樊ｴｻ諤ｧ蛹();
+ Trace.TraceInformation( "----------------------" );
+ Trace.TraceInformation( "笆 驕ｸ譖ｲ" );
+ stage驕ｸ譖ｲ.On豢ｻ諤ｧ蛹();
+ r逶ｴ蜑阪ｮ繧ｹ繝繝ｼ繧ｸ = r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ;
+ r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ = stage驕ｸ譖ｲ;
+ //-----------------------------
+ #endregion
+ break;
+
+ case (int)CStage繧ｿ繧､繝医Ν.E謌ｻ繧雁､.DANGAMESTART:
+ #region [ 谿ｵ菴埼∈謚槫ｦ逅縺ｸ ]
+ //-----------------------------
+ r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ.On髱樊ｴｻ諤ｧ蛹();
+ Trace.TraceInformation( "----------------------" );
+ Trace.TraceInformation( "笆 谿ｵ菴埼∈謚" );
+ stage谿ｵ菴埼∈謚.On豢ｻ諤ｧ蛹();
+ r逶ｴ蜑阪ｮ繧ｹ繝繝ｼ繧ｸ = r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ;
+ r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ = stage谿ｵ菴埼∈謚;
+ //-----------------------------
+ #endregion
+ break;
+
+ #region [ OPTION: 蟒豁｢貂 ]
+// case 2: // #24525 OPTION縺ｨCONFIG縺ｮ邨ｱ蜷医↓莨ｴ縺縲＾PTION縺ｯ蟒豁｢
+// #region [ *** ]
+// //-----------------------------
+// r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ.On髱樊ｴｻ諤ｧ蛹();
+// Trace.TraceInformation( "----------------------" );
+// Trace.TraceInformation( "笆 繧ｪ繝励す繝ｧ繝ｳ" );
+// stage繧ｪ繝励す繝ｧ繝ｳ.On豢ｻ諤ｧ蛹();
+// r逶ｴ蜑阪ｮ繧ｹ繝繝ｼ繧ｸ = r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ;
+// r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ = stage繧ｪ繝励す繝ｧ繝ｳ;
+// //-----------------------------
+// #endregion
+ // break;
+ #endregion
+
+ case (int)CStage繧ｿ繧､繝医Ν.E謌ｻ繧雁､.CONFIG:
+ #region [ *** ]
+ //-----------------------------
+ r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ.On髱樊ｴｻ諤ｧ蛹();
+ Trace.TraceInformation( "----------------------" );
+ Trace.TraceInformation( "笆 繧ｳ繝ｳ繝輔ぅ繧ｰ" );
+ stage繧ｳ繝ｳ繝輔ぅ繧ｰ.On豢ｻ諤ｧ蛹();
+ r逶ｴ蜑阪ｮ繧ｹ繝繝ｼ繧ｸ = r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ;
+ r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ = stage繧ｳ繝ｳ繝輔ぅ繧ｰ;
+ //-----------------------------
+ #endregion
+ break;
+
+ case (int)CStage繧ｿ繧､繝医Ν.E謌ｻ繧雁､.EXIT:
+ #region [ *** ]
+ //-----------------------------
+ r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ.On髱樊ｴｻ諤ｧ蛹();
+ Trace.TraceInformation( "----------------------" );
+ Trace.TraceInformation( "笆 邨ゆｺ" );
+ stage邨ゆｺ.On豢ｻ諤ｧ蛹();
+ r逶ｴ蜑阪ｮ繧ｹ繝繝ｼ繧ｸ = r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ;
+ r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ = stage邨ゆｺ;
+ //-----------------------------
+ #endregion
+ break;
+ }
+
+ foreach( STPlugin pg in this.list繝励Λ繧ｰ繧､繝ｳ )
+ {
+ Directory.SetCurrentDirectory( pg.str繝励Λ繧ｰ繧､繝ｳ繝輔か繝ｫ繝 );
+ pg.plugin.On繧ｹ繝繝ｼ繧ｸ螟画峩();
+ Directory.SetCurrentDirectory( TJAPlayer3.strEXE縺ｮ縺ゅｋ繝輔か繝ｫ繝 );
+ }
+
+ //this.t繧ｬ繝吶ｼ繧ｸ繧ｳ繝ｬ繧ｯ繧ｷ繝ｧ繝ｳ繧貞ｮ溯｡後☆繧(); // #31980 2013.9.3 yyagi 繧ｿ繧､繝医Ν逕ｻ髱｢縺ｧ縺縺代∵ｯ弱ヵ繝ｬ繝ｼ繝GC繧貞ｮ溯｡後＠縺ｦ驥阪￥縺ｪ縺｣縺ｦ縺縺溷撫鬘後ｮ菫ｮ豁｣
+ //-----------------------------
+ #endregion
+ break;
+
+ case CStage.E繧ｹ繝繝ｼ繧ｸ.繧ｳ繝ｳ繝輔ぅ繧ｰ:
+ #region [ *** ]
+ //-----------------------------
+ if( this.n騾ｲ陦梧緒逕ｻ縺ｮ謌ｻ繧雁､ != 0 )
+ {
+ switch( r逶ｴ蜑阪ｮ繧ｹ繝繝ｼ繧ｸ.e繧ｹ繝繝ｼ繧ｸID )
+ {
+ case CStage.E繧ｹ繝繝ｼ繧ｸ.繧ｿ繧､繝医Ν:
+ #region [ *** ]
+ //-----------------------------
+ r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ.On髱樊ｴｻ諤ｧ蛹();
+ Trace.TraceInformation( "----------------------" );
+ Trace.TraceInformation( "笆 繧ｿ繧､繝医Ν" );
+ stage繧ｿ繧､繝医Ν.On豢ｻ諤ｧ蛹();
+ r逶ｴ蜑阪ｮ繧ｹ繝繝ｼ繧ｸ = r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ;
+ r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ = stage繧ｿ繧､繝医Ν;
+
+ foreach( STPlugin pg in this.list繝励Λ繧ｰ繧､繝ｳ )
+ {
+ Directory.SetCurrentDirectory( pg.str繝励Λ繧ｰ繧､繝ｳ繝輔か繝ｫ繝 );
+ pg.plugin.On繧ｹ繝繝ｼ繧ｸ螟画峩();
+ Directory.SetCurrentDirectory( TJAPlayer3.strEXE縺ｮ縺ゅｋ繝輔か繝ｫ繝 );
+ }
+
+ this.t繧ｬ繝吶ｼ繧ｸ繧ｳ繝ｬ繧ｯ繧ｷ繝ｧ繝ｳ繧貞ｮ溯｡後☆繧();
+ break;
+ //-----------------------------
+ #endregion
+
+ case CStage.E繧ｹ繝繝ｼ繧ｸ.驕ｸ譖ｲ:
+ #region [ *** ]
+ //-----------------------------
+ r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ.On髱樊ｴｻ諤ｧ蛹();
+ Trace.TraceInformation( "----------------------" );
+ Trace.TraceInformation( "笆 驕ｸ譖ｲ" );
+ stage驕ｸ譖ｲ.On豢ｻ諤ｧ蛹();
+ r逶ｴ蜑阪ｮ繧ｹ繝繝ｼ繧ｸ = r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ;
+ r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ = stage驕ｸ譖ｲ;
+
+ foreach( STPlugin pg in this.list繝励Λ繧ｰ繧､繝ｳ )
+ {
+ Directory.SetCurrentDirectory( pg.str繝励Λ繧ｰ繧､繝ｳ繝輔か繝ｫ繝 );
+ pg.plugin.On繧ｹ繝繝ｼ繧ｸ螟画峩();
+ Directory.SetCurrentDirectory( TJAPlayer3.strEXE縺ｮ縺ゅｋ繝輔か繝ｫ繝 );
+ }
+
+ this.t繧ｬ繝吶ｼ繧ｸ繧ｳ繝ｬ繧ｯ繧ｷ繝ｧ繝ｳ繧貞ｮ溯｡後☆繧();
+ break;
+ //-----------------------------
+ #endregion
+ }
+ }
+ //-----------------------------
+ #endregion
+ break;
+
+ case CStage.E繧ｹ繝繝ｼ繧ｸ.驕ｸ譖ｲ:
+ #region [ *** ]
+ //-----------------------------
+ switch( this.n騾ｲ陦梧緒逕ｻ縺ｮ謌ｻ繧雁､ )
+ {
+ case (int) CStage驕ｸ譖ｲ.E謌ｻ繧雁､.繧ｿ繧､繝医Ν縺ｫ謌ｻ繧:
+ #region [ *** ]
+ //-----------------------------
+ r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ.On髱樊ｴｻ諤ｧ蛹();
+ Trace.TraceInformation( "----------------------" );
+ Trace.TraceInformation( "笆 繧ｿ繧､繝医Ν" );
+ stage繧ｿ繧､繝医Ν.On豢ｻ諤ｧ蛹();
+ r逶ｴ蜑阪ｮ繧ｹ繝繝ｼ繧ｸ = r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ;
+ r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ = stage繧ｿ繧､繝医Ν;
+
+ Skin.bgm驕ｸ譖ｲ逕ｻ髱｢繧､繝ｳ.t蛛懈ｭ｢縺吶ｋ();
+ Skin.bgm驕ｸ譖ｲ逕ｻ髱｢.t蛛懈ｭ｢縺吶ｋ();
+ foreach ( STPlugin pg in this.list繝励Λ繧ｰ繧､繝ｳ )
+ {
+ Directory.SetCurrentDirectory( pg.str繝励Λ繧ｰ繧､繝ｳ繝輔か繝ｫ繝 );
+ pg.plugin.On繧ｹ繝繝ｼ繧ｸ螟画峩();
+ Directory.SetCurrentDirectory( TJAPlayer3.strEXE縺ｮ縺ゅｋ繝輔か繝ｫ繝 );
+ }
+
+ this.t繧ｬ繝吶ｼ繧ｸ繧ｳ繝ｬ繧ｯ繧ｷ繝ｧ繝ｳ繧貞ｮ溯｡後☆繧();
+ break;
+ //-----------------------------
+ #endregion
+
+ case (int) CStage驕ｸ譖ｲ.E謌ｻ繧雁､.驕ｸ譖ｲ縺励◆:
+ #region [ *** ]
+ //-----------------------------
+ r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ.On髱樊ｴｻ諤ｧ蛹();
+ Trace.TraceInformation( "----------------------" );
+ Trace.TraceInformation( "笆 譖ｲ隱ｭ縺ｿ霎ｼ縺ｿ" );
+ stage譖ｲ隱ｭ縺ｿ霎ｼ縺ｿ.On豢ｻ諤ｧ蛹();
+ r逶ｴ蜑阪ｮ繧ｹ繝繝ｼ繧ｸ = r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ;
+ r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ = stage譖ｲ隱ｭ縺ｿ霎ｼ縺ｿ;
+
+ Skin.bgm驕ｸ譖ｲ逕ｻ髱｢繧､繝ｳ.t蛛懈ｭ｢縺吶ｋ();
+ Skin.bgm驕ｸ譖ｲ逕ｻ髱｢.t蛛懈ｭ｢縺吶ｋ();
+ foreach ( STPlugin pg in this.list繝励Λ繧ｰ繧､繝ｳ )
+ {
+ Directory.SetCurrentDirectory( pg.str繝励Λ繧ｰ繧､繝ｳ繝輔か繝ｫ繝 );
+ pg.plugin.On繧ｹ繝繝ｼ繧ｸ螟画峩();
+ Directory.SetCurrentDirectory( TJAPlayer3.strEXE縺ｮ縺ゅｋ繝輔か繝ｫ繝 );
+ }
+
+ this.t繧ｬ繝吶ｼ繧ｸ繧ｳ繝ｬ繧ｯ繧ｷ繝ｧ繝ｳ繧貞ｮ溯｡後☆繧();
+ break;
+ //-----------------------------
+ #endregion
+
+// case (int) CStage驕ｸ譖ｲ.E謌ｻ繧雁､.繧ｪ繝励す繝ｧ繝ｳ蜻ｼ縺ｳ蜃ｺ縺:
+ #region [ *** ]
+// //-----------------------------
+// r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ.On髱樊ｴｻ諤ｧ蛹();
+// Trace.TraceInformation( "----------------------" );
+// Trace.TraceInformation( "笆 繧ｪ繝励す繝ｧ繝ｳ" );
+// stage繧ｪ繝励す繝ｧ繝ｳ.On豢ｻ諤ｧ蛹();
+// r逶ｴ蜑阪ｮ繧ｹ繝繝ｼ繧ｸ = r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ;
+// r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ = stage繧ｪ繝励す繝ｧ繝ｳ;
+//
+// foreach( STPlugin pg in this.list繝励Λ繧ｰ繧､繝ｳ )
+// {
+// Directory.SetCurrentDirectory( pg.str繝励Λ繧ｰ繧､繝ｳ繝輔か繝ｫ繝 );
+// pg.plugin.On繧ｹ繝繝ｼ繧ｸ螟画峩();
+// Directory.SetCurrentDirectory( CDTXMania.strEXE縺ｮ縺ゅｋ繝輔か繝ｫ繝 );
+// }
+//
+// this.t繧ｬ繝吶ｼ繧ｸ繧ｳ繝ｬ繧ｯ繧ｷ繝ｧ繝ｳ繧貞ｮ溯｡後☆繧();
+// break;
+// //-----------------------------
+ #endregion
+
+ case (int) CStage驕ｸ譖ｲ.E謌ｻ繧雁､.繧ｳ繝ｳ繝輔ぅ繧ｰ蜻ｼ縺ｳ蜃ｺ縺:
+ #region [ *** ]
+ //-----------------------------
+ r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ.On髱樊ｴｻ諤ｧ蛹();
+ Trace.TraceInformation( "----------------------" );
+ Trace.TraceInformation( "笆 繧ｳ繝ｳ繝輔ぅ繧ｰ" );
+ stage繧ｳ繝ｳ繝輔ぅ繧ｰ.On豢ｻ諤ｧ蛹();
+ r逶ｴ蜑阪ｮ繧ｹ繝繝ｼ繧ｸ = r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ;
+ r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ = stage繧ｳ繝ｳ繝輔ぅ繧ｰ;
+
+ foreach( STPlugin pg in this.list繝励Λ繧ｰ繧､繝ｳ )
+ {
+ Directory.SetCurrentDirectory( pg.str繝励Λ繧ｰ繧､繝ｳ繝輔か繝ｫ繝 );
+ pg.plugin.On繧ｹ繝繝ｼ繧ｸ螟画峩();
+ Directory.SetCurrentDirectory( TJAPlayer3.strEXE縺ｮ縺ゅｋ繝輔か繝ｫ繝 );
+ }
+
+ this.t繧ｬ繝吶ｼ繧ｸ繧ｳ繝ｬ繧ｯ繧ｷ繝ｧ繝ｳ繧貞ｮ溯｡後☆繧();
+ break;
+ //-----------------------------
+ #endregion
+
+ case (int) CStage驕ｸ譖ｲ.E謌ｻ繧雁､.繧ｹ繧ｭ繝ｳ螟画峩:
+
+ #region [ *** ]
+ //-----------------------------
+ r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ.On髱樊ｴｻ諤ｧ蛹();
+ Trace.TraceInformation( "----------------------" );
+ Trace.TraceInformation( "笆 繧ｹ繧ｭ繝ｳ蛻繧頑崛縺" );
+ stageChangeSkin.On豢ｻ諤ｧ蛹();
+ r逶ｴ蜑阪ｮ繧ｹ繝繝ｼ繧ｸ = r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ;
+ r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ = stageChangeSkin;
+ break;
+ //-----------------------------
+ #endregion
+ }
+ //-----------------------------
+ #endregion
+ break;
+
+ case CStage.E繧ｹ繝繝ｼ繧ｸ.谿ｵ菴埼∈謚:
+ #region [ *** ]
+ switch (this.n騾ｲ陦梧緒逕ｻ縺ｮ謌ｻ繧雁､)
+ {
+ case (int)CStage驕ｸ譖ｲ.E謌ｻ繧雁､.繧ｿ繧､繝医Ν縺ｫ謌ｻ繧:
+ #region [ *** ]
+ //-----------------------------
+ r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ.On髱樊ｴｻ諤ｧ蛹();
+ Trace.TraceInformation("----------------------");
+ Trace.TraceInformation("笆 繧ｿ繧､繝医Ν");
+ stage繧ｿ繧､繝医Ν.On豢ｻ諤ｧ蛹();
+ r逶ｴ蜑阪ｮ繧ｹ繝繝ｼ繧ｸ = r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ;
+ r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ = stage繧ｿ繧､繝医Ν;
+
+ Skin.bgm驕ｸ譖ｲ逕ｻ髱｢繧､繝ｳ.t蛛懈ｭ｢縺吶ｋ();
+ Skin.bgm驕ｸ譖ｲ逕ｻ髱｢.t蛛懈ｭ｢縺吶ｋ();
+ foreach (STPlugin pg in this.list繝励Λ繧ｰ繧､繝ｳ)
+ {
+ Directory.SetCurrentDirectory(pg.str繝励Λ繧ｰ繧､繝ｳ繝輔か繝ｫ繝);
+ pg.plugin.On繧ｹ繝繝ｼ繧ｸ螟画峩();
+ Directory.SetCurrentDirectory(TJAPlayer3.strEXE縺ｮ縺ゅｋ繝輔か繝ｫ繝);
+ }
+
+ this.t繧ｬ繝吶ｼ繧ｸ繧ｳ繝ｬ繧ｯ繧ｷ繝ｧ繝ｳ繧貞ｮ溯｡後☆繧();
+ break;
+ //-----------------------------
+ #endregion
+
+ case (int)CStage驕ｸ譖ｲ.E謌ｻ繧雁､.驕ｸ譖ｲ縺励◆:
+ #region [ *** ]
+ //-----------------------------
+ r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ.On髱樊ｴｻ諤ｧ蛹();
+ Trace.TraceInformation("----------------------");
+ Trace.TraceInformation("笆 譖ｲ隱ｭ縺ｿ霎ｼ縺ｿ");
+ stage譖ｲ隱ｭ縺ｿ霎ｼ縺ｿ.On豢ｻ諤ｧ蛹();
+ r逶ｴ蜑阪ｮ繧ｹ繝繝ｼ繧ｸ = r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ;
+ r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ = stage譖ｲ隱ｭ縺ｿ霎ｼ縺ｿ;
+
+ foreach (STPlugin pg in this.list繝励Λ繧ｰ繧､繝ｳ)
+ {
+ Directory.SetCurrentDirectory(pg.str繝励Λ繧ｰ繧､繝ｳ繝輔か繝ｫ繝);
+ pg.plugin.On繧ｹ繝繝ｼ繧ｸ螟画峩();
+ Directory.SetCurrentDirectory(TJAPlayer3.strEXE縺ｮ縺ゅｋ繝輔か繝ｫ繝);
+ }
+
+ this.t繧ｬ繝吶ｼ繧ｸ繧ｳ繝ｬ繧ｯ繧ｷ繝ｧ繝ｳ繧貞ｮ溯｡後☆繧();
+ break;
+ //-----------------------------
+ #endregion
+ }
+ #endregion
+ break;
+
+ case CStage.E繧ｹ繝繝ｼ繧ｸ.譖ｲ隱ｭ縺ｿ霎ｼ縺ｿ:
+ #region [ *** ]
+ //-----------------------------
+ DTXVmode.Refreshed = false; // 譖ｲ縺ｮ繝ｪ繝ｭ繝ｼ繝我ｸｭ縺ｫ逋ｺ逕溘＠縺溷阪Μ繝ｭ繝ｼ繝峨ｯ縲∫┌隕悶☆繧九
+ if( this.n騾ｲ陦梧緒逕ｻ縺ｮ謌ｻ繧雁､ != 0 )
+ {
+ TJAPlayer3.Pad.st讀懃衍縺励◆繝繝舌う繧ｹ.Clear(); // 蜈･蜉帙ョ繝舌う繧ｹ繝輔Λ繧ｰ繧ｯ繝ｪ繧｢(2010.9.11)
+ r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ.On髱樊ｴｻ諤ｧ蛹();
+ #region [ ESC謚ｼ荳区凾縺ｯ縲∵峇縺ｮ隱ｭ縺ｿ霎ｼ縺ｿ繧剃ｸｭ豁｢縺励※驕ｸ譖ｲ逕ｻ髱｢縺ｫ謌ｻ繧 ]
+ if ( this.n騾ｲ陦梧緒逕ｻ縺ｮ謌ｻ繧雁､ == (int) E譖ｲ隱ｭ霎ｼ逕ｻ髱｢縺ｮ謌ｻ繧雁､.隱ｭ霎ｼ荳ｭ豁｢ )
+ {
+ //DTX.t蜈ｨ繝√ャ繝励ｮ蜀咲函蛛懈ｭ｢();
+ if( DTX != null )
+ DTX.On髱樊ｴｻ諤ｧ蛹();
+ if (stage驕ｸ譖ｲ.n遒ｺ螳壹＆繧後◆譖ｲ縺ｮ髮｣譏灘ｺｦ[0] == (int)Difficulty.Dan)
+ {
+ Trace.TraceInformation("----------------------");
+ Trace.TraceInformation("笆 谿ｵ菴埼∈謚");
+ stage谿ｵ菴埼∈謚.On豢ｻ諤ｧ蛹();
+ r逶ｴ蜑阪ｮ繧ｹ繝繝ｼ繧ｸ = r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ;
+ r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ = stage谿ｵ菴埼∈謚;
+ }
+ else
+ {
+ Trace.TraceInformation("----------------------");
+ Trace.TraceInformation("笆 驕ｸ譖ｲ");
+ stage驕ｸ譖ｲ.On豢ｻ諤ｧ蛹();
+ r逶ｴ蜑阪ｮ繧ｹ繝繝ｼ繧ｸ = r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ;
+ r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ = stage驕ｸ譖ｲ;
+ }
+ foreach ( STPlugin pg in this.list繝励Λ繧ｰ繧､繝ｳ )
+ {
+ Directory.SetCurrentDirectory( pg.str繝励Λ繧ｰ繧､繝ｳ繝輔か繝ｫ繝 );
+ pg.plugin.On繧ｹ繝繝ｼ繧ｸ螟画峩();
+ Directory.SetCurrentDirectory( TJAPlayer3.strEXE縺ｮ縺ゅｋ繝輔か繝ｫ繝 );
+ }
+ break;
+ }
+ #endregion
+
+ Trace.TraceInformation( "----------------------" );
+ Trace.TraceInformation( "笆 貍泌･擾ｼ医ラ繝ｩ繝逕ｻ髱｢ｼ" );
+#if false // #23625 2011.1.11 Config.ini縺九ｉ繝繝｡繝ｼ繧ｸ/蝗槫ｾｩ蛟､縺ｮ螳壽焚螟画峩繧定｡後≧蝣ｴ蜷医ｯ縺薙％繧呈怏蜉ｹ縺ｫ縺吶ｋ 087繝ｪ繝ｪ繝ｼ繧ｹ縺ｫ蜷医ｏ縺帶ｩ溯ｽ辟｡蜉ｹ蛹
+for (int i = 0; i < 5; i++)
+{
+ for (int j = 0; j < 2; j++)
+ {
+ stage貍泌･上ラ繝ｩ繝逕ｻ髱｢.fDamageGaugeDelta[i, j] = ConfigIni.fGaugeFactor[i, j];
+ }
+}
+for (int i = 0; i < 3; i++) {
+ stage貍泌･上ラ繝ｩ繝逕ｻ髱｢.fDamageLevelFactor[i] = ConfigIni.fDamageLevelFactor[i];
+}
+#endif
+ r逶ｴ蜑阪ｮ繧ｹ繝繝ｼ繧ｸ = r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ;
+ r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ = stage貍泌･上ラ繝ｩ繝逕ｻ髱｢;
+ foreach( STPlugin pg in this.list繝励Λ繧ｰ繧､繝ｳ )
+ {
+ Directory.SetCurrentDirectory( pg.str繝励Λ繧ｰ繧､繝ｳ繝輔か繝ｫ繝 );
+ pg.plugin.On繧ｹ繝繝ｼ繧ｸ螟画峩();
+ Directory.SetCurrentDirectory( TJAPlayer3.strEXE縺ｮ縺ゅｋ繝輔か繝ｫ繝 );
+ }
+
+ this.t繧ｬ繝吶ｼ繧ｸ繧ｳ繝ｬ繧ｯ繧ｷ繝ｧ繝ｳ繧貞ｮ溯｡後☆繧();
+ }
+ //-----------------------------
+ #endregion
+ break;
+
+ case CStage.E繧ｹ繝繝ｼ繧ｸ.貍泌･:
+ #region [ *** ]
+ //-----------------------------
+ //long n1 = FDK.CSound邂｡逅.rc貍泌･冗畑繧ｿ繧､繝.n繧ｷ繧ｹ繝繝譎ょ綾ms;
+ //long n2 = FDK.CSound邂｡逅.SoundDevice.n邨碁℃譎る俣ms;
+ //long n3 = FDK.CSound邂｡逅.SoundDevice.tm繧ｷ繧ｹ繝繝繧ｿ繧､繝.n繧ｷ繧ｹ繝繝譎ょ綾ms;
+ //long n4 = FDK.CSound邂｡逅.rc貍泌･冗畑繧ｿ繧､繝.n迴ｾ蝨ｨ譎ょ綾;
+ //long n5 = FDK.CSound邂｡逅.SoundDevice.n邨碁℃譎る俣繧呈峩譁ｰ縺励◆繧ｷ繧ｹ繝繝譎ょ綾ms;
+
+ //swlist1.Add( Convert.ToInt32(n1) );
+ //swlist2.Add( Convert.ToInt32(n2) );
+ //swlist3.Add( Convert.ToInt32( n3 ) );
+ //swlist4.Add( Convert.ToInt32( n4 ) );
+ //swlist5.Add( Convert.ToInt32( n5 ) );
+
+ #region [ DTXV繝｢繝ｼ繝我ｸｭ縺ｫDTXCreator縺九ｉ謖遉ｺ繧貞女縺代◆蝣ｴ蜷医ｮ蜃ｦ逅 ]
+ if ( DTXVmode.Enabled && DTXVmode.Refreshed )
+ {
+ DTXVmode.Refreshed = false;
+
+ if ( DTXVmode.Command == CDTXVmode.ECommand.Stop )
+ {
+ TJAPlayer3.stage貍泌･上ラ繝ｩ繝逕ｻ髱｢.t蛛懈ｭ｢();
+ if ( previewSound != null )
+ {
+ this.previewSound.t繧ｵ繧ｦ繝ｳ繝峨ｒ蛛懈ｭ｢縺吶ｋ();
+ this.previewSound.Dispose();
+ this.previewSound = null;
+ }
+ //{
+ // int lastd = 0;
+ // int f = 0;
+ // for ( int i = 0; i < swlist1.Count; i++ )
+ // {
+ // int d1 = swlist1[ i ];
+ // int d2 = swlist2[ i ];
+ // int d3 = swlist3[ i ];
+ // int d4 = swlist4[ i ];
+ // int d5 = swlist5[ i ];
+
+ // int dif = d1 - lastd;
+ // string s = "";
+ // if ( 16 <= dif && dif <= 17 )
+ // {
+ // }
+ // else
+ // {
+ // s = "笘";
+ // }
+ // Trace.TraceInformation( "frame {0:D4}: {1:D3} ( {2:D3}, {3:D3} - {7:D3}, {4:D3} ) {5}, n迴ｾ蝨ｨ譎ょ綾={6}", f, dif, d1, d2, d3, s, d4, d5 );
+ // lastd = d1;
+ // f++;
+ // }
+ // swlist1.Clear();
+ // swlist2.Clear();
+ // swlist3.Clear();
+ // swlist4.Clear();
+ // swlist5.Clear();
+
+ //}
+ }
+ else if ( DTXVmode.Command == CDTXVmode.ECommand.Play )
+ {
+ if ( DTXVmode.NeedReload )
+ {
+ TJAPlayer3.stage貍泌･上ラ繝ｩ繝逕ｻ髱｢.t蜀崎ｪｭ霎ｼ();
+
+ TJAPlayer3.ConfigIni.bTimeStretch = DTXVmode.TimeStretch;
+ CSound邂｡逅.bIsTimeStretch = DTXVmode.TimeStretch;
+ if ( TJAPlayer3.ConfigIni.b蝙ら峩蟶ｰ邱壼ｾ縺｡繧定｡後≧ != DTXVmode.VSyncWait )
+ {
+ TJAPlayer3.ConfigIni.b蝙ら峩蟶ｰ邱壼ｾ縺｡繧定｡後≧ = DTXVmode.VSyncWait;
+ TJAPlayer3.app.b谺｡縺ｮ繧ｿ繧､繝溘Φ繧ｰ縺ｧ蝙ら峩蟶ｰ邱壼酔譛溷繧頑崛縺医ｒ陦後≧ = true;
+ }
+ }
+ else
+ {
+ TJAPlayer3.stage貍泌･上ラ繝ｩ繝逕ｻ髱｢.t貍泌･丈ｽ咲ｽｮ縺ｮ螟画峩( TJAPlayer3.DTXVmode.nStartBar, 0 );
+ }
+ }
+ }
+ #endregion
+
+ switch( this.n騾ｲ陦梧緒逕ｻ縺ｮ謌ｻ繧雁､ )
+ {
+ case (int) E貍泌･冗判髱｢縺ｮ謌ｻ繧雁､.蜀崎ｪｭ霎ｼ_蜀肴ｼ泌･:
+ #region [ DTX繝輔ぃ繧､繝ｫ繧貞崎ｪｭ縺ｿ霎ｼ縺ｿ縺励※縲∝肴ｼ泌･ ]
+ DTX.t蜈ｨ繝√ャ繝励ｮ蜀咲函蛛懈ｭ｢();
+ DTX.On髱樊ｴｻ諤ｧ蛹();
+ r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ.On髱樊ｴｻ諤ｧ蛹();
+ stage譖ｲ隱ｭ縺ｿ霎ｼ縺ｿ.On豢ｻ諤ｧ蛹();
+ r逶ｴ蜑阪ｮ繧ｹ繝繝ｼ繧ｸ = r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ;
+ r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ = stage譖ｲ隱ｭ縺ｿ霎ｼ縺ｿ;
+ this.t繧ｬ繝吶ｼ繧ｸ繧ｳ繝ｬ繧ｯ繧ｷ繝ｧ繝ｳ繧貞ｮ溯｡後☆繧();
+ break;
+ #endregion
+
+ //case (int) E貍泌･冗判髱｢縺ｮ謌ｻ繧雁､.蜀肴ｼ泌･:
+ #region [ 蜀崎ｪｭ縺ｿ霎ｼ縺ｿ辟｡縺励〒縲∝肴ｼ泌･ ]
+ #endregion
+ // break;
+
+ case (int) E貍泌･冗判髱｢縺ｮ謌ｻ繧雁､.邯咏ｶ:
+ break;
+
+ case (int) E貍泌･冗判髱｢縺ｮ謌ｻ繧雁､.貍泌･丈ｸｭ譁ｭ:
+ #region [ 貍泌･上く繝｣繝ｳ繧ｻ繝ｫ ]
+ //-----------------------------
+ scoreIni = this.tScoreIni縺ｸBGMAdjust縺ｨHistory縺ｨPlayCount繧呈峩譁ｰ( "Play canceled" );
+
+ #region [ 繝励Λ繧ｰ繧､繝ｳ On貍泌･上く繝｣繝ｳ繧ｻ繝ｫ() 縺ｮ蜻ｼ縺ｳ蜃ｺ縺 ]
+ //---------------------
+ foreach( STPlugin pg in this.list繝励Λ繧ｰ繧､繝ｳ )
+ {
+ Directory.SetCurrentDirectory( pg.str繝励Λ繧ｰ繧､繝ｳ繝輔か繝ｫ繝 );
+ pg.plugin.On貍泌･上く繝｣繝ｳ繧ｻ繝ｫ( scoreIni );
+ Directory.SetCurrentDirectory( TJAPlayer3.strEXE縺ｮ縺ゅｋ繝輔か繝ｫ繝 );
+ }
+ //---------------------
+ #endregion
+
+ DTX.t蜈ｨ繝√ャ繝励ｮ蜀咲函蛛懈ｭ｢();
+ DTX.On髱樊ｴｻ諤ｧ蛹();
+ r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ.On髱樊ｴｻ諤ｧ蛹();
+ if( b繧ｳ繝ｳ繝代け繝医Δ繝ｼ繝 )
+ {
+ base.Window.Close();
+ }
+ else
+ {
+ if(stage驕ｸ譖ｲ.n遒ｺ螳壹＆繧後◆譖ｲ縺ｮ髮｣譏灘ｺｦ[0] == (int)Difficulty.Dan)
+ {
+ Trace.TraceInformation("----------------------");
+ Trace.TraceInformation("笆 谿ｵ菴埼∈謚");
+ stage谿ｵ菴埼∈謚.On豢ｻ諤ｧ蛹();
+ r逶ｴ蜑阪ｮ繧ｹ繝繝ｼ繧ｸ = r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ;
+ r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ = stage谿ｵ菴埼∈謚;
+ }
+ else
+ {
+ Trace.TraceInformation("----------------------");
+ Trace.TraceInformation("笆 驕ｸ譖ｲ");
+ stage驕ｸ譖ｲ.On豢ｻ諤ｧ蛹();
+ r逶ｴ蜑阪ｮ繧ｹ繝繝ｼ繧ｸ = r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ;
+ r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ = stage驕ｸ譖ｲ;
+ }
+
+ #region [ 繝励Λ繧ｰ繧､繝ｳ On繧ｹ繝繝ｼ繧ｸ螟画峩() 縺ｮ蜻ｼ縺ｳ蜃ｺ縺 ]
+ //---------------------
+ foreach ( STPlugin pg in this.list繝励Λ繧ｰ繧､繝ｳ )
+ {
+ Directory.SetCurrentDirectory( pg.str繝励Λ繧ｰ繧､繝ｳ繝輔か繝ｫ繝 );
+ pg.plugin.On繧ｹ繝繝ｼ繧ｸ螟画峩();
+ Directory.SetCurrentDirectory( TJAPlayer3.strEXE縺ｮ縺ゅｋ繝輔か繝ｫ繝 );
+ }
+ //---------------------
+ #endregion
+
+ this.t繧ｬ繝吶ｼ繧ｸ繧ｳ繝ｬ繧ｯ繧ｷ繝ｧ繝ｳ繧貞ｮ溯｡後☆繧();
+ }
+ this.t繧ｬ繝吶ｼ繧ｸ繧ｳ繝ｬ繧ｯ繧ｷ繝ｧ繝ｳ繧貞ｮ溯｡後☆繧();
+ break;
+ //-----------------------------
+ #endregion
+
+ case (int) E貍泌･冗判髱｢縺ｮ謌ｻ繧雁､.繧ｹ繝繝ｼ繧ｸ螟ｱ謨:
+ #region [ 貍泌･丞､ｱ謨(StageFailed) ]
+ //-----------------------------
+ scoreIni = this.tScoreIni縺ｸBGMAdjust縺ｨHistory縺ｨPlayCount繧呈峩譁ｰ( "Stage failed" );
+
+ #region [ 繝励Λ繧ｰ繧､繝ｳ On貍泌･丞､ｱ謨() 縺ｮ蜻ｼ縺ｳ蜃ｺ縺 ]
+ //---------------------
+ foreach( STPlugin pg in this.list繝励Λ繧ｰ繧､繝ｳ )
+ {
+ Directory.SetCurrentDirectory( pg.str繝励Λ繧ｰ繧､繝ｳ繝輔か繝ｫ繝 );
+ pg.plugin.On貍泌･丞､ｱ謨( scoreIni );
+ Directory.SetCurrentDirectory( TJAPlayer3.strEXE縺ｮ縺ゅｋ繝輔か繝ｫ繝 );
+ }
+ //---------------------
+ #endregion
+
+ DTX.t蜈ｨ繝√ャ繝励ｮ蜀咲函蛛懈ｭ｢();
+ DTX.On髱樊ｴｻ諤ｧ蛹();
+ r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ.On髱樊ｴｻ諤ｧ蛹();
+ if( b繧ｳ繝ｳ繝代け繝医Δ繝ｼ繝 )
+ {
+ base.Window.Close();
+ }
+ else
+ {
+ Trace.TraceInformation( "----------------------" );
+ Trace.TraceInformation( "笆 驕ｸ譖ｲ" );
+ stage驕ｸ譖ｲ.On豢ｻ諤ｧ蛹();
+ r逶ｴ蜑阪ｮ繧ｹ繝繝ｼ繧ｸ = r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ;
+ r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ = stage驕ｸ譖ｲ;
+
+ #region [ 繝励Λ繧ｰ繧､繝ｳ On繧ｹ繝繝ｼ繧ｸ螟画峩() 縺ｮ蜻ｼ縺ｳ蜃ｺ縺 ]
+ //---------------------
+ foreach( STPlugin pg in this.list繝励Λ繧ｰ繧､繝ｳ )
+ {
+ Directory.SetCurrentDirectory( pg.str繝励Λ繧ｰ繧､繝ｳ繝輔か繝ｫ繝 );
+ pg.plugin.On繧ｹ繝繝ｼ繧ｸ螟画峩();
+ Directory.SetCurrentDirectory( TJAPlayer3.strEXE縺ｮ縺ゅｋ繝輔か繝ｫ繝 );
+ }
+ //---------------------
+ #endregion
+
+ this.t繧ｬ繝吶ｼ繧ｸ繧ｳ繝ｬ繧ｯ繧ｷ繝ｧ繝ｳ繧貞ｮ溯｡後☆繧();
+ }
+ break;
+ //-----------------------------
+ #endregion
+
+ case (int) E貍泌･冗判髱｢縺ｮ謌ｻ繧雁､.繧ｹ繝繝ｼ繧ｸ繧ｯ繝ｪ繧｢:
+ #region [ 貍泌･上け繝ｪ繧｢ ]
+ //-----------------------------
+ CScoreIni.C貍泌･剰ｨ倬鹸 c貍泌･剰ｨ倬鹸_Drums;
+ stage貍泌･上ラ繝ｩ繝逕ｻ髱｢.t貍泌･冗ｵ先棡繧呈ｼ邏阪☆繧( out c貍泌･剰ｨ倬鹸_Drums );
+
+ double ps = 0.0, gs = 0.0;
+ if ( !c貍泌･剰ｨ倬鹸_Drums.b蜈ｨAUTO縺ｧ縺ゅｋ && c貍泌･剰ｨ倬鹸_Drums.n蜈ｨ繝√ャ繝玲焚 > 0) {
+ ps = c貍泌･剰ｨ倬鹸_Drums.db貍泌･丞梛繧ｹ繧ｭ繝ｫ蛟､;
+ gs = c貍泌･剰ｨ倬鹸_Drums.db繧ｲ繝ｼ繝蝙九せ繧ｭ繝ｫ蛟､;
+ }
+ string str = "Cleared";
+ switch( CScoreIni.t邱丞粋繝ｩ繝ｳ繧ｯ蛟､繧定ｨ育ｮ励＠縺ｦ霑斐☆( c貍泌･剰ｨ倬鹸_Drums, null, null ) )
+ {
+ case (int)CScoreIni.ERANK.SS:
+ str = string.Format( "Cleared (SS: {0:F2})", ps );
+ break;
+
+ case (int) CScoreIni.ERANK.S:
+ str = string.Format( "Cleared (S: {0:F2})", ps );
+ break;
+
+ case (int) CScoreIni.ERANK.A:
+ str = string.Format( "Cleared (A: {0:F2})", ps );
+ break;
+
+ case (int) CScoreIni.ERANK.B:
+ str = string.Format( "Cleared (B: {0:F2})", ps );
+ break;
+
+ case (int) CScoreIni.ERANK.C:
+ str = string.Format( "Cleared (C: {0:F2})", ps );
+ break;
+
+ case (int) CScoreIni.ERANK.D:
+ str = string.Format( "Cleared (D: {0:F2})", ps );
+ break;
+
+ case (int) CScoreIni.ERANK.E:
+ str = string.Format( "Cleared (E: {0:F2})", ps );
+ break;
+
+ case (int)CScoreIni.ERANK.UNKNOWN: // #23534 2010.10.28 yyagi add: 貍泌･上メ繝繝励′0蛟九ｮ縺ｨ縺
+ str = "Cleared (No chips)";
+ break;
+ }
+
+ scoreIni = this.tScoreIni縺ｸBGMAdjust縺ｨHistory縺ｨPlayCount繧呈峩譁ｰ( str );
+
+ #region [ 繝励Λ繧ｰ繧､繝ｳ On貍泌･上け繝ｪ繧｢() 縺ｮ蜻ｼ縺ｳ蜃ｺ縺 ]
+ //---------------------
+ foreach( STPlugin pg in this.list繝励Λ繧ｰ繧､繝ｳ )
+ {
+ Directory.SetCurrentDirectory( pg.str繝励Λ繧ｰ繧､繝ｳ繝輔か繝ｫ繝 );
+ pg.plugin.On貍泌･上け繝ｪ繧｢( scoreIni );
+ Directory.SetCurrentDirectory( TJAPlayer3.strEXE縺ｮ縺ゅｋ繝輔か繝ｫ繝 );
+ }
+ //---------------------
+ #endregion
+
+ r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ.On髱樊ｴｻ諤ｧ蛹();
+ Trace.TraceInformation( "----------------------" );
+ Trace.TraceInformation( "笆 邨先棡" );
+ stage邨先棡.st貍泌･剰ｨ倬鹸.Drums = c貍泌･剰ｨ倬鹸_Drums;
+ stage邨先棡.On豢ｻ諤ｧ蛹();
+ r逶ｴ蜑阪ｮ繧ｹ繝繝ｼ繧ｸ = r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ;
+ r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ = stage邨先棡;
+
+ #region [ 繝励Λ繧ｰ繧､繝ｳ On繧ｹ繝繝ｼ繧ｸ螟画峩() 縺ｮ蜻ｼ縺ｳ蜃ｺ縺 ]
+ //---------------------
+ foreach( STPlugin pg in this.list繝励Λ繧ｰ繧､繝ｳ )
+ {
+ Directory.SetCurrentDirectory( pg.str繝励Λ繧ｰ繧､繝ｳ繝輔か繝ｫ繝 );
+ pg.plugin.On繧ｹ繝繝ｼ繧ｸ螟画峩();
+ Directory.SetCurrentDirectory( TJAPlayer3.strEXE縺ｮ縺ゅｋ繝輔か繝ｫ繝 );
+ }
+ //---------------------
+ #endregion
+
+ break;
+ //-----------------------------
+ #endregion
+ }
+ //-----------------------------
+ #endregion
+ break;
+
+ case CStage.E繧ｹ繝繝ｼ繧ｸ.邨先棡:
+ #region [ *** ]
+ //-----------------------------
+ if( this.n騾ｲ陦梧緒逕ｻ縺ｮ謌ｻ繧雁､ != 0 )
+ {
+ //DTX.t蜈ｨ繝√ャ繝励ｮ蜀咲函荳譎ょ●豁｢();
+ DTX.t蜈ｨ繝√ャ繝励ｮ蜀咲函蛛懈ｭ｢縺ｨ繝溘く繧ｵ繝ｼ縺九ｉ縺ｮ蜑企勁();
+ DTX.On髱樊ｴｻ諤ｧ蛹();
+ r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ.On髱樊ｴｻ諤ｧ蛹();
+ this.t繧ｬ繝吶ｼ繧ｸ繧ｳ繝ｬ繧ｯ繧ｷ繝ｧ繝ｳ繧貞ｮ溯｡後☆繧();
+ if ( !b繧ｳ繝ｳ繝代け繝医Δ繝ｼ繝 )
+ {
+ if (stage驕ｸ譖ｲ.n遒ｺ螳壹＆繧後◆譖ｲ縺ｮ髮｣譏灘ｺｦ[0] == (int)Difficulty.Dan)
+ {
+ Trace.TraceInformation("----------------------");
+ Trace.TraceInformation("笆 谿ｵ菴埼∈謚");
+ stage谿ｵ菴埼∈謚.On豢ｻ諤ｧ蛹();
+ r逶ｴ蜑阪ｮ繧ｹ繝繝ｼ繧ｸ = r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ;
+ r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ = stage谿ｵ菴埼∈謚;
+ }
+ else
+ {
+ Trace.TraceInformation("----------------------");
+ Trace.TraceInformation("笆 驕ｸ譖ｲ");
+ stage驕ｸ譖ｲ.On豢ｻ諤ｧ蛹();
+ r逶ｴ蜑阪ｮ繧ｹ繝繝ｼ繧ｸ = r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ;
+ r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ = stage驕ｸ譖ｲ;
+ }
+ stage驕ｸ譖ｲ.NowSong++;
+
+ foreach( STPlugin pg in this.list繝励Λ繧ｰ繧､繝ｳ )
+ {
+ Directory.SetCurrentDirectory( pg.str繝励Λ繧ｰ繧､繝ｳ繝輔か繝ｫ繝 );
+ pg.plugin.On繧ｹ繝繝ｼ繧ｸ螟画峩();
+ Directory.SetCurrentDirectory( TJAPlayer3.strEXE縺ｮ縺ゅｋ繝輔か繝ｫ繝 );
+ }
+
+ this.t繧ｬ繝吶ｼ繧ｸ繧ｳ繝ｬ繧ｯ繧ｷ繝ｧ繝ｳ繧貞ｮ溯｡後☆繧();
+ }
+ else
+ {
+ base.Window.Close();
+ }
+ }
+ //-----------------------------
+ #endregion
+ break;
+
+ case CStage.E繧ｹ繝繝ｼ繧ｸ.ChangeSkin:
+ #region [ *** ]
+ //-----------------------------
+ if ( this.n騾ｲ陦梧緒逕ｻ縺ｮ謌ｻ繧雁､ != 0 )
+ {
+ r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ.On髱樊ｴｻ諤ｧ蛹();
+ Trace.TraceInformation( "----------------------" );
+ Trace.TraceInformation( "笆 驕ｸ譖ｲ" );
+ stage驕ｸ譖ｲ.On豢ｻ諤ｧ蛹();
+ r逶ｴ蜑阪ｮ繧ｹ繝繝ｼ繧ｸ = r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ;
+ r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ = stage驕ｸ譖ｲ;
+ this.t繧ｬ繝吶ｼ繧ｸ繧ｳ繝ｬ繧ｯ繧ｷ繝ｧ繝ｳ繧貞ｮ溯｡後☆繧();
+ }
+ //-----------------------------
+ #endregion
+ break;
+
+ case CStage.E繧ｹ繝繝ｼ繧ｸ.邨ゆｺ:
+ #region [ *** ]
+ //-----------------------------
+ if( this.n騾ｲ陦梧緒逕ｻ縺ｮ謌ｻ繧雁､ != 0 )
+ {
+ base.Exit();
+ }
+ //-----------------------------
+ #endregion
+ break;
+ }
+
+ actScanningLoudness.On騾ｲ陦梧緒逕ｻ();
+
+ if (r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ != null && r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ.e繧ｹ繝繝ｼ繧ｸID != CStage.E繧ｹ繝繝ｼ繧ｸ.襍ｷ蜍 && TJAPlayer3.Tx.Network_Connection != null)
+ {
+ if (Math.Abs(CSound邂｡逅.rc貍泌･冗畑繧ｿ繧､繝.n繧ｷ繧ｹ繝繝譎ょ綾ms - this.蜑榊屓縺ｮ繧ｷ繧ｹ繝繝譎ょ綾ms) > 10000)
+ {
+ this.蜑榊屓縺ｮ繧ｷ繧ｹ繝繝譎ょ綾ms = CSound邂｡逅.rc貍泌･冗畑繧ｿ繧､繝.n繧ｷ繧ｹ繝繝譎ょ綾ms;
+ Task.Factory.StartNew(() =>
+ {
+ //IPv4 8.8.8.8縺ｫPing繧帝∽ｿ｡縺吶ｋ(timeout 5000ms)
+ PingReply reply = new Ping().Send("8.8.8.8", 5000);
+ this.b繝阪ャ繝医Ρ繝ｼ繧ｯ縺ｫ謗･邯壻ｸｭ = reply.Status == IPStatus.Success;
+ });
+ }
+ TJAPlayer3.Tx.Network_Connection.t2D謠冗判(app.Device, GameWindowSize.Width - (TJAPlayer3.Tx.Network_Connection.sz繝繧ｯ繧ｹ繝√Ε繧ｵ繧､繧ｺ.Width / 2), GameWindowSize.Height - TJAPlayer3.Tx.Network_Connection.sz繝繧ｯ繧ｹ繝√Ε繧ｵ繧､繧ｺ.Height, new Rectangle((TJAPlayer3.Tx.Network_Connection.sz繝繧ｯ繧ｹ繝√Ε繧ｵ繧､繧ｺ.Width / 2) * (this.b繝阪ャ繝医Ρ繝ｼ繧ｯ縺ｫ謗･邯壻ｸｭ ? 0 : 1), 0, TJAPlayer3.Tx.Network_Connection.sz繝繧ｯ繧ｹ繝√Ε繧ｵ繧､繧ｺ.Width / 2, TJAPlayer3.Tx.Network_Connection.sz繝繧ｯ繧ｹ繝√Ε繧ｵ繧､繧ｺ.Height));
+ }
+ // 繧ｪ繝ｼ繝舌Ξ繧､繧呈緒逕ｻ縺吶ｋ(繝繧ｯ繧ｹ繝√Ε縺ｮ逕滓舌＆繧後※縺縺ｪ縺襍ｷ蜍輔せ繝繝ｼ繧ｸ縺ｯ萓句､
+ if (r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ != null && r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ.e繧ｹ繝繝ｼ繧ｸID != CStage.E繧ｹ繝繝ｼ繧ｸ.襍ｷ蜍 && TJAPlayer3.Tx.Overlay != null)
+ {
+ TJAPlayer3.Tx.Overlay.t2D謠冗判(app.Device, 0, 0);
+ }
+ }
+ this.Device.EndScene(); // Present()縺ｯ game.cs縺ｮOnFrameEnd()縺ｫ逋ｻ骭ｲ縺輔ｌ縺溘；raphicsDeviceManager.game_FrameEnd() 蜀縺ｧ螳溯｡後＆繧後ｋ縺ｮ縺ｧ荳崎ｦ
+ // (縺､縺ｾ繧翫￣resent()縺ｯ縲．raw()螳御ｺ蠕後↓螳溯｡後＆繧後ｋ)
+#if !GPUFlushAfterPresent
+ actFlushGPU?.On騾ｲ陦梧緒逕ｻ(); // Flush GPU // EndScene()ｽ霸resent()髢 (縺､縺ｾ繧碍Sync蜑) 縺ｧFlush螳溯｡
+#endif
+ if ( Sound邂｡逅?.GetCurrentSoundDeviceType() != "DirectSound" )
+ {
+ Sound邂｡逅?.t蜀咲函荳ｭ縺ｮ蜃ｦ逅繧偵☆繧(); // 繧ｵ繧ｦ繝ｳ繝峨ヰ繝繝輔ぃ縺ｮ譖ｴ譁ｰ; 逕ｻ髱｢謠冗判縺ｨ蜷梧悄縺輔○繧九％縺ｨ縺ｧ縲√せ繧ｯ繝ｭ繝ｼ繝ｫ繧偵せ繝繝ｼ繧ｺ縺ｫ縺吶ｋ
+ }
+
+
+ #region [ 蜈ｨ逕ｻ髱｢_繧ｦ繧､繝ｳ繝峨え蛻繧頑崛縺 ]
+ if ( this.b谺｡縺ｮ繧ｿ繧､繝溘Φ繧ｰ縺ｧ蜈ｨ逕ｻ髱｢_繧ｦ繧｣繝ｳ繝峨え蛻繧頑崛縺医ｒ陦後≧ )
+ {
+ ConfigIni.b蜈ｨ逕ｻ髱｢繝｢繝ｼ繝 = !ConfigIni.b蜈ｨ逕ｻ髱｢繝｢繝ｼ繝;
+ app.t蜈ｨ逕ｻ髱｢_繧ｦ繧｣繝ｳ繝峨え繝｢繝ｼ繝牙繧頑崛縺();
+ this.b谺｡縺ｮ繧ｿ繧､繝溘Φ繧ｰ縺ｧ蜈ｨ逕ｻ髱｢_繧ｦ繧｣繝ｳ繝峨え蛻繧頑崛縺医ｒ陦後≧ = false;
+ }
+ #endregion
+ #region [ 蝙ら峩蝓ｺ邱壼酔譛溷繧頑崛縺 ]
+ if ( this.b谺｡縺ｮ繧ｿ繧､繝溘Φ繧ｰ縺ｧ蝙ら峩蟶ｰ邱壼酔譛溷繧頑崛縺医ｒ陦後≧ )
+ {
+ bool bIsMaximized = this.Window.IsMaximized; // #23510 2010.11.3 yyagi: to backup current window mode before changing VSyncWait
+ currentClientSize = this.Window.ClientSize; // #23510 2010.11.3 yyagi: to backup current window size before changing VSyncWait
+ DeviceSettings currentSettings = app.GraphicsDeviceManager.CurrentSettings;
+ currentSettings.EnableVSync = ConfigIni.b蝙ら峩蟶ｰ邱壼ｾ縺｡繧定｡後≧;
+ app.GraphicsDeviceManager.ChangeDevice( currentSettings );
+ this.b谺｡縺ｮ繧ｿ繧､繝溘Φ繧ｰ縺ｧ蝙ら峩蟶ｰ邱壼酔譛溷繧頑崛縺医ｒ陦後≧ = false;
+ base.Window.ClientSize = new Size(currentClientSize.Width, currentClientSize.Height); // #23510 2010.11.3 yyagi: to resume window size after changing VSyncWait
+ if (bIsMaximized)
+ {
+ this.Window.WindowState = FormWindowState.Maximized; // #23510 2010.11.3 yyagi: to resume window mode after changing VSyncWait
+ }
+ }
+ #endregion
+ }
+
+ // 縺昴ｮ莉
+
+ #region [ 豎守畑繝倥Ν繝代ｼ ]
+ //-----------------
+ public static CTexture t繝繧ｯ繧ｹ繝√Ε縺ｮ逕滓( string fileName )
+ {
+ return t繝繧ｯ繧ｹ繝√Ε縺ｮ逕滓( fileName, false );
+ }
+ public static CTexture t繝繧ｯ繧ｹ繝√Ε縺ｮ逕滓( string fileName, bool b鮟偵ｒ騾城℃縺吶ｋ )
+ {
+ if ( app == null )
+ {
+ return null;
+ }
+ try
+ {
+ return new CTexture( app.Device, fileName, TextureFormat, b鮟偵ｒ騾城℃縺吶ｋ );
+ }
+ catch ( CTextureCreateFailedException e )
+ {
+ Trace.TraceError( e.ToString() );
+ Trace.TraceError( "繝繧ｯ繧ｹ繝√Ε縺ｮ逕滓舌↓螟ｱ謨励＠縺ｾ縺励◆縲({0})", fileName );
+ return null;
+ }
+ catch ( FileNotFoundException )
+ {
+ Trace.TraceWarning( "繝繧ｯ繧ｹ繝√Ε繝輔ぃ繧､繝ｫ縺瑚ｦ九▽縺九ｊ縺ｾ縺帙ｓ縺ｧ縺励◆縲({0})", fileName );
+ return null;
+ }
+ }
+ public static void t繝繧ｯ繧ｹ繝√Ε縺ｮ隗｣謾ｾ(ref CTexture tx )
+ {
+ TJAPlayer3.t螳牙ｨ縺ｫDispose縺吶ｋ( ref tx );
+ }
+ public static void t繝繧ｯ繧ｹ繝√Ε縺ｮ隗｣謾ｾ( ref CTextureAf tx )
+ {
+ TJAPlayer3.t螳牙ｨ縺ｫDispose縺吶ｋ( ref tx );
+ }
+ public static CTexture t繝繧ｯ繧ｹ繝√Ε縺ｮ逕滓( byte[] txData )
+ {
+ return t繝繧ｯ繧ｹ繝√Ε縺ｮ逕滓( txData, false );
+ }
+ public static CTexture t繝繧ｯ繧ｹ繝√Ε縺ｮ逕滓( byte[] txData, bool b鮟偵ｒ騾城℃縺吶ｋ )
+ {
+ if ( app == null )
+ {
+ return null;
+ }
+ try
+ {
+ return new CTexture( app.Device, txData, TextureFormat, b鮟偵ｒ騾城℃縺吶ｋ );
+ }
+ catch ( CTextureCreateFailedException e )
+ {
+ Trace.TraceError( e.ToString() );
+ Trace.TraceError( "繝繧ｯ繧ｹ繝√Ε縺ｮ逕滓舌↓螟ｱ謨励＠縺ｾ縺励◆縲(txData)" );
+ return null;
+ }
+ }
+ public static CTexture t繝繧ｯ繧ｹ繝√Ε縺ｮ逕滓( Bitmap bitmap )
+ {
+ return t繝繧ｯ繧ｹ繝√Ε縺ｮ逕滓( bitmap, false );
+ }
+ public static CTexture t繝繧ｯ繧ｹ繝√Ε縺ｮ逕滓( Bitmap bitmap, bool b鮟偵ｒ騾城℃縺吶ｋ )
+ {
+ if ( app == null )
+ {
+ return null;
+ }
+ if (bitmap == null)
+ {
+ Trace.TraceError("繝繧ｯ繧ｹ繝√Ε縺ｮ逕滓舌↓螟ｱ謨励＠縺ｾ縺励◆縲(bitmap==null)");
+ return null;
+ }
+ try
+ {
+ return new CTexture( app.Device, bitmap, TextureFormat, b鮟偵ｒ騾城℃縺吶ｋ );
+ }
+ catch ( CTextureCreateFailedException e )
+ {
+ Trace.TraceError( e.ToString() );
+ Trace.TraceError( "繝繧ｯ繧ｹ繝√Ε縺ｮ逕滓舌↓螟ｱ謨励＠縺ｾ縺励◆縲(txData)" );
+ return null;
+ }
+ }
+
+ public static CTextureAf t繝繧ｯ繧ｹ繝√Ε縺ｮ逕滓植f( string fileName )
+ {
+ return t繝繧ｯ繧ｹ繝√Ε縺ｮ逕滓植f( fileName, false );
+ }
+ public static CTextureAf t繝繧ｯ繧ｹ繝√Ε縺ｮ逕滓植f( string fileName, bool b鮟偵ｒ騾城℃縺吶ｋ )
+ {
+ if ( app == null )
+ {
+ return null;
+ }
+ try
+ {
+ return new CTextureAf( app.Device, fileName, TextureFormat, b鮟偵ｒ騾城℃縺吶ｋ );
+ }
+ catch ( CTextureCreateFailedException e )
+ {
+ Trace.TraceError( e.ToString() );
+ Trace.TraceError( "繝繧ｯ繧ｹ繝√Ε縺ｮ逕滓舌↓螟ｱ謨励＠縺ｾ縺励◆縲({0})", fileName );
+ return null;
+ }
+ catch ( FileNotFoundException e )
+ {
+ Trace.TraceError( e.ToString() );
+ Trace.TraceError( "繝繧ｯ繧ｹ繝√Ε繝輔ぃ繧､繝ｫ縺瑚ｦ九▽縺九ｊ縺ｾ縺帙ｓ縺ｧ縺励◆縲({0})", fileName );
+ return null;
+ }
+ }
+ public static CDirectShow t螟ｱ謨励＠縺ｦ繧ゅせ繧ｭ繝繝怜庄閭ｽ縺ｪDirectShow繧堤函謌舌☆繧(string fileName, IntPtr hWnd, bool b繧ｪ繝ｼ繝繧｣繧ｪ繝ｬ繝ｳ繝繝ｩ縺ｪ縺)
+ {
+ CDirectShow ds = null;
+ if( File.Exists( fileName ) )
+ {
+ try
+ {
+ ds = new CDirectShow(fileName, hWnd, b繧ｪ繝ｼ繝繧｣繧ｪ繝ｬ繝ｳ繝繝ｩ縺ｪ縺);
+ }
+ catch (FileNotFoundException e)
+ {
+ Trace.TraceError( e.ToString() );
+ Trace.TraceError("蜍慕判繝輔ぃ繧､繝ｫ縺瑚ｦ九▽縺九ｊ縺ｾ縺帙ｓ縺ｧ縺励◆縲({0})", fileName);
+ ds = null; // Dispose 縺ｯ繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ蜀縺ｧ螳滓命貂医∩
+ }
+ catch (Exception e)
+ {
+ Trace.TraceError( e.ToString() );
+ Trace.TraceError("DirectShow 縺ｮ逕滓舌↓螟ｱ謨励＠縺ｾ縺励◆縲[{0}]", fileName);
+ ds = null; // Dispose 縺ｯ繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ蜀縺ｧ螳滓命貂医∩
+ }
+ }
+ else
+ {
+ Trace.TraceError("蜍慕判繝輔ぃ繧､繝ｫ縺瑚ｦ九▽縺九ｊ縺ｾ縺帙ｓ縺ｧ縺励◆縲({0})", fileName);
+ return null;
+ }
+
+ return ds;
+ }
+
+ /// 繝励Ο繝代ユ繧｣縲√う繝ｳ繝繧ｯ繧ｵ縺ｫ縺ｯ ref 縺ｯ菴ｿ逕ｨ縺ｧ縺阪↑縺縺ｮ縺ｧ豕ｨ諢上
+ public static void t螳牙ｨ縺ｫDispose縺吶ｋ(ref T obj)
+ {
+ if (obj == null)
+ return;
+
+ var d = obj as IDisposable;
+
+ if (d != null)
+ d.Dispose();
+
+ obj = default(T);
+ }
+
+ public static void t螳牙ｨ縺ｫDispose縺吶ｋ(ref T[] array) where T : class, IDisposable //2020.08.01 Mr-Ojii twopointzero豌上ｮ繧ｽ繝ｼ繧ｹ繧ｳ繝ｼ繝峨ｒ繧ゅ→縺ｫ霑ｽ蜉
+ {
+ if (array == null)
+ {
+ return;
+ }
+
+ for (var i = 0; i < array.Length; i++)
+ {
+ array[i]?.Dispose();
+ array[i] = null;
+ }
+ }
+
+ ///
+ /// 縺昴ｮ繝輔か繝ｫ繝縺ｮ騾｣逡ｪ逕ｻ蜒上ｮ譛螟ｧ蛟､繧定ｿ斐☆縲
+ ///
+ public static int t騾｣逡ｪ逕ｻ蜒上ｮ譫壽焚繧呈焚縺医ｋ(string 繝繧｣繝ｬ繧ｯ繝医Μ蜷, string 繝励Ξ繝輔ぅ繝繧ｯ繧ｹ = "", string 諡｡蠑ｵ蟄 = ".png")
+ {
+ int num = 0;
+ while(File.Exists(繝繧｣繝ｬ繧ｯ繝医Μ蜷 + 繝励Ξ繝輔ぅ繝繧ｯ繧ｹ + num + 諡｡蠑ｵ蟄))
+ {
+ num++;
+ }
+ return num;
+ }
+
+ ///
+ /// 譖ｲ蜷阪ユ繧ｯ繧ｹ繝√Ε縺ｮ邵ｮ蟆丞咲紫繧定ｿ斐☆縲
+ ///
+ /// 譖ｲ蜷阪ユ繧ｯ繧ｹ繝√Ε縲
+ /// 遲牙阪〒陦ｨ遉ｺ縺吶ｋ繝斐け繧ｻ繝ｫ謨ｰ縺ｮ譛螟ｧ蛟､(繝繝輔か繝ｫ繝亥､:645)
+ /// 譖ｲ蜷阪ユ繧ｯ繧ｹ繝√Ε縺ｮ邵ｮ蟆丞咲紫縲ゅ◎縺ｮ繝繧ｯ繧ｹ繝√Ε縺系ull縺ｪ繧峨ｰ荳蛟(1f)繧定ｿ斐☆縲
+ public static float GetSongNameXScaling(ref CTexture cTexture, int samePixel = 660)
+ {
+ if (cTexture == null) return 1f;
+ float scalingRate = (float)samePixel / (float)cTexture.sz繝繧ｯ繧ｹ繝√Ε繧ｵ繧､繧ｺ.Width;
+ if (cTexture.sz繝繧ｯ繧ｹ繝√Ε繧ｵ繧､繧ｺ.Width <= samePixel)
+ scalingRate = 1.0f;
+ return scalingRate;
+ }
+
+ ///
+ /// 髮｣譏灘ｺｦ繧定｡ｨ縺呎焚蟄励ｒ蛻玲嫌菴薙↓螟画鋤縺励∪縺吶
+ ///
+ /// 髮｣譏灘ｺｦ繧定｡ｨ縺呎焚蟄励
+ /// Difficulty 蛻玲嫌菴
+ public static Difficulty DifficultyNumberToEnum(int number)
+ {
+ switch (number)
+ {
+ case 0:
+ return Difficulty.Easy;
+ case 1:
+ return Difficulty.Normal;
+ case 2:
+ return Difficulty.Hard;
+ case 3:
+ return Difficulty.Oni;
+ case 4:
+ return Difficulty.Edit;
+ case 5:
+ return Difficulty.Tower;
+ case 6:
+ return Difficulty.Dan;
+ default:
+ throw new IndexOutOfRangeException();
+ }
+ }
+
+ //-----------------
+ #endregion
+
+ #region [ private ]
+ //-----------------
+ private bool b繝槭え繧ｹ繧ｫ繝ｼ繧ｽ繝ｫ陦ｨ遉ｺ荳ｭ = true;
+ private bool b邨ゆｺ蜃ｦ逅螳御ｺ貂医∩;
+ private bool b繝阪ャ繝医Ρ繝ｼ繧ｯ縺ｫ謗･邯壻ｸｭ = false;
+ private long 蜑榊屓縺ｮ繧ｷ繧ｹ繝繝譎ょ綾ms = long.MinValue;
+ private static CDTX[] dtx = new CDTX[ 4 ];
+
+ public static TextureLoader Tx = new TextureLoader();
+
+ private List list繝医ャ繝励Ξ繝吶ΝActivities;
+ private int n騾ｲ陦梧緒逕ｻ縺ｮ謌ｻ繧雁､;
+ private MouseButtons mb = System.Windows.Forms.MouseButtons.Left;
+ private string strWindowTitle
+ {
+ get
+ {
+ if ( DTXVmode.Enabled )
+ {
+ return "DTXViewer release " + VERSION;
+ }
+ else
+ {
+ return "TJAPlayer3 feat.DTXMania";
+ }
+ }
+ }
+ private CSound previewSound;
+ public static long StartupTime
+ {
+ get;
+ private set;
+ }
+
+ private void t襍ｷ蜍募ｦ逅()
+ {
+ #region [ strEXE縺ｮ縺ゅｋ繝輔か繝ｫ繝繧呈ｱｺ螳壹☆繧 ]
+ //-----------------
+// BEGIN #23629 2010.11.13 from: 繝繝舌ャ繧ｰ譎ゅｯ Application.ExecutablePath 縺 ($SolutionDir)/bin/x86/Debug/ 縺ｪ縺ｩ縺ｫ縺ｪ繧 System/ 縺ｮ隱ｭ縺ｿ霎ｼ縺ｿ縺ｫ螟ｱ謨励☆繧九ｮ縺ｧ縲√き繝ｬ繝ｳ繝医ョ繧｣繝ｬ繧ｯ繝医Μ繧呈治逕ｨ縺吶ｋ縲ゑｼ医励Ο繧ｸ繧ｧ繧ｯ繝医ｮ繝励Ο繝代ユ繧｣竊偵ョ繝舌ャ繧ｰ竊剃ｽ懈･ｭ繝繧｣繝ｬ繧ｯ繝医Μ縺梧怏蜉ｹ縺ｫ縺ｪ繧具ｼ
+#if DEBUG
+ strEXE縺ｮ縺ゅｋ繝輔か繝ｫ繝 = Environment.CurrentDirectory + @"\";
+#else
+ strEXE縺ｮ縺ゅｋ繝輔か繝ｫ繝 = Path.GetDirectoryName( Application.ExecutablePath ) + @"\"; // #23629 2010.11.9 yyagi: set correct pathname where DTXManiaGR.exe is.
+#endif
+ // END #23629 2010.11.13 from
+ //-----------------
+ #endregion
+
+ #region [ Config.ini 縺ｮ隱ｭ霎ｼ縺ｿ ]
+ //---------------------
+ NamePlateConfig = new NamePlateConfig();
+ NamePlateConfig.tNamePlateConfig();
+ ConfigIni = new CConfigIni();
+ string path = strEXE縺ｮ縺ゅｋ繝輔か繝ｫ繝 + "Config.ini";
+ if( File.Exists( path ) )
+ {
+ try
+ {
+ ConfigIni.t繝輔ぃ繧､繝ｫ縺九ｉ隱ｭ縺ｿ霎ｼ縺ｿ( path );
+ }
+ catch (Exception e)
+ {
+ //ConfigIni = new CConfigIni(); // 蟄伜惠縺励※縺ｪ縺代ｌ縺ｰ譁ｰ隕冗函謌
+ Trace.TraceError( e.ToString() );
+ Trace.TraceError( "萓句､悶′逋ｺ逕溘＠縺ｾ縺励◆縺悟ｦ逅繧堤ｶ咏ｶ壹＠縺ｾ縺吶 (b8d93255-bbe4-4ca3-8264-7ee5175b19f3)" );
+ }
+ }
+ this.Window.EnableSystemMenu = TJAPlayer3.ConfigIni.bIsEnabledSystemMenu; // #28200 2011.5.1 yyagi
+ // 2012.8.22 Config.ini縺檎┌縺縺ｨ縺阪↓蛻晄悄蛟､縺碁←逕ｨ縺輔ｌ繧九ｈ縺縲√％縺ｮ險ｭ螳夊｡後ｒif繝悶Ο繝繧ｯ螟悶↓遘ｻ蜍
+
+ //---------------------
+ #endregion
+ #region [ 繝ｭ繧ｰ蜃ｺ蜉幃幕蟋 ]
+ //---------------------
+ Trace.AutoFlush = true;
+ if( ConfigIni.b繝ｭ繧ｰ蜃ｺ蜉 )
+ {
+ try
+ {
+ Trace.Listeners.Add( new CTraceLogListener( new StreamWriter( System.IO.Path.Combine( strEXE縺ｮ縺ゅｋ繝輔か繝ｫ繝, "TJAPlayer3.log" ), false, Encoding.GetEncoding( "Shift_JIS" ) ) ) );
+ }
+ catch ( System.UnauthorizedAccessException ) // #24481 2011.2.20 yyagi
+ {
+ int c = (CultureInfo.CurrentUICulture.TwoLetterISOLanguageName == "ja")? 0 : 1;
+ string[] mes_writeErr = {
+ "DTXManiaLog.txt縺ｸ縺ｮ譖ｸ縺崎ｾｼ縺ｿ縺後〒縺阪∪縺帙ｓ縺ｧ縺励◆縲よ嶌縺崎ｾｼ縺ｿ縺ｧ縺阪ｋ繧医≧縺ｫ縺励※縺九ｉ縲∝榊ｺｦ襍ｷ蜍輔＠縺ｦ縺上□縺輔＞縲",
+ "Failed to write DTXManiaLog.txt. Please set it writable and try again."
+ };
+ MessageBox.Show( mes_writeErr[c], "DTXMania boot error", MessageBoxButtons.OK, MessageBoxIcon.Error );
+ Environment.Exit(1);
+ }
+ }
+ Trace.WriteLine("");
+ Trace.WriteLine( "DTXMania powered by YAMAHA Silent Session Drums" );
+ Trace.WriteLine( string.Format( "Release: {0}", VERSION ) );
+ Trace.WriteLine( "" );
+ Trace.TraceInformation( "----------------------" );
+ Trace.TraceInformation( "笆 繧｢繝励Μ繧ｱ繝ｼ繧ｷ繝ｧ繝ｳ縺ｮ蛻晄悄蛹" );
+ Trace.TraceInformation( "OS Version: " + Environment.OSVersion );
+ Trace.TraceInformation( "ProcessorCount: " + Environment.ProcessorCount.ToString() );
+ Trace.TraceInformation( "CLR Version: " + Environment.Version.ToString() );
+ //---------------------
+ #endregion
+ #region [ DTXVmode繧ｯ繝ｩ繧ｹ 縺ｮ蛻晄悄蛹 ]
+ //---------------------
+ //Trace.TraceInformation( "DTXV繝｢繝ｼ繝峨ｮ蛻晄悄蛹悶ｒ陦後＞縺ｾ縺吶" );
+ //Trace.Indent();
+ try
+ {
+ DTXVmode = new CDTXVmode();
+ DTXVmode.Enabled = false;
+ //Trace.TraceInformation( "DTXV繝｢繝ｼ繝峨ｮ蛻晄悄蛹悶ｒ螳御ｺ縺励∪縺励◆縲" );
+ }
+ finally
+ {
+ //Trace.Unindent();
+ }
+ //---------------------
+ #endregion
+
+
+ #region [ 繧ｦ繧｣繝ｳ繝峨え蛻晄悄蛹 ]
+ //---------------------
+ base.Window.StartPosition = FormStartPosition.Manual; // #30675 2013.02.04 ikanick add
+ base.Window.Location = new Point( ConfigIni.n蛻晄悄繧ｦ繧｣繝ｳ繝峨え髢句ｧ倶ｽ咲ｽｮX, ConfigIni.n蛻晄悄繧ｦ繧｣繝ｳ繝峨え髢句ｧ倶ｽ咲ｽｮY ); // #30675 2013.02.04 ikanick add
+
+
+ base.Window.Text = "";
+
+ base.Window.StartPosition = FormStartPosition.Manual; // #30675 2013.02.04 ikanick add
+ base.Window.Location = new Point(ConfigIni.n蛻晄悄繧ｦ繧｣繝ｳ繝峨え髢句ｧ倶ｽ咲ｽｮX, ConfigIni.n蛻晄悄繧ｦ繧｣繝ｳ繝峨え髢句ｧ倶ｽ咲ｽｮY); // #30675 2013.02.04 ikanick add
+
+ base.Window.ClientSize = new Size(ConfigIni.n繧ｦ繧､繝ｳ繝峨えwidth, ConfigIni.n繧ｦ繧､繝ｳ繝峨えheight); // #34510 yyagi 2010.10.31 to change window size got from Config.ini
+#if !WindowedFullscreen
+ if (!ConfigIni.b繧ｦ繧｣繝ｳ繝峨え繝｢繝ｼ繝) // #23510 2010.11.02 yyagi: add; to recover window size in case bootup with fullscreen mode
+ { // #30666 2013.02.02 yyagi: currentClientSize should be always made
+#endif
+ currentClientSize = new Size( ConfigIni.n繧ｦ繧､繝ｳ繝峨えwidth, ConfigIni.n繧ｦ繧､繝ｳ繝峨えheight );
+#if !WindowedFullscreen
+ }
+#endif
+ base.Window.MaximizeBox = true; // #23510 2010.11.04 yyagi: to support maximizing window
+ base.Window.FormBorderStyle = FormBorderStyle.Sizable; // #23510 2010.10.27 yyagi: changed from FixedDialog to Sizable, to support window resize
+ // #30666 2013.02.02 yyagi: moved the code to t蜈ｨ逕ｻ髱｢_繧ｦ繧､繝ｳ繝峨え繝｢繝ｼ繝牙繧頑崛縺()
+ base.Window.ShowIcon = true;
+ base.Window.Icon = global::TJAPlayer3.Properties.Resources.tjap3;
+ base.Window.KeyDown += new KeyEventHandler( this.Window_KeyDown );
+ base.Window.MouseUp +=new MouseEventHandler( this.Window_MouseUp);
+ base.Window.MouseDoubleClick += new MouseEventHandler(this.Window_MouseDoubleClick); // #23510 2010.11.13 yyagi: to go fullscreen mode
+ base.Window.ResizeEnd += new EventHandler(this.Window_ResizeEnd); // #23510 2010.11.20 yyagi: to set resized window size in Config.ini
+ base.Window.ApplicationActivated += new EventHandler(this.Window_ApplicationActivated);
+ base.Window.ApplicationDeactivated += new EventHandler( this.Window_ApplicationDeactivated );
+ //---------------------
+ #endregion
+ #region [ Direct3D9Ex繧剃ｽｿ縺縺九←縺縺句愛螳 ]
+ #endregion
+ #region [ Direct3D9 繝繝舌う繧ｹ縺ｮ逕滓 ]
+ //---------------------
+ DeviceSettings settings = new DeviceSettings();
+#if WindowedFullscreen
+ settings.Windowed = true; // #30666 2013.2.2 yyagi: Fullscreenmode is "Maximized window" mode
+#else
+ settings.Windowed = ConfigIni.b繧ｦ繧｣繝ｳ繝峨え繝｢繝ｼ繝;
+#endif
+ settings.BackBufferWidth = SampleFramework.GameWindowSize.Width;
+ settings.BackBufferHeight = SampleFramework.GameWindowSize.Height;
+// settings.BackBufferCount = 3;
+ settings.EnableVSync = ConfigIni.b蝙ら峩蟶ｰ邱壼ｾ縺｡繧定｡後≧;
+// settings.BackBufferFormat = Format.A8R8G8B8;
+// settings.MultisampleType = MultisampleType.FourSamples;
+// settings.MultisampleQuality = 4;
+// settings.MultisampleType = MultisampleType.None;
+// settings.MultisampleQuality = 0;
+
+ try
+ {
+ base.GraphicsDeviceManager.ChangeDevice(settings);
+ }
+ catch (DeviceCreationException e)
+ {
+ Trace.TraceError(e.ToString());
+ MessageBox.Show(e.ToString(), "DTXMania failed to boot: DirectX9 Initialize Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
+ Environment.Exit(-1);
+ }
+
+ base.IsFixedTimeStep = false;
+// base.TargetElapsedTime = TimeSpan.FromTicks( 10000000 / 75 );
+ base.Window.ClientSize = new Size(ConfigIni.n繧ｦ繧､繝ｳ繝峨えwidth, ConfigIni.n繧ｦ繧､繝ｳ繝峨えheight); // #23510 2010.10.31 yyagi: to recover window size. width and height are able to get from Config.ini.
+ base.InactiveSleepTime = TimeSpan.FromMilliseconds((float)(ConfigIni.n髱槭ヵ繧ｩ繝ｼ繧ｫ繧ｹ譎ゅせ繝ｪ繝ｼ繝洋s)); // #23568 2010.11.3 yyagi: to support valiable sleep value when !IsActive
+ // #23568 2010.11.4 ikanick changed ( 1 -> ConfigIni )
+#if WindowedFullscreen
+ this.t蜈ｨ逕ｻ髱｢_繧ｦ繧｣繝ｳ繝峨え繝｢繝ｼ繝牙繧頑崛縺(); // #30666 2013.2.2 yyagi: finalize settings for "Maximized window mode"
+#endif
+ actFlushGPU = new CActFlushGPU();
+ //---------------------
+ #endregion
+
+ DTX = null;
+
+ #region [ Skin 縺ｮ蛻晄悄蛹 ]
+ //---------------------
+ Trace.TraceInformation( "繧ｹ繧ｭ繝ｳ縺ｮ蛻晄悄蛹悶ｒ陦後＞縺ｾ縺吶" );
+ Trace.Indent();
+ try
+ {
+ Skin = new CSkin( TJAPlayer3.ConfigIni.strSystemSkinSubfolderFullName, false);
+ TJAPlayer3.ConfigIni.strSystemSkinSubfolderFullName = TJAPlayer3.Skin.GetCurrentSkinSubfolderFullName( true ); // 譌ｧ謖螳壹ｮSkin繝輔か繝ｫ繝縺梧ｶ域ｻ縺励※縺縺溷ｴ蜷医↓蛯吶∴繧
+ Trace.TraceInformation( "繧ｹ繧ｭ繝ｳ縺ｮ蛻晄悄蛹悶ｒ螳御ｺ縺励∪縺励◆縲" );
+ }
+ catch (Exception e)
+ {
+ Trace.TraceInformation( "繧ｹ繧ｭ繝ｳ縺ｮ蛻晄悄蛹悶↓螟ｱ謨励＠縺ｾ縺励◆縲" );
+ throw;
+ }
+ finally
+ {
+ Trace.Unindent();
+ }
+ //---------------------
+ #endregion
+ //-----------
+ #region [ Timer 縺ｮ蛻晄悄蛹 ]
+ //---------------------
+ Trace.TraceInformation( "繧ｿ繧､繝槭ｮ蛻晄悄蛹悶ｒ陦後＞縺ｾ縺吶" );
+ Trace.Indent();
+ try
+ {
+ Timer = new CTimer( CTimer.E遞ｮ蛻･.MultiMedia );
+ Trace.TraceInformation( "繧ｿ繧､繝槭ｮ蛻晄悄蛹悶ｒ螳御ｺ縺励∪縺励◆縲" );
+ }
+ finally
+ {
+ Trace.Unindent();
+ }
+ //---------------------
+ #endregion
+ //-----------
+
+ #region [ FPS 繧ｫ繧ｦ繝ｳ繧ｿ縺ｮ蛻晄悄蛹 ]
+ //---------------------
+ Trace.TraceInformation( "FPS繧ｫ繧ｦ繝ｳ繧ｿ縺ｮ蛻晄悄蛹悶ｒ陦後＞縺ｾ縺吶" );
+ Trace.Indent();
+ try
+ {
+ FPS = new CFPS();
+ Trace.TraceInformation( "FPS繧ｫ繧ｦ繝ｳ繧ｿ繧堤函謌舌＠縺ｾ縺励◆縲" );
+ }
+ finally
+ {
+ Trace.Unindent();
+ }
+ //---------------------
+ #endregion
+ #region [ act譁蟄励さ繝ｳ繧ｽ繝ｼ繝ｫ縺ｮ蛻晄悄蛹 ]
+ //---------------------
+ Trace.TraceInformation( "譁蟄励さ繝ｳ繧ｽ繝ｼ繝ｫ縺ｮ蛻晄悄蛹悶ｒ陦後＞縺ｾ縺吶" );
+ Trace.Indent();
+ try
+ {
+ act譁蟄励さ繝ｳ繧ｽ繝ｼ繝ｫ = new C譁蟄励さ繝ｳ繧ｽ繝ｼ繝ｫ();
+ Trace.TraceInformation( "譁蟄励さ繝ｳ繧ｽ繝ｼ繝ｫ繧堤函謌舌＠縺ｾ縺励◆縲" );
+ act譁蟄励さ繝ｳ繧ｽ繝ｼ繝ｫ.On豢ｻ諤ｧ蛹();
+ Trace.TraceInformation( "譁蟄励さ繝ｳ繧ｽ繝ｼ繝ｫ繧呈ｴｻ諤ｧ蛹悶＠縺ｾ縺励◆縲" );
+ Trace.TraceInformation( "譁蟄励さ繝ｳ繧ｽ繝ｼ繝ｫ縺ｮ蛻晄悄蛹悶ｒ螳御ｺ縺励∪縺励◆縲" );
+ }
+ catch( Exception exception )
+ {
+ Trace.TraceError( exception.ToString() );
+ Trace.TraceError( "譁蟄励さ繝ｳ繧ｽ繝ｼ繝ｫ縺ｮ蛻晄悄蛹悶↓螟ｱ謨励＠縺ｾ縺励◆縲" );
+ }
+ finally
+ {
+ Trace.Unindent();
+ }
+ //---------------------
+ #endregion
+ #region [ Input邂｡逅 縺ｮ蛻晄悄蛹 ]
+ //---------------------
+ Trace.TraceInformation( "DirectInput, MIDI蜈･蜉帙ｮ蛻晄悄蛹悶ｒ陦後＞縺ｾ縺吶" );
+ Trace.Indent();
+ try
+ {
+ bool bUseMIDIIn = !DTXVmode.Enabled;
+ Input邂｡逅 = new CInput邂｡逅( base.Window.Handle, bUseMIDIIn );
+ foreach( IInputDevice device in Input邂｡逅.list蜈･蜉帙ョ繝舌う繧ｹ )
+ {
+ if( ( device.e蜈･蜉帙ョ繝舌う繧ｹ遞ｮ蛻･ == E蜈･蜉帙ョ繝舌う繧ｹ遞ｮ蛻･.Joystick ) && !ConfigIni.dicJoystick.ContainsValue( device.GUID ) )
+ {
+ int key = 0;
+ while( ConfigIni.dicJoystick.ContainsKey( key ) )
+ {
+ key++;
+ }
+ ConfigIni.dicJoystick.Add( key, device.GUID );
+ }
+ }
+ foreach( IInputDevice device2 in Input邂｡逅.list蜈･蜉帙ョ繝舌う繧ｹ )
+ {
+ if( device2.e蜈･蜉帙ョ繝舌う繧ｹ遞ｮ蛻･ == E蜈･蜉帙ョ繝舌う繧ｹ遞ｮ蛻･.Joystick )
+ {
+ foreach( KeyValuePair pair in ConfigIni.dicJoystick )
+ {
+ if( device2.GUID.Equals( pair.Value ) )
+ {
+ ( (CInputJoystick) device2 ).SetID( pair.Key );
+ break;
+ }
+ }
+ continue;
+ }
+ }
+ Trace.TraceInformation( "DirectInput 縺ｮ蛻晄悄蛹悶ｒ螳御ｺ縺励∪縺励◆縲" );
+ }
+ catch( Exception exception2 )
+ {
+ Trace.TraceError( "DirectInput, MIDI蜈･蜉帙ｮ蛻晄悄蛹悶↓螟ｱ謨励＠縺ｾ縺励◆縲" );
+ throw;
+ }
+ finally
+ {
+ Trace.Unindent();
+ }
+ //---------------------
+ #endregion
+ #region [ Pad 縺ｮ蛻晄悄蛹 ]
+ //---------------------
+ Trace.TraceInformation( "繝代ャ繝峨ｮ蛻晄悄蛹悶ｒ陦後＞縺ｾ縺吶" );
+ Trace.Indent();
+ try
+ {
+ Pad = new CPad( ConfigIni, Input邂｡逅 );
+ Trace.TraceInformation( "繝代ャ繝峨ｮ蛻晄悄蛹悶ｒ螳御ｺ縺励∪縺励◆縲" );
+ }
+ catch( Exception exception3 )
+ {
+ Trace.TraceError( exception3.ToString() );
+ Trace.TraceError( "繝代ャ繝峨ｮ蛻晄悄蛹悶↓螟ｱ謨励＠縺ｾ縺励◆縲" );
+ }
+ finally
+ {
+ Trace.Unindent();
+ }
+ //---------------------
+ #endregion
+ #region [ Sound邂｡逅 縺ｮ蛻晄悄蛹 ]
+ //---------------------
+ Trace.TraceInformation( "繧ｵ繧ｦ繝ｳ繝峨ョ繝舌う繧ｹ縺ｮ蛻晄悄蛹悶ｒ陦後＞縺ｾ縺吶" );
+ Trace.Indent();
+ try
+ {
+ ESoundDeviceType soundDeviceType;
+ switch ( TJAPlayer3.ConfigIni.nSoundDeviceType )
+ {
+ case 0:
+ soundDeviceType = ESoundDeviceType.DirectSound;
+ break;
+ case 1:
+ soundDeviceType = ESoundDeviceType.ASIO;
+ break;
+ case 2:
+ soundDeviceType = ESoundDeviceType.ExclusiveWASAPI;
+ break;
+ default:
+ soundDeviceType = ESoundDeviceType.Unknown;
+ break;
+ }
+ Sound邂｡逅 = new CSound邂｡逅(base.Window.Handle,
+ soundDeviceType,
+ TJAPlayer3.ConfigIni.nWASAPIBufferSizeMs,
+ // CDTXMania.ConfigIni.nASIOBufferSizeMs,
+ 0,
+ TJAPlayer3.ConfigIni.nASIODevice,
+ TJAPlayer3.ConfigIni.bUseOSTimer
+ );
+ //Sound邂｡逅 = FDK.CSound邂｡逅.Instance;
+ //Sound邂｡逅.t蛻晄悄蛹( soundDeviceType, 0, 0, CDTXMania.ConfigIni.nASIODevice, base.Window.Handle );
+
+
+ Trace.TraceInformation("Initializing loudness scanning, song gain control, and sound group level control...");
+ Trace.Indent();
+ try
+ {
+ actScanningLoudness = new CActScanningLoudness();
+ actScanningLoudness.On豢ｻ諤ｧ蛹();
+ LoudnessMetadataScanner.ScanningStateChanged +=
+ (_, args) => actScanningLoudness.bIsActivelyScanning = args.IsActivelyScanning;
+ LoudnessMetadataScanner.StartBackgroundScanning();
+
+ SongGainController = new SongGainController();
+ ConfigIniToSongGainControllerBinder.Bind(ConfigIni, SongGainController);
+
+ SoundGroupLevelController = new SoundGroupLevelController(CSound.list繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ);
+ ConfigIniToSoundGroupLevelControllerBinder.Bind(ConfigIni, SoundGroupLevelController);
+ }
+ finally
+ {
+ Trace.Unindent();
+ Trace.TraceInformation("Initialized loudness scanning, song gain control, and sound group level control.");
+ }
+
+ ShowWindowTitleWithSoundType();
+ FDK.CSound邂｡逅.bIsTimeStretch = TJAPlayer3.ConfigIni.bTimeStretch;
+ Sound邂｡逅.nMasterVolume = TJAPlayer3.ConfigIni.nMasterVolume;
+ //FDK.CSound邂｡逅.bIsMP3DecodeByWindowsCodec = CDTXMania.ConfigIni.bNoMP3Streaming;
+ Trace.TraceInformation( "繧ｵ繧ｦ繝ｳ繝峨ョ繝舌う繧ｹ縺ｮ蛻晄悄蛹悶ｒ螳御ｺ縺励∪縺励◆縲" );
+ }
+ catch (Exception e)
+ {
+ throw new NullReferenceException("繧ｵ繧ｦ繝ｳ繝峨ョ繝舌う繧ｹ縺後ｲ縺ｨ縺､繧よ怏蜉ｹ縺ｫ縺ｪ縺｣縺ｦ縺縺ｪ縺縺溘ａ縲√し繧ｦ繝ｳ繝峨ョ繝舌う繧ｹ縺ｮ蛻晄悄蛹悶′縺ｧ縺阪∪縺帙ｓ縺ｧ縺励◆縲", e);
+ }
+ finally
+ {
+ Trace.Unindent();
+ }
+ //---------------------
+ #endregion
+ #region [ Songs邂｡逅 縺ｮ蛻晄悄蛹 ]
+ //---------------------
+ Trace.TraceInformation( "譖ｲ繝ｪ繧ｹ繝医ｮ蛻晄悄蛹悶ｒ陦後＞縺ｾ縺吶" );
+ Trace.Indent();
+ try
+ {
+ Songs邂｡逅 = new CSongs邂｡逅();
+// Songs邂｡逅_陬剰ｪｭ = new CSongs邂｡逅();
+ EnumSongs = new CEnumSongs();
+ actEnumSongs = new CActEnumSongs();
+ Trace.TraceInformation( "譖ｲ繝ｪ繧ｹ繝医ｮ蛻晄悄蛹悶ｒ螳御ｺ縺励∪縺励◆縲" );
+ }
+ catch( Exception e )
+ {
+ Trace.TraceError( e.ToString() );
+ Trace.TraceError( "譖ｲ繝ｪ繧ｹ繝医ｮ蛻晄悄蛹悶↓螟ｱ謨励＠縺ｾ縺励◆縲" );
+ }
+ finally
+ {
+ Trace.Unindent();
+ }
+ //---------------------
+ #endregion
+ #region [ CAvi 縺ｮ蛻晄悄蛹 ]
+ //---------------------
+ CAvi.t蛻晄悄蛹();
+ //---------------------
+ #endregion
+ #region [ Random 縺ｮ蛻晄悄蛹 ]
+ //---------------------
+ Random = new Random( (int) Timer.n繧ｷ繧ｹ繝繝譎ょ綾 );
+ //---------------------
+ #endregion
+ #region [ 繧ｹ繝繝ｼ繧ｸ縺ｮ蛻晄悄蛹 ]
+ //---------------------
+ r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ = null;
+ r逶ｴ蜑阪ｮ繧ｹ繝繝ｼ繧ｸ = null;
+ stage襍ｷ蜍 = new CStage襍ｷ蜍();
+ stage繧ｿ繧､繝医Ν = new CStage繧ｿ繧､繝医Ν();
+// stage繧ｪ繝励す繝ｧ繝ｳ = new CStage繧ｪ繝励す繝ｧ繝ｳ();
+ stage繧ｳ繝ｳ繝輔ぅ繧ｰ = new CStage繧ｳ繝ｳ繝輔ぅ繧ｰ();
+ stage驕ｸ譖ｲ = new CStage驕ｸ譖ｲ();
+ stage谿ｵ菴埼∈謚 = new CStage谿ｵ菴埼∈謚();
+ stage譖ｲ隱ｭ縺ｿ霎ｼ縺ｿ = new CStage譖ｲ隱ｭ縺ｿ霎ｼ縺ｿ();
+ stage貍泌･上ラ繝ｩ繝逕ｻ髱｢ = new CStage貍泌･上ラ繝ｩ繝逕ｻ髱｢();
+ stage邨先棡 = new CStage邨先棡();
+ stageChangeSkin = new CStageChangeSkin();
+ stage邨ゆｺ = new CStage邨ゆｺ();
+ NamePlate = new CNamePlate();
+ this.list繝医ャ繝励Ξ繝吶ΝActivities = new List();
+ this.list繝医ャ繝励Ξ繝吶ΝActivities.Add( actEnumSongs );
+ this.list繝医ャ繝励Ξ繝吶ΝActivities.Add( act譁蟄励さ繝ｳ繧ｽ繝ｼ繝ｫ );
+ this.list繝医ャ繝励Ξ繝吶ΝActivities.Add( stage襍ｷ蜍 );
+ this.list繝医ャ繝励Ξ繝吶ΝActivities.Add( stage繧ｿ繧､繝医Ν );
+// this.list繝医ャ繝励Ξ繝吶ΝActivities.Add( stage繧ｪ繝励す繝ｧ繝ｳ );
+ this.list繝医ャ繝励Ξ繝吶ΝActivities.Add( stage繧ｳ繝ｳ繝輔ぅ繧ｰ );
+ this.list繝医ャ繝励Ξ繝吶ΝActivities.Add( stage驕ｸ譖ｲ );
+ this.list繝医ャ繝励Ξ繝吶ΝActivities.Add( stage谿ｵ菴埼∈謚 );
+ this.list繝医ャ繝励Ξ繝吶ΝActivities.Add( stage譖ｲ隱ｭ縺ｿ霎ｼ縺ｿ );
+ this.list繝医ャ繝励Ξ繝吶ΝActivities.Add( stage貍泌･上ラ繝ｩ繝逕ｻ髱｢ );
+ this.list繝医ャ繝励Ξ繝吶ΝActivities.Add( stage邨先棡 );
+ this.list繝医ャ繝励Ξ繝吶ΝActivities.Add( stageChangeSkin );
+ this.list繝医ャ繝励Ξ繝吶ΝActivities.Add( stage邨ゆｺ );
+ this.list繝医ャ繝励Ξ繝吶ΝActivities.Add( actFlushGPU );
+ //---------------------
+ #endregion
+ #region [ 繝励Λ繧ｰ繧､繝ｳ縺ｮ讀懃ｴ｢縺ｨ逕滓 ]
+ //---------------------
+ PluginHost = new CPluginHost();
+
+ Trace.TraceInformation( "繝励Λ繧ｰ繧､繝ｳ縺ｮ讀懃ｴ｢縺ｨ逕滓舌ｒ陦後＞縺ｾ縺吶" );
+ Trace.Indent();
+ try
+ {
+ this.t繝励Λ繧ｰ繧､繝ｳ讀懃ｴ｢縺ｨ逕滓();
+ Trace.TraceInformation( "繝励Λ繧ｰ繧､繝ｳ縺ｮ讀懃ｴ｢縺ｨ逕滓舌ｒ螳御ｺ縺励∪縺励◆縲" );
+ }
+ finally
+ {
+ Trace.Unindent();
+ }
+ //---------------------
+ #endregion
+ #region [ 繝励Λ繧ｰ繧､繝ｳ縺ｮ蛻晄悄蛹 ]
+ //---------------------
+ if( this.list繝励Λ繧ｰ繧､繝ｳ != null && this.list繝励Λ繧ｰ繧､繝ｳ.Count > 0 )
+ {
+ Trace.TraceInformation( "繝励Λ繧ｰ繧､繝ｳ縺ｮ蛻晄悄蛹悶ｒ陦後＞縺ｾ縺吶" );
+ Trace.Indent();
+ try
+ {
+ foreach( STPlugin st in this.list繝励Λ繧ｰ繧､繝ｳ )
+ {
+ Directory.SetCurrentDirectory( st.str繝励Λ繧ｰ繧､繝ｳ繝輔か繝ｫ繝 );
+ st.plugin.On蛻晄悄蛹( this.PluginHost );
+ st.plugin.OnManaged繝ｪ繧ｽ繝ｼ繧ｹ縺ｮ菴懈();
+ st.plugin.OnUnmanaged繝ｪ繧ｽ繝ｼ繧ｹ縺ｮ菴懈();
+ Directory.SetCurrentDirectory( TJAPlayer3.strEXE縺ｮ縺ゅｋ繝輔か繝ｫ繝 );
+ }
+ Trace.TraceInformation( "縺吶∋縺ｦ縺ｮ繝励Λ繧ｰ繧､繝ｳ縺ｮ蛻晄悄蛹悶ｒ螳御ｺ縺励∪縺励◆縲" );
+ }
+ catch
+ {
+ Trace.TraceError( "繝励Λ繧ｰ繧､繝ｳ縺ｮ縺ｩ繧後°縺ｮ蛻晄悄蛹悶↓螟ｱ謨励＠縺ｾ縺励◆縲" );
+ throw;
+ }
+ finally
+ {
+ Trace.Unindent();
+ }
+ }
+
+ //---------------------
+ #endregion
+
+ #region Discord縺ｮ蜃ｦ逅
+ Discord.Initialize("784989629728161813");
+ StartupTime = Discord.GetUnixTime();
+ Discord.UpdatePresence("", Properties.Discord.Stage_StartUp, StartupTime);
+ #endregion
+
+
+ Trace.TraceInformation( "繧｢繝励Μ繧ｱ繝ｼ繧ｷ繝ｧ繝ｳ縺ｮ蛻晄悄蛹悶ｒ螳御ｺ縺励∪縺励◆縲" );
+
+
+ #region [ 譛蛻昴ｮ繧ｹ繝繝ｼ繧ｸ縺ｮ襍ｷ蜍 ]
+ //---------------------
+ Trace.TraceInformation( "----------------------" );
+ Trace.TraceInformation( "笆 襍ｷ蜍" );
+
+ if ( TJAPlayer3.b繧ｳ繝ｳ繝代け繝医Δ繝ｼ繝 )
+ {
+ r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ = stage譖ｲ隱ｭ縺ｿ霎ｼ縺ｿ;
+ }
+ else
+ {
+ r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ = stage襍ｷ蜍;
+ }
+ r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ.On豢ｻ諤ｧ蛹();
+
+ //---------------------
+ #endregion
+ }
+
+ public void ShowWindowTitleWithSoundType()
+ {
+ string delay = "";
+ if ( Sound邂｡逅.GetCurrentSoundDeviceType() != "DirectSound" )
+ {
+ delay = "(" + Sound邂｡逅.GetSoundDelay() + "ms)";
+ }
+ AssemblyName asmApp = Assembly.GetExecutingAssembly().GetName();
+ base.Window.Text = asmApp.Name + " Ver." + VERSION + " (" + Sound邂｡逅.GetCurrentSoundDeviceType() + delay + ")";
+ }
+
+ private void t邨ゆｺ蜃ｦ逅()
+ {
+ if( !this.b邨ゆｺ蜃ｦ逅螳御ｺ貂医∩ )
+ {
+ Trace.TraceInformation( "----------------------" );
+ Trace.TraceInformation( "笆 繧｢繝励Μ繧ｱ繝ｼ繧ｷ繝ｧ繝ｳ縺ｮ邨ゆｺ" );
+ #region [ 譖ｲ讀懃ｴ｢縺ｮ邨ゆｺ蜃ｦ逅 ]
+ //---------------------
+ if ( actEnumSongs != null )
+ {
+ Trace.TraceInformation( "譖ｲ讀懃ｴ｢act縺ｮ邨ゆｺ蜃ｦ逅繧定｡後＞縺ｾ縺吶" );
+ Trace.Indent();
+ try
+ {
+ actEnumSongs.On髱樊ｴｻ諤ｧ蛹();
+ actEnumSongs= null;
+ Trace.TraceInformation( "譖ｲ讀懃ｴ｢act縺ｮ邨ゆｺ蜃ｦ逅繧貞ｮ御ｺ縺励∪縺励◆縲" );
+ }
+ catch ( Exception e )
+ {
+ Trace.TraceError( e.ToString() );
+ Trace.TraceError( "譖ｲ讀懃ｴ｢act縺ｮ邨ゆｺ蜃ｦ逅縺ｫ螟ｱ謨励＠縺ｾ縺励◆縲" );
+ }
+ finally
+ {
+ Trace.Unindent();
+ }
+ }
+ //---------------------
+ #endregion
+ #region [ 迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ縺ｮ邨ゆｺ蜃ｦ逅 ]
+ //---------------------
+ if( TJAPlayer3.r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ != null && TJAPlayer3.r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ.b豢ｻ諤ｧ蛹悶＠縺ｦ繧 ) // #25398 2011.06.07 MODIFY FROM
+ {
+ Trace.TraceInformation( "迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ繧堤ｵゆｺ縺励∪縺吶" );
+ Trace.Indent();
+ try
+ {
+ r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ.On髱樊ｴｻ諤ｧ蛹();
+ Trace.TraceInformation( "迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ縺ｮ邨ゆｺ蜃ｦ逅繧貞ｮ御ｺ縺励∪縺励◆縲" );
+ }
+ finally
+ {
+ Trace.Unindent();
+ }
+ }
+ //---------------------
+ #endregion
+ #region [ 繝励Λ繧ｰ繧､繝ｳ縺ｮ邨ゆｺ蜃ｦ逅 ]
+ //---------------------
+ if (this.list繝励Λ繧ｰ繧､繝ｳ != null && this.list繝励Λ繧ｰ繧､繝ｳ.Count > 0)
+ {
+ Trace.TraceInformation( "縺吶∋縺ｦ縺ｮ繝励Λ繧ｰ繧､繝ｳ繧堤ｵゆｺ縺励∪縺吶" );
+ Trace.Indent();
+ try
+ {
+ foreach( STPlugin st in this.list繝励Λ繧ｰ繧､繝ｳ )
+ {
+ Directory.SetCurrentDirectory( st.str繝励Λ繧ｰ繧､繝ｳ繝輔か繝ｫ繝 );
+ st.plugin.OnUnmanaged繝ｪ繧ｽ繝ｼ繧ｹ縺ｮ隗｣謾ｾ();
+ st.plugin.OnManaged繝ｪ繧ｽ繝ｼ繧ｹ縺ｮ隗｣謾ｾ();
+ st.plugin.On邨ゆｺ();
+ Directory.SetCurrentDirectory( TJAPlayer3.strEXE縺ｮ縺ゅｋ繝輔か繝ｫ繝 );
+ }
+ PluginHost = null;
+ Trace.TraceInformation( "縺吶∋縺ｦ縺ｮ繝励Λ繧ｰ繧､繝ｳ縺ｮ邨ゆｺ蜃ｦ逅繧貞ｮ御ｺ縺励∪縺励◆縲" );
+ }
+ finally
+ {
+ Trace.Unindent();
+ }
+ }
+ //---------------------
+ #endregion
+ #region Discord縺ｮ蜃ｦ逅
+ Discord.Shutdown();
+ #endregion
+ #region [ 譖ｲ繝ｪ繧ｹ繝医ｮ邨ゆｺ蜃ｦ逅 ]
+ //---------------------
+ if (Songs邂｡逅 != null)
+ {
+ Trace.TraceInformation( "譖ｲ繝ｪ繧ｹ繝医ｮ邨ゆｺ蜃ｦ逅繧定｡後＞縺ｾ縺吶" );
+ Trace.Indent();
+ try
+ {
+ Songs邂｡逅 = null;
+ Trace.TraceInformation( "譖ｲ繝ｪ繧ｹ繝医ｮ邨ゆｺ蜃ｦ逅繧貞ｮ御ｺ縺励∪縺励◆縲" );
+ }
+ catch( Exception exception )
+ {
+ Trace.TraceError( exception.ToString() );
+ Trace.TraceError( "譖ｲ繝ｪ繧ｹ繝医ｮ邨ゆｺ蜃ｦ逅縺ｫ螟ｱ謨励＠縺ｾ縺励◆縲" );
+ }
+ finally
+ {
+ Trace.Unindent();
+ }
+ }
+ CAvi.t邨ゆｺ();
+ //---------------------
+ #endregion
+ #region TextureLoader縺ｮ蜃ｦ逅
+ Tx.DisposeTexture();
+ #endregion
+ #region [ 繧ｹ繧ｭ繝ｳ縺ｮ邨ゆｺ蜃ｦ逅 ]
+ //---------------------
+ if (Skin != null)
+ {
+ Trace.TraceInformation( "繧ｹ繧ｭ繝ｳ縺ｮ邨ゆｺ蜃ｦ逅繧定｡後＞縺ｾ縺吶" );
+ Trace.Indent();
+ try
+ {
+ Skin.Dispose();
+ Skin = null;
+ Trace.TraceInformation( "繧ｹ繧ｭ繝ｳ縺ｮ邨ゆｺ蜃ｦ逅繧貞ｮ御ｺ縺励∪縺励◆縲" );
+ }
+ catch( Exception exception2 )
+ {
+ Trace.TraceError( exception2.ToString() );
+ Trace.TraceError( "繧ｹ繧ｭ繝ｳ縺ｮ邨ゆｺ蜃ｦ逅縺ｫ螟ｱ謨励＠縺ｾ縺励◆縲" );
+ }
+ finally
+ {
+ Trace.Unindent();
+ }
+ }
+ //---------------------
+ #endregion
+ #region [ DirectSound縺ｮ邨ゆｺ蜃ｦ逅 ]
+ //---------------------
+ if (Sound邂｡逅 != null)
+ {
+ Trace.TraceInformation( "DirectSound 縺ｮ邨ゆｺ蜃ｦ逅繧定｡後＞縺ｾ縺吶" );
+ Trace.Indent();
+ try
+ {
+ Sound邂｡逅.Dispose();
+ Sound邂｡逅 = null;
+ Trace.TraceInformation( "DirectSound 縺ｮ邨ゆｺ蜃ｦ逅繧貞ｮ御ｺ縺励∪縺励◆縲" );
+ }
+ catch( Exception exception3 )
+ {
+ Trace.TraceError( exception3.ToString() );
+ Trace.TraceError( "DirectSound 縺ｮ邨ゆｺ蜃ｦ逅縺ｫ螟ｱ謨励＠縺ｾ縺励◆縲" );
+ }
+ finally
+ {
+ Trace.Unindent();
+ }
+ }
+ //---------------------
+ #endregion
+ #region [ 繝代ャ繝峨ｮ邨ゆｺ蜃ｦ逅 ]
+ //---------------------
+ if (Pad != null)
+ {
+ Trace.TraceInformation( "繝代ャ繝峨ｮ邨ゆｺ蜃ｦ逅繧定｡後＞縺ｾ縺吶" );
+ Trace.Indent();
+ try
+ {
+ Pad = null;
+ Trace.TraceInformation( "繝代ャ繝峨ｮ邨ゆｺ蜃ｦ逅繧貞ｮ御ｺ縺励∪縺励◆縲" );
+ }
+ catch( Exception exception4 )
+ {
+ Trace.TraceError( exception4.ToString() );
+ Trace.TraceError( "繝代ャ繝峨ｮ邨ゆｺ蜃ｦ逅縺ｫ螟ｱ謨励＠縺ｾ縺励◆縲" );
+ }
+ finally
+ {
+ Trace.Unindent();
+ }
+ }
+ //---------------------
+ #endregion
+ #region [ DirectInput, MIDI蜈･蜉帙ｮ邨ゆｺ蜃ｦ逅 ]
+ //---------------------
+ if (Input邂｡逅 != null)
+ {
+ Trace.TraceInformation( "DirectInput, MIDI蜈･蜉帙ｮ邨ゆｺ蜃ｦ逅繧定｡後＞縺ｾ縺吶" );
+ Trace.Indent();
+ try
+ {
+ Input邂｡逅.Dispose();
+ Input邂｡逅 = null;
+ Trace.TraceInformation( "DirectInput, MIDI蜈･蜉帙ｮ邨ゆｺ蜃ｦ逅繧貞ｮ御ｺ縺励∪縺励◆縲" );
+ }
+ catch( Exception exception5 )
+ {
+ Trace.TraceError( exception5.ToString() );
+ Trace.TraceError( "DirectInput, MIDI蜈･蜉帙ｮ邨ゆｺ蜃ｦ逅縺ｫ螟ｱ謨励＠縺ｾ縺励◆縲" );
+ }
+ finally
+ {
+ Trace.Unindent();
+ }
+ }
+ //---------------------
+ #endregion
+ #region [ 譁蟄励さ繝ｳ繧ｽ繝ｼ繝ｫ縺ｮ邨ゆｺ蜃ｦ逅 ]
+ //---------------------
+ if (act譁蟄励さ繝ｳ繧ｽ繝ｼ繝ｫ != null)
+ {
+ Trace.TraceInformation( "譁蟄励さ繝ｳ繧ｽ繝ｼ繝ｫ縺ｮ邨ゆｺ蜃ｦ逅繧定｡後＞縺ｾ縺吶" );
+ Trace.Indent();
+ try
+ {
+ act譁蟄励さ繝ｳ繧ｽ繝ｼ繝ｫ.On髱樊ｴｻ諤ｧ蛹();
+ act譁蟄励さ繝ｳ繧ｽ繝ｼ繝ｫ = null;
+ Trace.TraceInformation( "譁蟄励さ繝ｳ繧ｽ繝ｼ繝ｫ縺ｮ邨ゆｺ蜃ｦ逅繧貞ｮ御ｺ縺励∪縺励◆縲" );
+ }
+ catch( Exception exception6 )
+ {
+ Trace.TraceError( exception6.ToString() );
+ Trace.TraceError( "譁蟄励さ繝ｳ繧ｽ繝ｼ繝ｫ縺ｮ邨ゆｺ蜃ｦ逅縺ｫ螟ｱ謨励＠縺ｾ縺励◆縲" );
+ }
+ finally
+ {
+ Trace.Unindent();
+ }
+ }
+ //---------------------
+ #endregion
+ #region [ FPS繧ｫ繧ｦ繝ｳ繧ｿ縺ｮ邨ゆｺ蜃ｦ逅 ]
+ //---------------------
+ Trace.TraceInformation("FPS繧ｫ繧ｦ繝ｳ繧ｿ縺ｮ邨ゆｺ蜃ｦ逅繧定｡後＞縺ｾ縺吶");
+ Trace.Indent();
+ try
+ {
+ if( FPS != null )
+ {
+ FPS = null;
+ }
+ Trace.TraceInformation( "FPS繧ｫ繧ｦ繝ｳ繧ｿ縺ｮ邨ゆｺ蜃ｦ逅繧貞ｮ御ｺ縺励∪縺励◆縲" );
+ }
+ finally
+ {
+ Trace.Unindent();
+ }
+ //---------------------
+ #endregion
+ #region [ 繧ｿ繧､繝槭ｮ邨ゆｺ蜃ｦ逅 ]
+ //---------------------
+ Trace.TraceInformation("繧ｿ繧､繝槭ｮ邨ゆｺ蜃ｦ逅繧定｡後＞縺ｾ縺吶");
+ Trace.Indent();
+ try
+ {
+ if( Timer != null )
+ {
+ Timer.Dispose();
+ Timer = null;
+ Trace.TraceInformation( "繧ｿ繧､繝槭ｮ邨ゆｺ蜃ｦ逅繧貞ｮ御ｺ縺励∪縺励◆縲" );
+ }
+ else
+ {
+ Trace.TraceInformation( "繧ｿ繧､繝槭ｯ菴ｿ逕ｨ縺輔ｌ縺ｦ縺縺ｾ縺帙ｓ縲" );
+ }
+ }
+ finally
+ {
+ Trace.Unindent();
+ }
+ //---------------------
+ #endregion
+ #region [ Config.ini縺ｮ蜃ｺ蜉 ]
+ //---------------------
+ Trace.TraceInformation("Config.ini 繧貞ｺ蜉帙＠縺ｾ縺吶");
+// if ( ConfigIni.bIsSwappedGuitarBass ) // #24063 2011.1.16 yyagi 繧ｮ繧ｿ繝ｼ繝吶ｼ繧ｹ縺後せ繝ｯ繝繝励＠縺ｦ縺繧九→縺阪ｯ蜈縺ｫ謌ｻ縺
+ string str = strEXE縺ｮ縺ゅｋ繝輔か繝ｫ繝 + "Config.ini";
+ Trace.Indent();
+ try
+ {
+ if ( DTXVmode.Enabled )
+ {
+ DTXVmode.tUpdateConfigIni();
+ Trace.TraceInformation( "DTXV繝｢繝ｼ繝峨ｮ險ｭ螳壽ュ蝣ｱ繧偵，onfig.ini縺ｫ菫晏ｭ倥＠縺ｾ縺励◆縲" );
+ }
+ else
+ {
+ ConfigIni.t譖ｸ縺榊ｺ縺( str );
+ Trace.TraceInformation( "菫晏ｭ倥＠縺ｾ縺励◆縲({0})", str );
+ }
+ }
+ catch( Exception e )
+ {
+ Trace.TraceError( e.ToString() );
+ Trace.TraceError( "Config.ini 縺ｮ蜃ｺ蜉帙↓螟ｱ謨励＠縺ｾ縺励◆縲({0})", str );
+ }
+ finally
+ {
+ Trace.Unindent();
+ }
+
+ Trace.TraceInformation("Deinitializing loudness scanning, song gain control, and sound group level control...");
+ Trace.Indent();
+ try
+ {
+ SoundGroupLevelController = null;
+ SongGainController = null;
+ LoudnessMetadataScanner.StopBackgroundScanning(joinImmediately: true);
+ actScanningLoudness.On髱樊ｴｻ諤ｧ蛹();
+ actScanningLoudness = null;
+ }
+ finally
+ {
+ Trace.Unindent();
+ Trace.TraceInformation("Deinitialized loudness scanning, song gain control, and sound group level control.");
+ }
+
+ ConfigIni = null;
+
+ //---------------------
+ #endregion
+ #region [ DTXVmode縺ｮ邨ゆｺ蜃ｦ逅 ]
+ //---------------------
+ //Trace.TraceInformation( "DTXV繝｢繝ｼ繝峨ｮ邨ゆｺ蜃ｦ逅繧定｡後＞縺ｾ縺吶" );
+ //Trace.Indent();
+ try
+ {
+ if ( DTXVmode != null )
+ {
+ DTXVmode = null;
+ //Trace.TraceInformation( "DTXV繝｢繝ｼ繝峨ｮ邨ゆｺ蜃ｦ逅繧貞ｮ御ｺ縺励∪縺励◆縲" );
+ }
+ else
+ {
+ //Trace.TraceInformation( "DTXV繝｢繝ｼ繝峨ｯ菴ｿ逕ｨ縺輔ｌ縺ｦ縺縺ｾ縺帙ｓ縲" );
+ }
+ }
+ finally
+ {
+ //Trace.Unindent();
+ }
+ //---------------------
+ #endregion
+ #region [ DirectX縺ｮ邨ゆｺ蜃ｦ逅 ]
+ base.GraphicsDeviceManager.Dispose();
+ #endregion
+ Trace.TraceInformation( "繧｢繝励Μ繧ｱ繝ｼ繧ｷ繝ｧ繝ｳ縺ｮ邨ゆｺ蜃ｦ逅繧貞ｮ御ｺ縺励∪縺励◆縲" );
+
+
+ this.b邨ゆｺ蜃ｦ逅螳御ｺ貂医∩ = true;
+ }
+ }
+ private CScoreIni tScoreIni縺ｸBGMAdjust縺ｨHistory縺ｨPlayCount繧呈峩譁ｰ(string str譁ｰ繝偵せ繝医Μ陦)
+ {
+ bool bIsUpdatedDrums, bIsUpdatedGuitar, bIsUpdatedBass;
+ string strFilename = DTX.str繝輔ぃ繧､繝ｫ蜷阪ｮ邨ｶ蟇ｾ繝代せ + ".score.ini";
+ CScoreIni ini = new CScoreIni( strFilename );
+ if( !File.Exists( strFilename ) )
+ {
+ ini.st繝輔ぃ繧､繝ｫ.Title = DTX.TITLE;
+ ini.st繝輔ぃ繧､繝ｫ.Name = DTX.str繝輔ぃ繧､繝ｫ蜷;
+ ini.st繝輔ぃ繧､繝ｫ.Hash = CScoreIni.t繝輔ぃ繧､繝ｫ縺ｮMD5繧呈ｱゅａ縺ｦ霑斐☆( DTX.str繝輔ぃ繧､繝ｫ蜷阪ｮ邨ｶ蟇ｾ繝代せ );
+ for( int i = 0; i < 6; i++ )
+ {
+ ini.st繧ｻ繧ｯ繧ｷ繝ｧ繝ｳ[ i ].nPerfect縺ｫ縺ｪ繧狗ｯ蝗ｲms = nPerfect遽蝗ｲms;
+ ini.st繧ｻ繧ｯ繧ｷ繝ｧ繝ｳ[ i ].nGreat縺ｫ縺ｪ繧狗ｯ蝗ｲms = nGreat遽蝗ｲms;
+ ini.st繧ｻ繧ｯ繧ｷ繝ｧ繝ｳ[ i ].nGood縺ｫ縺ｪ繧狗ｯ蝗ｲms = nGood遽蝗ｲms;
+ ini.st繧ｻ繧ｯ繧ｷ繝ｧ繝ｳ[ i ].nPoor縺ｫ縺ｪ繧狗ｯ蝗ｲms = nPoor遽蝗ｲms;
+ }
+ }
+ ini.st繝輔ぃ繧､繝ｫ.BGMAdjust = DTX.nBGMAdjust;
+ CScoreIni.t譖ｴ譁ｰ譚｡莉ｶ繧貞叙蠕励☆繧( out bIsUpdatedDrums, out bIsUpdatedGuitar, out bIsUpdatedBass );
+ if( bIsUpdatedDrums || bIsUpdatedGuitar || bIsUpdatedBass )
+ {
+ if( bIsUpdatedDrums )
+ {
+ ini.st繝輔ぃ繧､繝ｫ.PlayCountDrums++;
+ }
+ if( bIsUpdatedGuitar )
+ {
+ ini.st繝輔ぃ繧､繝ｫ.PlayCountGuitar++;
+ }
+ if( bIsUpdatedBass )
+ {
+ ini.st繝輔ぃ繧､繝ｫ.PlayCountBass++;
+ }
+ ini.t繝偵せ繝医Μ繧定ｿｽ蜉縺吶ｋ( str譁ｰ繝偵せ繝医Μ陦 );
+ if( !b繧ｳ繝ｳ繝代け繝医Δ繝ｼ繝 )
+ {
+ stage驕ｸ譖ｲ.r遒ｺ螳壹＆繧後◆繧ｹ繧ｳ繧｢.隴憺擇諠蝣ｱ.貍泌･丞屓謨ｰ.Drums = ini.st繝輔ぃ繧､繝ｫ.PlayCountDrums;
+ stage驕ｸ譖ｲ.r遒ｺ螳壹＆繧後◆繧ｹ繧ｳ繧｢.隴憺擇諠蝣ｱ.貍泌･丞屓謨ｰ.Guitar = ini.st繝輔ぃ繧､繝ｫ.PlayCountGuitar;
+ stage驕ｸ譖ｲ.r遒ｺ螳壹＆繧後◆繧ｹ繧ｳ繧｢.隴憺擇諠蝣ｱ.貍泌･丞屓謨ｰ.Bass = ini.st繝輔ぃ繧､繝ｫ.PlayCountBass;
+ for( int j = 0; j < ini.st繝輔ぃ繧､繝ｫ.History.Length; j++ )
+ {
+ stage驕ｸ譖ｲ.r遒ｺ螳壹＆繧後◆繧ｹ繧ｳ繧｢.隴憺擇諠蝣ｱ.貍泌･丞ｱ･豁ｴ[ j ] = ini.st繝輔ぃ繧､繝ｫ.History[ j ];
+ }
+ }
+ }
+ if( ConfigIni.bScoreIni繧貞ｺ蜉帙☆繧 )
+ {
+ ini.t譖ｸ縺榊ｺ縺( strFilename );
+ }
+
+ return ini;
+ }
+ private void t繧ｬ繝吶ｼ繧ｸ繧ｳ繝ｬ繧ｯ繧ｷ繝ｧ繝ｳ繧貞ｮ溯｡後☆繧()
+ {
+ GC.Collect(GC.MaxGeneration);
+ GC.WaitForPendingFinalizers();
+ GC.Collect(GC.MaxGeneration);
+ }
+ private void t繝励Λ繧ｰ繧､繝ｳ讀懃ｴ｢縺ｨ逕滓()
+ {
+ this.list繝励Λ繧ｰ繧､繝ｳ = new List();
+
+ string strIPluginActivity縺ｮ蜷榊燕 = typeof( IPluginActivity ).FullName;
+ string str繝励Λ繧ｰ繧､繝ｳ繝輔か繝ｫ繝繝代せ = strEXE縺ｮ縺ゅｋ繝輔か繝ｫ繝 + "Plugins\\";
+
+ this.t謖螳壹ヵ繧ｩ繝ｫ繝蜀縺ｧ縺ｮ繝励Λ繧ｰ繧､繝ｳ讀懃ｴ｢縺ｨ逕滓( str繝励Λ繧ｰ繧､繝ｳ繝輔か繝ｫ繝繝代せ, strIPluginActivity縺ｮ蜷榊燕 );
+
+ if( this.list繝励Λ繧ｰ繧､繝ｳ.Count > 0 )
+ Trace.TraceInformation( this.list繝励Λ繧ｰ繧､繝ｳ.Count + " 蛟九ｮ繝励Λ繧ｰ繧､繝ｳ繧定ｪｭ縺ｿ霎ｼ縺ｿ縺ｾ縺励◆縲" );
+ }
+
+ public void RefleshSkin()
+ {
+ Trace.TraceInformation("繧ｹ繧ｭ繝ｳ螟画峩:" + TJAPlayer3.Skin.GetCurrentSkinSubfolderFullName(false));
+
+ TJAPlayer3.act譁蟄励さ繝ｳ繧ｽ繝ｼ繝ｫ.On髱樊ｴｻ諤ｧ蛹();
+
+ TJAPlayer3.Skin.Dispose();
+ TJAPlayer3.Skin = null;
+ TJAPlayer3.Skin = new CSkin(TJAPlayer3.ConfigIni.strSystemSkinSubfolderFullName, false);
+
+
+ TJAPlayer3.Tx.DisposeTexture();
+ TJAPlayer3.Tx.LoadTexture();
+
+ TJAPlayer3.act譁蟄励さ繝ｳ繧ｽ繝ｼ繝ｫ.On豢ｻ諤ｧ蛹();
+ }
+ #region [ Window繧､繝吶Φ繝亥ｦ逅 ]
+ private void t謖螳壹ヵ繧ｩ繝ｫ繝蜀縺ｧ縺ｮ繝励Λ繧ｰ繧､繝ｳ讀懃ｴ｢縺ｨ逕滓( string str繝励Λ繧ｰ繧､繝ｳ繝輔か繝ｫ繝繝代せ, string str繝励Λ繧ｰ繧､繝ｳ蝙句錐 )
+ {
+ // 謖螳壹＆繧後◆繝代せ縺悟ｭ伜惠縺励↑縺縺ｨ繧ｨ繝ｩ繝ｼ
+ if( !Directory.Exists( str繝励Λ繧ｰ繧､繝ｳ繝輔か繝ｫ繝繝代せ ) )
+ {
+ Trace.TraceWarning( "繝励Λ繧ｰ繧､繝ｳ繝輔か繝ｫ繝縺悟ｭ伜惠縺励∪縺帙ｓ縲(" + str繝励Λ繧ｰ繧､繝ｳ繝輔か繝ｫ繝繝代せ + ")" );
+ return;
+ }
+
+ // (1) 縺吶∋縺ｦ縺ｮ *.dll 縺ｫ縺､縺縺ｦ窶ｦ
+ string[] strDLLs = System.IO.Directory.GetFiles( str繝励Λ繧ｰ繧､繝ｳ繝輔か繝ｫ繝繝代せ, "*.dll" );
+ foreach( string dllName in strDLLs )
+ {
+ try
+ {
+ // (1-1) dll 繧偵い繧ｻ繝ｳ繝悶Μ縺ｨ縺励※隱ｭ縺ｿ霎ｼ繧縲
+ System.Reflection.Assembly asm = System.Reflection.Assembly.LoadFrom( dllName );
+
+ // (1-2) 繧｢繧ｻ繝ｳ繝悶Μ蜀縺ｮ縺吶∋縺ｦ縺ｮ蝙九↓縺､縺縺ｦ縲√励Λ繧ｰ繧､繝ｳ縺ｨ縺励※譛牙柑縺玖ｪｿ縺ｹ繧
+ foreach( Type t in asm.GetTypes() )
+ {
+ // (1-3) 竊薙け繝ｩ繧ｹ縺ｧ縺ゅｊ竊撤ublic縺ｧ縺ゅｊ竊捺歓雎｡繧ｯ繝ｩ繧ｹ縺ｧ縺ｪ縺鞘的Plugin蝙九ｮ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺御ｽ懊ｌ繧九蝙九ｒ謖√▲縺ｦ縺繧後ｰ譛牙柑
+ if( t.IsClass && t.IsPublic && !t.IsAbstract && t.GetInterface( str繝励Λ繧ｰ繧､繝ｳ蝙句錐 ) != null )
+ {
+ // (1-4) 繧ｯ繝ｩ繧ｹ蜷阪°繧峨う繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ繧剃ｽ懈舌☆繧
+ var st = new STPlugin() {
+ plugin = (IPluginActivity) asm.CreateInstance( t.FullName ),
+ str繝励Λ繧ｰ繧､繝ｳ繝輔か繝ｫ繝 = Path.GetDirectoryName( dllName ),
+ str繧｢繧ｻ繝ｳ繝悶Μ邁｡譏灘錐 = asm.GetName().Name,
+ Version = asm.GetName().Version,
+ };
+
+ // (1-5) 繝励Λ繧ｰ繧､繝ｳ繝ｪ繧ｹ繝医∈逋ｻ骭ｲ
+ this.list繝励Λ繧ｰ繧､繝ｳ.Add( st );
+ Trace.TraceInformation( "繝励Λ繧ｰ繧､繝ｳ {0} ({1}, {2}, {3}) 繧定ｪｭ縺ｿ霎ｼ縺ｿ縺ｾ縺励◆縲", t.FullName, Path.GetFileName( dllName ), st.str繧｢繧ｻ繝ｳ繝悶Μ邁｡譏灘錐, st.Version.ToString() );
+ }
+ }
+ }
+ catch (Exception e)
+ {
+ Trace.TraceError( e.ToString() );
+ Trace.TraceInformation( dllName + " 縺九ｉ繝励Λ繧ｰ繧､繝ｳ繧堤函謌舌☆繧九％縺ｨ縺ｫ螟ｱ謨励＠縺ｾ縺励◆縲ゅせ繧ｭ繝繝励＠縺ｾ縺吶" );
+ }
+ }
+
+ // (2) 繧ｵ繝悶ヵ繧ｩ繝ｫ繝縺後≠繧後ｰ蜀榊ｸｰ縺吶ｋ
+ string[] strDirs = Directory.GetDirectories( str繝励Λ繧ｰ繧､繝ｳ繝輔か繝ｫ繝繝代せ, "*" );
+ foreach( string dir in strDirs )
+ this.t謖螳壹ヵ繧ｩ繝ｫ繝蜀縺ｧ縺ｮ繝励Λ繧ｰ繧､繝ｳ讀懃ｴ｢縺ｨ逕滓( dir + "\\", str繝励Λ繧ｰ繧､繝ｳ蝙句錐 );
+ }
+ //-----------------
+ private void Window_ApplicationActivated( object sender, EventArgs e )
+ {
+ this.bApplicationActive = true;
+ }
+ private void Window_ApplicationDeactivated( object sender, EventArgs e )
+ {
+ this.bApplicationActive = false;
+ }
+ private void Window_KeyDown( object sender, KeyEventArgs e )
+ {
+ if ( e.KeyCode == Keys.Menu )
+ {
+ e.Handled = true;
+ e.SuppressKeyPress = true;
+ }
+ else if ( ( e.KeyCode == Keys.Return ) && e.Alt )
+ {
+ if ( ConfigIni != null )
+ {
+ ConfigIni.b繧ｦ繧｣繝ｳ繝峨え繝｢繝ｼ繝 = !ConfigIni.b繧ｦ繧｣繝ｳ繝峨え繝｢繝ｼ繝;
+ this.t蜈ｨ逕ｻ髱｢_繧ｦ繧｣繝ｳ繝峨え繝｢繝ｼ繝牙繧頑崛縺();
+ }
+ e.Handled = true;
+ e.SuppressKeyPress = true;
+ }
+ else
+ {
+ for ( int i = 0; i < 0x10; i++ )
+ {
+ if ( ConfigIni.KeyAssign.System.Capture[ i ].繧ｳ繝ｼ繝 > 0 &&
+ e.KeyCode == DeviceConstantConverter.KeyToKeyCode( (SlimDXKeys.Key) ConfigIni.KeyAssign.System.Capture[ i ].繧ｳ繝ｼ繝 ) )
+ {
+ // Debug.WriteLine( "capture: " + string.Format( "{0:2x}", (int) e.KeyCode ) + " " + (int) e.KeyCode );
+ string strFullPath =
+ Path.Combine( TJAPlayer3.strEXE縺ｮ縺ゅｋ繝輔か繝ｫ繝, "Capture_img" );
+ strFullPath = Path.Combine( strFullPath, DateTime.Now.ToString( "yyyyMMddHHmmss" ) + ".png" );
+ SaveResultScreen( strFullPath );
+ }
+ }
+ }
+ }
+ private void Window_MouseUp( object sender, MouseEventArgs e )
+ {
+ mb = e.Button;
+ }
+
+ private void Window_MouseDoubleClick( object sender, MouseEventArgs e) // #23510 2010.11.13 yyagi: to go full screen mode
+ {
+ if ( mb.Equals(MouseButtons.Left) && ConfigIni.bIsAllowedDoubleClickFullscreen ) // #26752 2011.11.27 yyagi
+ {
+ ConfigIni.b繧ｦ繧｣繝ｳ繝峨え繝｢繝ｼ繝 = false;
+ this.t蜈ｨ逕ｻ髱｢_繧ｦ繧｣繝ｳ繝峨え繝｢繝ｼ繝牙繧頑崛縺();
+ }
+ }
+ private void Window_ResizeEnd(object sender, EventArgs e) // #23510 2010.11.20 yyagi: to get resized window size
+ {
+ if ( ConfigIni.b繧ｦ繧｣繝ｳ繝峨え繝｢繝ｼ繝 )
+ {
+ ConfigIni.n蛻晄悄繧ｦ繧｣繝ｳ繝峨え髢句ｧ倶ｽ咲ｽｮX = base.Window.Location.X; // #30675 2013.02.04 ikanick add
+ ConfigIni.n蛻晄悄繧ｦ繧｣繝ｳ繝峨え髢句ｧ倶ｽ咲ｽｮY = base.Window.Location.Y; //
+ }
+
+ ConfigIni.n繧ｦ繧､繝ｳ繝峨えwidth = (ConfigIni.b繧ｦ繧｣繝ｳ繝峨え繝｢繝ｼ繝) ? base.Window.ClientSize.Width : currentClientSize.Width; // #23510 2010.10.31 yyagi add
+ ConfigIni.n繧ｦ繧､繝ｳ繝峨えheight = (ConfigIni.b繧ｦ繧｣繝ｳ繝峨え繝｢繝ｼ繝) ? base.Window.ClientSize.Height : currentClientSize.Height;
+ }
+ #endregion
+ #endregion
+ }
+}
diff --git a/TJAPlayer3/DTXManiaGR.exe.x86.manifest b/TJAPlayer3/DTXManiaGR.exe.x86.manifest
new file mode 100644
index 00000000..0bfcb3b0
--- /dev/null
+++ b/TJAPlayer3/DTXManiaGR.exe.x86.manifest
@@ -0,0 +1,8 @@
+ｻｿ
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/TJAPlayer3/GlobalSuppressions.cs b/TJAPlayer3/GlobalSuppressions.cs
new file mode 100644
index 00000000..92c01f87
Binary files /dev/null and b/TJAPlayer3/GlobalSuppressions.cs differ
diff --git a/TJAPlayer3/Items/CItemBase.cs b/TJAPlayer3/Items/CItemBase.cs
new file mode 100644
index 00000000..7a1be928
--- /dev/null
+++ b/TJAPlayer3/Items/CItemBase.cs
@@ -0,0 +1,120 @@
+ｻｿusing System;
+using System.Globalization;
+using System.Collections.Generic;
+using System.Text;
+using System.Diagnostics;
+
+namespace TJAPlayer3
+{
+ ///
+ /// 縺吶∋縺ｦ縺ｮ繧｢繧､繝繝縺ｮ蝓ｺ譛ｬ繧ｯ繝ｩ繧ｹ縲
+ ///
+ internal class CItemBase
+ {
+ // 繝励Ο繝代ユ繧｣
+
+ public E繝代ロ繝ｫ遞ｮ蛻･ e繝代ロ繝ｫ遞ｮ蛻･;
+ public enum E繝代ロ繝ｫ遞ｮ蛻･
+ {
+ 騾壼ｸｸ,
+ 縺昴ｮ莉
+ }
+
+ public E遞ｮ蛻･ e遞ｮ蛻･;
+ public enum E遞ｮ蛻･
+ {
+ 蝓ｺ譛ｬ蠖｢,
+ ONorOFF繝医げ繝ｫ,
+ ONorOFFor荳榊ｮ壹せ繝ｪ繝ｼ繧ｹ繝繝ｼ繝,
+ 謨ｴ謨ｰ,
+ 繝ｪ繧ｹ繝,
+ 蛻譖ｿ繝ｪ繧ｹ繝
+ }
+
+ public string str鬆逶ｮ蜷;
+ public string str隱ｬ譏取枚;
+
+
+ // 繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ
+
+ public CItemBase()
+ {
+ this.str鬆逶ｮ蜷 = "";
+ this.str隱ｬ譏取枚 = "";
+ }
+ public CItemBase( string str鬆逶ｮ蜷 )
+ : this()
+ {
+ this.t蛻晄悄蛹( str鬆逶ｮ蜷 );
+ }
+ public CItemBase(string str鬆逶ｮ蜷, string str隱ｬ譏取枚jp)
+ : this() {
+ this.t蛻晄悄蛹(str鬆逶ｮ蜷, str隱ｬ譏取枚jp);
+ }
+ public CItemBase(string str鬆逶ｮ蜷, string str隱ｬ譏取枚jp, string str隱ｬ譏取枚en)
+ : this() {
+ this.t蛻晄悄蛹(str鬆逶ｮ蜷, str隱ｬ譏取枚jp, str隱ｬ譏取枚en);
+ }
+
+ public CItemBase(string str鬆逶ｮ蜷, E繝代ロ繝ｫ遞ｮ蛻･ e繝代ロ繝ｫ遞ｮ蛻･)
+ : this()
+ {
+ this.t蛻晄悄蛹( str鬆逶ｮ蜷, e繝代ロ繝ｫ遞ｮ蛻･ );
+ }
+ public CItemBase(string str鬆逶ｮ蜷, E繝代ロ繝ｫ遞ｮ蛻･ e繝代ロ繝ｫ遞ｮ蛻･, string str隱ｬ譏取枚jp)
+ : this() {
+ this.t蛻晄悄蛹(str鬆逶ｮ蜷, e繝代ロ繝ｫ遞ｮ蛻･, str隱ｬ譏取枚jp);
+ }
+ public CItemBase(string str鬆逶ｮ蜷, E繝代ロ繝ｫ遞ｮ蛻･ e繝代ロ繝ｫ遞ｮ蛻･, string str隱ｬ譏取枚jp, string str隱ｬ譏取枚en)
+ : this() {
+ this.t蛻晄悄蛹(str鬆逶ｮ蜷, e繝代ロ繝ｫ遞ｮ蛻･, str隱ｬ譏取枚jp, str隱ｬ譏取枚en);
+ }
+
+
+ // 繝｡繧ｽ繝繝会ｼ帛ｭ舌け繝ｩ繧ｹ縺ｧ螳溯｣縺吶ｋ
+
+ public virtual void tEnter謚ｼ荳()
+ {
+ }
+ public virtual void t鬆逶ｮ蛟､繧呈ｬ｡縺ｸ遘ｻ蜍()
+ {
+ }
+ public virtual void t鬆逶ｮ蛟､繧貞燕縺ｸ遘ｻ蜍()
+ {
+ }
+ public virtual void t蛻晄悄蛹( string str鬆逶ｮ蜷 )
+ {
+ this.t蛻晄悄蛹( str鬆逶ｮ蜷, E繝代ロ繝ｫ遞ｮ蛻･.騾壼ｸｸ );
+ }
+ public virtual void t蛻晄悄蛹(string str鬆逶ｮ蜷, string str隱ｬ譏取枚jp) {
+ this.t蛻晄悄蛹(str鬆逶ｮ蜷, E繝代ロ繝ｫ遞ｮ蛻･.騾壼ｸｸ, str隱ｬ譏取枚jp, str隱ｬ譏取枚jp);
+ }
+ public virtual void t蛻晄悄蛹(string str鬆逶ｮ蜷, string str隱ｬ譏取枚jp, string str隱ｬ譏取枚en) {
+ this.t蛻晄悄蛹(str鬆逶ｮ蜷, E繝代ロ繝ｫ遞ｮ蛻･.騾壼ｸｸ, str隱ｬ譏取枚jp, str隱ｬ譏取枚en);
+ }
+
+ public virtual void t蛻晄悄蛹( string str鬆逶ｮ蜷, E繝代ロ繝ｫ遞ｮ蛻･ e繝代ロ繝ｫ遞ｮ蛻･ )
+ {
+ this.t蛻晄悄蛹(str鬆逶ｮ蜷, e繝代ロ繝ｫ遞ｮ蛻･, "", "");
+ }
+ public virtual void t蛻晄悄蛹(string str鬆逶ｮ蜷, E繝代ロ繝ｫ遞ｮ蛻･ e繝代ロ繝ｫ遞ｮ蛻･, string str隱ｬ譏取枚jp) {
+ this.t蛻晄悄蛹(str鬆逶ｮ蜷, e繝代ロ繝ｫ遞ｮ蛻･, str隱ｬ譏取枚jp, str隱ｬ譏取枚jp);
+ }
+ public virtual void t蛻晄悄蛹(string str鬆逶ｮ蜷, E繝代ロ繝ｫ遞ｮ蛻･ e繝代ロ繝ｫ遞ｮ蛻･, string str隱ｬ譏取枚jp, string str隱ｬ譏取枚en) {
+ this.str鬆逶ｮ蜷 = str鬆逶ｮ蜷;
+ this.e繝代ロ繝ｫ遞ｮ蛻･ = e繝代ロ繝ｫ遞ｮ蛻･;
+ this.str隱ｬ譏取枚 = (CultureInfo.CurrentUICulture.TwoLetterISOLanguageName == "ja") ? str隱ｬ譏取枚jp : str隱ｬ譏取枚en;
+ }
+ public virtual object obj迴ｾ蝨ｨ蛟､()
+ {
+ return null;
+ }
+ public virtual int GetIndex()
+ {
+ return 0;
+ }
+ public virtual void SetIndex( int index )
+ {
+ }
+ }
+}
diff --git a/TJAPlayer3/Items/CItemInteger.cs b/TJAPlayer3/Items/CItemInteger.cs
new file mode 100644
index 00000000..d86f7832
--- /dev/null
+++ b/TJAPlayer3/Items/CItemInteger.cs
@@ -0,0 +1,125 @@
+ｻｿusing System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace TJAPlayer3
+{
+ ///
+ /// 縲梧紛謨ｰ縲阪ｒ陦ｨ縺吶い繧､繝繝縲
+ ///
+ internal class CItemInteger : CItemBase
+ {
+ // 繝励Ο繝代ユ繧｣
+
+ public int n迴ｾ蝨ｨ縺ｮ蛟､;
+ public bool b蛟､縺後ヵ繧ｩ繝ｼ繧ｫ繧ｹ縺輔ｌ縺ｦ縺繧;
+
+
+ // 繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ
+
+ public CItemInteger()
+ {
+ base.e遞ｮ蛻･ = CItemBase.E遞ｮ蛻･.謨ｴ謨ｰ;
+ this.n譛蟆丞､ = 0;
+ this.n譛螟ｧ蛟､ = 0;
+ this.n迴ｾ蝨ｨ縺ｮ蛟､ = 0;
+ this.b蛟､縺後ヵ繧ｩ繝ｼ繧ｫ繧ｹ縺輔ｌ縺ｦ縺繧 = false;
+ }
+ public CItemInteger( string str鬆逶ｮ蜷, int n譛蟆丞､, int n譛螟ｧ蛟､, int n蛻晄悄蛟､ )
+ : this()
+ {
+ this.t蛻晄悄蛹( str鬆逶ｮ蜷, n譛蟆丞､, n譛螟ｧ蛟､, n蛻晄悄蛟､ );
+ }
+ public CItemInteger(string str鬆逶ｮ蜷, int n譛蟆丞､, int n譛螟ｧ蛟､, int n蛻晄悄蛟､, string str隱ｬ譏取枚jp)
+ : this() {
+ this.t蛻晄悄蛹(str鬆逶ｮ蜷, n譛蟆丞､, n譛螟ｧ蛟､, n蛻晄悄蛟､, str隱ｬ譏取枚jp);
+ }
+ public CItemInteger(string str鬆逶ｮ蜷, int n譛蟆丞､, int n譛螟ｧ蛟､, int n蛻晄悄蛟､, string str隱ｬ譏取枚jp, string str隱ｬ譏取枚en)
+ : this() {
+ this.t蛻晄悄蛹(str鬆逶ｮ蜷, n譛蟆丞､, n譛螟ｧ蛟､, n蛻晄悄蛟､, str隱ｬ譏取枚jp, str隱ｬ譏取枚en);
+ }
+
+
+ public CItemInteger( string str鬆逶ｮ蜷, int n譛蟆丞､, int n譛螟ｧ蛟､, int n蛻晄悄蛟､, CItemBase.E繝代ロ繝ｫ遞ｮ蛻･ e繝代ロ繝ｫ遞ｮ蛻･ )
+ : this()
+ {
+ this.t蛻晄悄蛹( str鬆逶ｮ蜷, n譛蟆丞､, n譛螟ｧ蛟､, n蛻晄悄蛟､, e繝代ロ繝ｫ遞ｮ蛻･ );
+ }
+ public CItemInteger(string str鬆逶ｮ蜷, int n譛蟆丞､, int n譛螟ｧ蛟､, int n蛻晄悄蛟､, CItemBase.E繝代ロ繝ｫ遞ｮ蛻･ e繝代ロ繝ｫ遞ｮ蛻･, string str隱ｬ譏取枚jp)
+ : this() {
+ this.t蛻晄悄蛹(str鬆逶ｮ蜷, n譛蟆丞､, n譛螟ｧ蛟､, n蛻晄悄蛟､, e繝代ロ繝ｫ遞ｮ蛻･, str隱ｬ譏取枚jp);
+ }
+ public CItemInteger(string str鬆逶ｮ蜷, int n譛蟆丞､, int n譛螟ｧ蛟､, int n蛻晄悄蛟､, CItemBase.E繝代ロ繝ｫ遞ｮ蛻･ e繝代ロ繝ｫ遞ｮ蛻･, string str隱ｬ譏取枚jp, string str隱ｬ譏取枚en)
+ : this() {
+ this.t蛻晄悄蛹(str鬆逶ｮ蜷, n譛蟆丞､, n譛螟ｧ蛟､, n蛻晄悄蛟､, e繝代ロ繝ｫ遞ｮ蛻･, str隱ｬ譏取枚jp, str隱ｬ譏取枚en);
+ }
+
+
+ // CItemBase 螳溯｣
+
+ public override void tEnter謚ｼ荳()
+ {
+ this.b蛟､縺後ヵ繧ｩ繝ｼ繧ｫ繧ｹ縺輔ｌ縺ｦ縺繧 = !this.b蛟､縺後ヵ繧ｩ繝ｼ繧ｫ繧ｹ縺輔ｌ縺ｦ縺繧;
+ }
+ public override void t鬆逶ｮ蛟､繧呈ｬ｡縺ｸ遘ｻ蜍()
+ {
+ if( ++this.n迴ｾ蝨ｨ縺ｮ蛟､ > this.n譛螟ｧ蛟､ )
+ {
+ this.n迴ｾ蝨ｨ縺ｮ蛟､ = this.n譛螟ｧ蛟､;
+ }
+ }
+ public override void t鬆逶ｮ蛟､繧貞燕縺ｸ遘ｻ蜍()
+ {
+ if( --this.n迴ｾ蝨ｨ縺ｮ蛟､ < this.n譛蟆丞､ )
+ {
+ this.n迴ｾ蝨ｨ縺ｮ蛟､ = this.n譛蟆丞､;
+ }
+ }
+ public void t蛻晄悄蛹( string str鬆逶ｮ蜷, int n譛蟆丞､, int n譛螟ｧ蛟､, int n蛻晄悄蛟､ )
+ {
+ this.t蛻晄悄蛹( str鬆逶ｮ蜷, n譛蟆丞､, n譛螟ｧ蛟､, n蛻晄悄蛟､, CItemBase.E繝代ロ繝ｫ遞ｮ蛻･.騾壼ｸｸ, "", "" );
+ }
+ public void t蛻晄悄蛹(string str鬆逶ｮ蜷, int n譛蟆丞､, int n譛螟ｧ蛟､, int n蛻晄悄蛟､, string str隱ｬ譏取枚jp) {
+ this.t蛻晄悄蛹(str鬆逶ｮ蜷, n譛蟆丞､, n譛螟ｧ蛟､, n蛻晄悄蛟､, CItemBase.E繝代ロ繝ｫ遞ｮ蛻･.騾壼ｸｸ, str隱ｬ譏取枚jp, str隱ｬ譏取枚jp);
+ }
+ public void t蛻晄悄蛹(string str鬆逶ｮ蜷, int n譛蟆丞､, int n譛螟ｧ蛟､, int n蛻晄悄蛟､, string str隱ｬ譏取枚jp, string str隱ｬ譏取枚en) {
+ this.t蛻晄悄蛹(str鬆逶ｮ蜷, n譛蟆丞､, n譛螟ｧ蛟､, n蛻晄悄蛟､, CItemBase.E繝代ロ繝ｫ遞ｮ蛻･.騾壼ｸｸ, str隱ｬ譏取枚jp, str隱ｬ譏取枚en);
+ }
+
+
+ public void t蛻晄悄蛹( string str鬆逶ｮ蜷, int n譛蟆丞､, int n譛螟ｧ蛟､, int n蛻晄悄蛟､, CItemBase.E繝代ロ繝ｫ遞ｮ蛻･ e繝代ロ繝ｫ遞ｮ蛻･ )
+ {
+ this.t蛻晄悄蛹( str鬆逶ｮ蜷, n譛蟆丞､, n譛螟ｧ蛟､, n蛻晄悄蛟､, e繝代ロ繝ｫ遞ｮ蛻･, "", "" );
+ }
+ public void t蛻晄悄蛹(string str鬆逶ｮ蜷, int n譛蟆丞､, int n譛螟ｧ蛟､, int n蛻晄悄蛟､, CItemBase.E繝代ロ繝ｫ遞ｮ蛻･ e繝代ロ繝ｫ遞ｮ蛻･, string str隱ｬ譏取枚jp) {
+ this.t蛻晄悄蛹(str鬆逶ｮ蜷, n譛蟆丞､, n譛螟ｧ蛟､, n蛻晄悄蛟､, e繝代ロ繝ｫ遞ｮ蛻･, str隱ｬ譏取枚jp, str隱ｬ譏取枚jp);
+ }
+ public void t蛻晄悄蛹(string str鬆逶ｮ蜷, int n譛蟆丞､, int n譛螟ｧ蛟､, int n蛻晄悄蛟､, CItemBase.E繝代ロ繝ｫ遞ｮ蛻･ e繝代ロ繝ｫ遞ｮ蛻･, string str隱ｬ譏取枚jp, string str隱ｬ譏取枚en) {
+ base.t蛻晄悄蛹(str鬆逶ｮ蜷, e繝代ロ繝ｫ遞ｮ蛻･, str隱ｬ譏取枚jp, str隱ｬ譏取枚en);
+ this.n譛蟆丞､ = n譛蟆丞､;
+ this.n譛螟ｧ蛟､ = n譛螟ｧ蛟､;
+ this.n迴ｾ蝨ｨ縺ｮ蛟､ = n蛻晄悄蛟､;
+ this.b蛟､縺後ヵ繧ｩ繝ｼ繧ｫ繧ｹ縺輔ｌ縺ｦ縺繧 = false;
+ }
+ public override object obj迴ｾ蝨ｨ蛟､()
+ {
+ return this.n迴ｾ蝨ｨ縺ｮ蛟､;
+ }
+ public override int GetIndex()
+ {
+ return this.n迴ｾ蝨ｨ縺ｮ蛟､;
+ }
+ public override void SetIndex( int index )
+ {
+ this.n迴ｾ蝨ｨ縺ｮ蛟､ = index;
+ }
+ // 縺昴ｮ莉
+
+ #region [ private ]
+ //-----------------
+ private int n譛蟆丞､;
+ private int n譛螟ｧ蛟､;
+ //-----------------
+ #endregion
+ }
+}
diff --git a/TJAPlayer3/Items/CItemList.cs b/TJAPlayer3/Items/CItemList.cs
new file mode 100644
index 00000000..4035bdb1
--- /dev/null
+++ b/TJAPlayer3/Items/CItemList.cs
@@ -0,0 +1,153 @@
+ｻｿusing System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace TJAPlayer3
+{
+ ///
+ /// 縲後Μ繧ｹ繝医搾ｼ郁､謨ｰ縺ｮ蝗ｺ螳壼､縺九ｉ縺ｮｼ代▽繧帝∈謚槫庄閭ｽｼ峨ｒ陦ｨ縺吶い繧､繝繝縲
+ ///
+ internal class CItemList : CItemBase
+ {
+ // 繝励Ο繝代ユ繧｣
+
+ public List list鬆逶ｮ蛟､;
+ public int n迴ｾ蝨ｨ驕ｸ謚槭＆繧後※縺繧矩逶ｮ逡ｪ蜿ｷ;
+
+
+ // 繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ
+
+ public CItemList()
+ {
+ base.e遞ｮ蛻･ = CItemBase.E遞ｮ蛻･.繝ｪ繧ｹ繝;
+ this.n迴ｾ蝨ｨ驕ｸ謚槭＆繧後※縺繧矩逶ｮ逡ｪ蜿ｷ = 0;
+ this.list鬆逶ｮ蛟､ = new List();
+ }
+ public CItemList( string str鬆逶ｮ蜷 )
+ : this()
+ {
+ this.t蛻晄悄蛹( str鬆逶ｮ蜷 );
+ }
+ public CItemList( string str鬆逶ｮ蜷, CItemBase.E繝代ロ繝ｫ遞ｮ蛻･ e繝代ロ繝ｫ遞ｮ蛻･ )
+ : this()
+ {
+ this.t蛻晄悄蛹( str鬆逶ｮ蜷, e繝代ロ繝ｫ遞ｮ蛻･ );
+ }
+ public CItemList( string str鬆逶ｮ蜷, CItemBase.E繝代ロ繝ｫ遞ｮ蛻･ e繝代ロ繝ｫ遞ｮ蛻･, int n蛻晄悄繧､繝ｳ繝繝繧ｯ繧ｹ蛟､, params string[] arg鬆逶ｮ繝ｪ繧ｹ繝 )
+ : this()
+ {
+ this.t蛻晄悄蛹( str鬆逶ｮ蜷, e繝代ロ繝ｫ遞ｮ蛻･, n蛻晄悄繧､繝ｳ繝繝繧ｯ繧ｹ蛟､, arg鬆逶ｮ繝ｪ繧ｹ繝 );
+ }
+ public CItemList(string str鬆逶ｮ蜷, CItemBase.E繝代ロ繝ｫ遞ｮ蛻･ e繝代ロ繝ｫ遞ｮ蛻･, int n蛻晄悄繧､繝ｳ繝繝繧ｯ繧ｹ蛟､, string str隱ｬ譏取枚jp, params string[] arg鬆逶ｮ繝ｪ繧ｹ繝)
+ : this() {
+ this.t蛻晄悄蛹(str鬆逶ｮ蜷, e繝代ロ繝ｫ遞ｮ蛻･, n蛻晄悄繧､繝ｳ繝繝繧ｯ繧ｹ蛟､, str隱ｬ譏取枚jp, arg鬆逶ｮ繝ｪ繧ｹ繝);
+ }
+ public CItemList(string str鬆逶ｮ蜷, CItemBase.E繝代ロ繝ｫ遞ｮ蛻･ e繝代ロ繝ｫ遞ｮ蛻･, int n蛻晄悄繧､繝ｳ繝繝繧ｯ繧ｹ蛟､, string str隱ｬ譏取枚jp, string str隱ｬ譏取枚en, params string[] arg鬆逶ｮ繝ｪ繧ｹ繝)
+ : this() {
+ this.t蛻晄悄蛹(str鬆逶ｮ蜷, e繝代ロ繝ｫ遞ｮ蛻･, n蛻晄悄繧､繝ｳ繝繝繧ｯ繧ｹ蛟､, str隱ｬ譏取枚jp, str隱ｬ譏取枚en, arg鬆逶ｮ繝ｪ繧ｹ繝);
+ }
+
+
+ // CItemBase 螳溯｣
+
+ public override void tEnter謚ｼ荳()
+ {
+ this.t鬆逶ｮ蛟､繧呈ｬ｡縺ｸ遘ｻ蜍();
+ }
+ public override void t鬆逶ｮ蛟､繧呈ｬ｡縺ｸ遘ｻ蜍()
+ {
+ if( ++this.n迴ｾ蝨ｨ驕ｸ謚槭＆繧後※縺繧矩逶ｮ逡ｪ蜿ｷ >= this.list鬆逶ｮ蛟､.Count )
+ {
+ this.n迴ｾ蝨ｨ驕ｸ謚槭＆繧後※縺繧矩逶ｮ逡ｪ蜿ｷ = 0;
+ }
+ }
+ public override void t鬆逶ｮ蛟､繧貞燕縺ｸ遘ｻ蜍()
+ {
+ if( --this.n迴ｾ蝨ｨ驕ｸ謚槭＆繧後※縺繧矩逶ｮ逡ｪ蜿ｷ < 0 )
+ {
+ this.n迴ｾ蝨ｨ驕ｸ謚槭＆繧後※縺繧矩逶ｮ逡ｪ蜿ｷ = this.list鬆逶ｮ蛟､.Count - 1;
+ }
+ }
+ public override void t蛻晄悄蛹( string str鬆逶ｮ蜷, CItemBase.E繝代ロ繝ｫ遞ｮ蛻･ e繝代ロ繝ｫ遞ｮ蛻･ )
+ {
+ base.t蛻晄悄蛹( str鬆逶ｮ蜷, e繝代ロ繝ｫ遞ｮ蛻･ );
+ this.n迴ｾ蝨ｨ驕ｸ謚槭＆繧後※縺繧矩逶ｮ逡ｪ蜿ｷ = 0;
+ this.list鬆逶ｮ蛟､.Clear();
+ }
+ public void t蛻晄悄蛹( string str鬆逶ｮ蜷, CItemBase.E繝代ロ繝ｫ遞ｮ蛻･ e繝代ロ繝ｫ遞ｮ蛻･, int n蛻晄悄繧､繝ｳ繝繝繧ｯ繧ｹ蛟､, params string[] arg鬆逶ｮ繝ｪ繧ｹ繝 )
+ {
+ this.t蛻晄悄蛹(str鬆逶ｮ蜷, e繝代ロ繝ｫ遞ｮ蛻･, n蛻晄悄繧､繝ｳ繝繝繧ｯ繧ｹ蛟､, "", "",arg鬆逶ｮ繝ｪ繧ｹ繝);
+ }
+ public void t蛻晄悄蛹(string str鬆逶ｮ蜷, CItemBase.E繝代ロ繝ｫ遞ｮ蛻･ e繝代ロ繝ｫ遞ｮ蛻･, int n蛻晄悄繧､繝ｳ繝繝繧ｯ繧ｹ蛟､, string str隱ｬ譏取枚jp, params string[] arg鬆逶ｮ繝ｪ繧ｹ繝) {
+ this.t蛻晄悄蛹(str鬆逶ｮ蜷, e繝代ロ繝ｫ遞ｮ蛻･, n蛻晄悄繧､繝ｳ繝繝繧ｯ繧ｹ蛟､, str隱ｬ譏取枚jp, str隱ｬ譏取枚jp, arg鬆逶ｮ繝ｪ繧ｹ繝);
+ }
+ public void t蛻晄悄蛹(string str鬆逶ｮ蜷, CItemBase.E繝代ロ繝ｫ遞ｮ蛻･ e繝代ロ繝ｫ遞ｮ蛻･, int n蛻晄悄繧､繝ｳ繝繝繧ｯ繧ｹ蛟､, string str隱ｬ譏取枚jp, string str隱ｬ譏取枚en, params string[] arg鬆逶ｮ繝ｪ繧ｹ繝) {
+ base.t蛻晄悄蛹(str鬆逶ｮ蜷, e繝代ロ繝ｫ遞ｮ蛻･, str隱ｬ譏取枚jp, str隱ｬ譏取枚en);
+ this.n迴ｾ蝨ｨ驕ｸ謚槭＆繧後※縺繧矩逶ｮ逡ｪ蜿ｷ = n蛻晄悄繧､繝ｳ繝繝繧ｯ繧ｹ蛟､;
+ foreach (string str in arg鬆逶ｮ繝ｪ繧ｹ繝) {
+ this.list鬆逶ｮ蛟､.Add(str);
+ }
+ }
+ public override object obj迴ｾ蝨ｨ蛟､()
+ {
+ return this.list鬆逶ｮ蛟､[ n迴ｾ蝨ｨ驕ｸ謚槭＆繧後※縺繧矩逶ｮ逡ｪ蜿ｷ ];
+ }
+ public override int GetIndex()
+ {
+ return n迴ｾ蝨ｨ驕ｸ謚槭＆繧後※縺繧矩逶ｮ逡ｪ蜿ｷ;
+ }
+ public override void SetIndex( int index )
+ {
+ n迴ｾ蝨ｨ驕ｸ謚槭＆繧後※縺繧矩逶ｮ逡ｪ蜿ｷ = index;
+ }
+ }
+
+
+
+
+ ///
+ /// 邁｡譏薙さ繝ｳ繝輔ぅ繧ｰ縺ｮ縲悟繧頑崛縺医阪↓菴ｿ逕ｨ縺吶ｋ縲√後Μ繧ｹ繝医搾ｼ郁､謨ｰ縺ｮ蝗ｺ螳壼､縺九ｉ縺ｮｼ代▽繧帝∈謚槫庄閭ｽｼ峨ｒ陦ｨ縺吶い繧､繝繝縲
+ /// e遞ｮ蛻･縺碁＆縺縺ｮ縺ｨ縲》Enter謚ｼ荳()縺ｧ菴輔ｂ縺励↑縺莉･螟悶ｯ縲√後Μ繧ｹ繝医阪◎縺ｮ縺ｾ縺ｾ縲
+ ///
+ internal class CSwitchItemList : CItemList
+ {
+ // 繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ
+
+ public CSwitchItemList()
+ {
+ base.e遞ｮ蛻･ = CItemBase.E遞ｮ蛻･.蛻譖ｿ繝ｪ繧ｹ繝;
+ this.n迴ｾ蝨ｨ驕ｸ謚槭＆繧後※縺繧矩逶ｮ逡ｪ蜿ｷ = 0;
+ this.list鬆逶ｮ蛟､ = new List();
+ }
+ public CSwitchItemList( string str鬆逶ｮ蜷 )
+ : this()
+ {
+ this.t蛻晄悄蛹( str鬆逶ｮ蜷 );
+ }
+ public CSwitchItemList( string str鬆逶ｮ蜷, CItemBase.E繝代ロ繝ｫ遞ｮ蛻･ e繝代ロ繝ｫ遞ｮ蛻･ )
+ : this()
+ {
+ this.t蛻晄悄蛹( str鬆逶ｮ蜷, e繝代ロ繝ｫ遞ｮ蛻･ );
+ }
+ public CSwitchItemList( string str鬆逶ｮ蜷, CItemBase.E繝代ロ繝ｫ遞ｮ蛻･ e繝代ロ繝ｫ遞ｮ蛻･, int n蛻晄悄繧､繝ｳ繝繝繧ｯ繧ｹ蛟､, params string[] arg鬆逶ｮ繝ｪ繧ｹ繝 )
+ : this()
+ {
+ this.t蛻晄悄蛹( str鬆逶ｮ蜷, e繝代ロ繝ｫ遞ｮ蛻･, n蛻晄悄繧､繝ｳ繝繝繧ｯ繧ｹ蛟､, arg鬆逶ｮ繝ｪ繧ｹ繝 );
+ }
+ public CSwitchItemList(string str鬆逶ｮ蜷, CItemBase.E繝代ロ繝ｫ遞ｮ蛻･ e繝代ロ繝ｫ遞ｮ蛻･, int n蛻晄悄繧､繝ｳ繝繝繧ｯ繧ｹ蛟､, string str隱ｬ譏取枚jp, params string[] arg鬆逶ｮ繝ｪ繧ｹ繝)
+ : this() {
+ this.t蛻晄悄蛹(str鬆逶ｮ蜷, e繝代ロ繝ｫ遞ｮ蛻･, n蛻晄悄繧､繝ｳ繝繝繧ｯ繧ｹ蛟､, str隱ｬ譏取枚jp, arg鬆逶ｮ繝ｪ繧ｹ繝);
+ }
+ public CSwitchItemList( string str鬆逶ｮ蜷, CItemBase.E繝代ロ繝ｫ遞ｮ蛻･ e繝代ロ繝ｫ遞ｮ蛻･, int n蛻晄悄繧､繝ｳ繝繝繧ｯ繧ｹ蛟､, string str隱ｬ譏取枚jp, string str隱ｬ譏取枚en, params string[] arg鬆逶ｮ繝ｪ繧ｹ繝 )
+ : this()
+ {
+ this.t蛻晄悄蛹( str鬆逶ｮ蜷, e繝代ロ繝ｫ遞ｮ蛻･, n蛻晄悄繧､繝ｳ繝繝繧ｯ繧ｹ蛟､, str隱ｬ譏取枚jp, str隱ｬ譏取枚en, arg鬆逶ｮ繝ｪ繧ｹ繝 );
+ }
+
+ public override void tEnter謚ｼ荳()
+ {
+ // this.t鬆逶ｮ蛟､繧呈ｬ｡縺ｸ遘ｻ蜍(); // 菴輔ｂ縺励↑縺
+ }
+ }
+
+}
diff --git a/TJAPlayer3/Items/CItemThreeState.cs b/TJAPlayer3/Items/CItemThreeState.cs
new file mode 100644
index 00000000..bc6f5622
--- /dev/null
+++ b/TJAPlayer3/Items/CItemThreeState.cs
@@ -0,0 +1,154 @@
+ｻｿusing System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace TJAPlayer3
+{
+ ///
+ /// 縲後せ繝ｪ繝ｼ繧ｹ繝繝ｼ繝医搾ｼON, OFF, 荳榊ｮ 縺ｮ3迥ｶ諷具ｼ峨ｒ陦ｨ縺吶い繧､繝繝縲
+ ///
+ internal class CItemThreeState : CItemBase
+ {
+ // 繝励Ο繝代ユ繧｣
+
+ public E迥ｶ諷 e迴ｾ蝨ｨ縺ｮ迥ｶ諷;
+ public enum E迥ｶ諷
+ {
+ ON,
+ OFF,
+ 荳榊ｮ
+ }
+
+
+ // 繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ
+
+ public CItemThreeState()
+ {
+ base.e遞ｮ蛻･ = CItemBase.E遞ｮ蛻･.ONorOFFor荳榊ｮ壹せ繝ｪ繝ｼ繧ｹ繝繝ｼ繝;
+ this.e迴ｾ蝨ｨ縺ｮ迥ｶ諷 = E迥ｶ諷.荳榊ｮ;
+ }
+ public CItemThreeState( string str鬆逶ｮ蜷, E迥ｶ諷 e蛻晄悄迥ｶ諷 )
+ : this()
+ {
+ this.t蛻晄悄蛹( str鬆逶ｮ蜷, e蛻晄悄迥ｶ諷 );
+ }
+ public CItemThreeState(string str鬆逶ｮ蜷, E迥ｶ諷 e蛻晄悄迥ｶ諷, string str隱ｬ譏取枚jp)
+ : this() {
+ this.t蛻晄悄蛹(str鬆逶ｮ蜷, e蛻晄悄迥ｶ諷, str隱ｬ譏取枚jp, str隱ｬ譏取枚jp);
+ }
+ public CItemThreeState(string str鬆逶ｮ蜷, E迥ｶ諷 e蛻晄悄迥ｶ諷, string str隱ｬ譏取枚jp, string str隱ｬ譏取枚en)
+ : this() {
+ this.t蛻晄悄蛹(str鬆逶ｮ蜷, e蛻晄悄迥ｶ諷, str隱ｬ譏取枚jp, str隱ｬ譏取枚en);
+ }
+
+ public CItemThreeState( string str鬆逶ｮ蜷, E迥ｶ諷 e蛻晄悄迥ｶ諷, CItemBase.E繝代ロ繝ｫ遞ｮ蛻･ e繝代ロ繝ｫ遞ｮ蛻･ )
+ : this()
+ {
+ this.t蛻晄悄蛹( str鬆逶ｮ蜷, e蛻晄悄迥ｶ諷, e繝代ロ繝ｫ遞ｮ蛻･ );
+ }
+ public CItemThreeState(string str鬆逶ｮ蜷, E迥ｶ諷 e蛻晄悄迥ｶ諷, CItemBase.E繝代ロ繝ｫ遞ｮ蛻･ e繝代ロ繝ｫ遞ｮ蛻･, string str隱ｬ譏取枚jp)
+ : this() {
+ this.t蛻晄悄蛹(str鬆逶ｮ蜷, e蛻晄悄迥ｶ諷, e繝代ロ繝ｫ遞ｮ蛻･, str隱ｬ譏取枚jp, str隱ｬ譏取枚jp);
+ }
+ public CItemThreeState(string str鬆逶ｮ蜷, E迥ｶ諷 e蛻晄悄迥ｶ諷, CItemBase.E繝代ロ繝ｫ遞ｮ蛻･ e繝代ロ繝ｫ遞ｮ蛻･, string str隱ｬ譏取枚jp, string str隱ｬ譏取枚en)
+ : this() {
+ this.t蛻晄悄蛹(str鬆逶ｮ蜷, e蛻晄悄迥ｶ諷, e繝代ロ繝ｫ遞ｮ蛻･, str隱ｬ譏取枚jp, str隱ｬ譏取枚en);
+ }
+
+
+ // CItemBase 螳溯｣
+
+ public override void tEnter謚ｼ荳()
+ {
+ this.t鬆逶ｮ蛟､繧呈ｬ｡縺ｸ遘ｻ蜍();
+ }
+ public override void t鬆逶ｮ蛟､繧呈ｬ｡縺ｸ遘ｻ蜍()
+ {
+ switch( this.e迴ｾ蝨ｨ縺ｮ迥ｶ諷 )
+ {
+ case E迥ｶ諷.ON:
+ this.e迴ｾ蝨ｨ縺ｮ迥ｶ諷 = E迥ｶ諷.OFF;
+ return;
+
+ case E迥ｶ諷.OFF:
+ this.e迴ｾ蝨ｨ縺ｮ迥ｶ諷 = E迥ｶ諷.ON;
+ return;
+
+ case E迥ｶ諷.荳榊ｮ:
+ this.e迴ｾ蝨ｨ縺ｮ迥ｶ諷 = E迥ｶ諷.ON;
+ return;
+ }
+ }
+ public override void t鬆逶ｮ蛟､繧貞燕縺ｸ遘ｻ蜍()
+ {
+ switch( this.e迴ｾ蝨ｨ縺ｮ迥ｶ諷 )
+ {
+ case E迥ｶ諷.ON:
+ this.e迴ｾ蝨ｨ縺ｮ迥ｶ諷 = E迥ｶ諷.OFF;
+ return;
+
+ case E迥ｶ諷.OFF:
+ this.e迴ｾ蝨ｨ縺ｮ迥ｶ諷 = E迥ｶ諷.ON;
+ return;
+
+ case E迥ｶ諷.荳榊ｮ:
+ this.e迴ｾ蝨ｨ縺ｮ迥ｶ諷 = E迥ｶ諷.OFF;
+ return;
+ }
+ }
+ public void t蛻晄悄蛹( string str鬆逶ｮ蜷, E迥ｶ諷 e蛻晄悄迥ｶ諷 )
+ {
+ this.t蛻晄悄蛹( str鬆逶ｮ蜷, e蛻晄悄迥ｶ諷, CItemBase.E繝代ロ繝ｫ遞ｮ蛻･.騾壼ｸｸ );
+ }
+ public void t蛻晄悄蛹(string str鬆逶ｮ蜷, E迥ｶ諷 e蛻晄悄迥ｶ諷, string str隱ｬ譏取枚jp) {
+ this.t蛻晄悄蛹(str鬆逶ｮ蜷, e蛻晄悄迥ｶ諷, CItemBase.E繝代ロ繝ｫ遞ｮ蛻･.騾壼ｸｸ, str隱ｬ譏取枚jp, str隱ｬ譏取枚jp);
+ }
+ public void t蛻晄悄蛹(string str鬆逶ｮ蜷, E迥ｶ諷 e蛻晄悄迥ｶ諷, string str隱ｬ譏取枚jp, string str隱ｬ譏取枚en) {
+ this.t蛻晄悄蛹(str鬆逶ｮ蜷, e蛻晄悄迥ｶ諷, CItemBase.E繝代ロ繝ｫ遞ｮ蛻･.騾壼ｸｸ, str隱ｬ譏取枚jp, str隱ｬ譏取枚en);
+ }
+
+ public void t蛻晄悄蛹( string str鬆逶ｮ蜷, E迥ｶ諷 e蛻晄悄迥ｶ諷, CItemBase.E繝代ロ繝ｫ遞ｮ蛻･ e繝代ロ繝ｫ遞ｮ蛻･ )
+ {
+ this.t蛻晄悄蛹(str鬆逶ｮ蜷, e蛻晄悄迥ｶ諷, CItemBase.E繝代ロ繝ｫ遞ｮ蛻･.騾壼ｸｸ, "", "");
+ }
+ public void t蛻晄悄蛹(string str鬆逶ｮ蜷, E迥ｶ諷 e蛻晄悄迥ｶ諷, CItemBase.E繝代ロ繝ｫ遞ｮ蛻･ e繝代ロ繝ｫ遞ｮ蛻･, string str隱ｬ譏取枚jp) {
+ this.t蛻晄悄蛹(str鬆逶ｮ蜷, e蛻晄悄迥ｶ諷, CItemBase.E繝代ロ繝ｫ遞ｮ蛻･.騾壼ｸｸ, str隱ｬ譏取枚jp, str隱ｬ譏取枚jp);
+ }
+ public void t蛻晄悄蛹(string str鬆逶ｮ蜷, E迥ｶ諷 e蛻晄悄迥ｶ諷, CItemBase.E繝代ロ繝ｫ遞ｮ蛻･ e繝代ロ繝ｫ遞ｮ蛻･, string str隱ｬ譏取枚jp, string str隱ｬ譏取枚en) {
+ base.t蛻晄悄蛹(str鬆逶ｮ蜷, e繝代ロ繝ｫ遞ｮ蛻･, str隱ｬ譏取枚jp, str隱ｬ譏取枚en);
+ this.e迴ｾ蝨ｨ縺ｮ迥ｶ諷 = e蛻晄悄迥ｶ諷;
+ }
+ public override object obj迴ｾ蝨ｨ蛟､()
+ {
+ if ( this.e迴ｾ蝨ｨ縺ｮ迥ｶ諷 == E迥ｶ諷.荳榊ｮ )
+ {
+ return "- -";
+ }
+ else
+ {
+ return this.e迴ｾ蝨ｨ縺ｮ迥ｶ諷.ToString();
+ }
+ }
+ public override int GetIndex()
+ {
+ return (int)this.e迴ｾ蝨ｨ縺ｮ迥ｶ諷;
+ }
+ public override void SetIndex( int index )
+ {
+ switch (index )
+ {
+ case 0:
+ this.e迴ｾ蝨ｨ縺ｮ迥ｶ諷 = E迥ｶ諷.ON;
+ break;
+ case 1:
+ this.e迴ｾ蝨ｨ縺ｮ迥ｶ諷 = E迥ｶ諷.OFF;
+ break;
+ case 2:
+ this.e迴ｾ蝨ｨ縺ｮ迥ｶ諷 = E迥ｶ諷.荳榊ｮ;
+ break;
+ default:
+ throw new ArgumentOutOfRangeException();
+ }
+ }
+ }
+}
diff --git a/TJAPlayer3/Items/CItemToggle.cs b/TJAPlayer3/Items/CItemToggle.cs
new file mode 100644
index 00000000..495dd1fe
--- /dev/null
+++ b/TJAPlayer3/Items/CItemToggle.cs
@@ -0,0 +1,111 @@
+ｻｿusing System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace TJAPlayer3
+{
+ ///
+ /// 縲後ヨ繧ｰ繝ｫ縲搾ｼON, OFF 縺ｮ2迥ｶ諷具ｼ峨ｒ陦ｨ縺吶い繧､繝繝縲
+ ///
+ internal class CItemToggle : CItemBase
+ {
+ // 繝励Ο繝代ユ繧｣
+
+ public bool bON;
+
+
+ // 繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ
+
+ public CItemToggle()
+ {
+ base.e遞ｮ蛻･ = CItemBase.E遞ｮ蛻･.ONorOFF繝医げ繝ｫ;
+ this.bON = false;
+ }
+ public CItemToggle( string str鬆逶ｮ蜷, bool b蛻晄悄迥ｶ諷 )
+ : this()
+ {
+ this.t蛻晄悄蛹( str鬆逶ｮ蜷, b蛻晄悄迥ｶ諷 );
+ }
+ public CItemToggle(string str鬆逶ｮ蜷, bool b蛻晄悄迥ｶ諷, string str隱ｬ譏取枚jp)
+ : this() {
+ this.t蛻晄悄蛹(str鬆逶ｮ蜷, b蛻晄悄迥ｶ諷, str隱ｬ譏取枚jp);
+ }
+ public CItemToggle(string str鬆逶ｮ蜷, bool b蛻晄悄迥ｶ諷, string str隱ｬ譏取枚jp, string str隱ｬ譏取枚en)
+ : this() {
+ this.t蛻晄悄蛹(str鬆逶ｮ蜷, b蛻晄悄迥ｶ諷, str隱ｬ譏取枚jp, str隱ｬ譏取枚en);
+ }
+ public CItemToggle(string str鬆逶ｮ蜷, bool b蛻晄悄迥ｶ諷, CItemBase.E繝代ロ繝ｫ遞ｮ蛻･ e繝代ロ繝ｫ遞ｮ蛻･)
+ : this()
+ {
+ this.t蛻晄悄蛹( str鬆逶ｮ蜷, b蛻晄悄迥ｶ諷, e繝代ロ繝ｫ遞ｮ蛻･ );
+ }
+ public CItemToggle(string str鬆逶ｮ蜷, bool b蛻晄悄迥ｶ諷, CItemBase.E繝代ロ繝ｫ遞ｮ蛻･ e繝代ロ繝ｫ遞ｮ蛻･, string str隱ｬ譏取枚jp)
+ : this() {
+ this.t蛻晄悄蛹(str鬆逶ｮ蜷, b蛻晄悄迥ｶ諷, e繝代ロ繝ｫ遞ｮ蛻･, str隱ｬ譏取枚jp);
+ }
+ public CItemToggle(string str鬆逶ｮ蜷, bool b蛻晄悄迥ｶ諷, CItemBase.E繝代ロ繝ｫ遞ｮ蛻･ e繝代ロ繝ｫ遞ｮ蛻･, string str隱ｬ譏取枚jp, string str隱ｬ譏取枚en)
+ : this() {
+ this.t蛻晄悄蛹(str鬆逶ｮ蜷, b蛻晄悄迥ｶ諷, e繝代ロ繝ｫ遞ｮ蛻･, str隱ｬ譏取枚jp, str隱ｬ譏取枚en);
+ }
+
+
+ // CItemBase 螳溯｣
+
+ public override void tEnter謚ｼ荳()
+ {
+ this.t鬆逶ｮ蛟､繧呈ｬ｡縺ｸ遘ｻ蜍();
+ }
+ public override void t鬆逶ｮ蛟､繧呈ｬ｡縺ｸ遘ｻ蜍()
+ {
+ this.bON = !this.bON;
+ }
+ public override void t鬆逶ｮ蛟､繧貞燕縺ｸ遘ｻ蜍()
+ {
+ this.t鬆逶ｮ蛟､繧呈ｬ｡縺ｸ遘ｻ蜍();
+ }
+ public void t蛻晄悄蛹( string str鬆逶ｮ蜷, bool b蛻晄悄迥ｶ諷 )
+ {
+ this.t蛻晄悄蛹( str鬆逶ｮ蜷, b蛻晄悄迥ｶ諷, CItemBase.E繝代ロ繝ｫ遞ｮ蛻･.騾壼ｸｸ );
+ }
+ public void t蛻晄悄蛹(string str鬆逶ｮ蜷, bool b蛻晄悄迥ｶ諷, string str隱ｬ譏取枚jp) {
+ this.t蛻晄悄蛹(str鬆逶ｮ蜷, b蛻晄悄迥ｶ諷, CItemBase.E繝代ロ繝ｫ遞ｮ蛻･.騾壼ｸｸ, str隱ｬ譏取枚jp, str隱ｬ譏取枚jp);
+ }
+ public void t蛻晄悄蛹(string str鬆逶ｮ蜷, bool b蛻晄悄迥ｶ諷, string str隱ｬ譏取枚jp, string str隱ｬ譏取枚en) {
+ this.t蛻晄悄蛹(str鬆逶ｮ蜷, b蛻晄悄迥ｶ諷, CItemBase.E繝代ロ繝ｫ遞ｮ蛻･.騾壼ｸｸ, str隱ｬ譏取枚jp, str隱ｬ譏取枚en);
+ }
+
+ public void t蛻晄悄蛹(string str鬆逶ｮ蜷, bool b蛻晄悄迥ｶ諷, CItemBase.E繝代ロ繝ｫ遞ｮ蛻･ e繝代ロ繝ｫ遞ｮ蛻･)
+ {
+ this.t蛻晄悄蛹(str鬆逶ｮ蜷, b蛻晄悄迥ｶ諷, e繝代ロ繝ｫ遞ｮ蛻･, "", "");
+ }
+ public void t蛻晄悄蛹(string str鬆逶ｮ蜷, bool b蛻晄悄迥ｶ諷, CItemBase.E繝代ロ繝ｫ遞ｮ蛻･ e繝代ロ繝ｫ遞ｮ蛻･, string str隱ｬ譏取枚jp) {
+ this.t蛻晄悄蛹(str鬆逶ｮ蜷, b蛻晄悄迥ｶ諷, e繝代ロ繝ｫ遞ｮ蛻･, str隱ｬ譏取枚jp, str隱ｬ譏取枚jp);
+ }
+ public void t蛻晄悄蛹(string str鬆逶ｮ蜷, bool b蛻晄悄迥ｶ諷, CItemBase.E繝代ロ繝ｫ遞ｮ蛻･ e繝代ロ繝ｫ遞ｮ蛻･, string str隱ｬ譏取枚jp, string str隱ｬ譏取枚en) {
+ base.t蛻晄悄蛹(str鬆逶ｮ蜷, e繝代ロ繝ｫ遞ｮ蛻･, str隱ｬ譏取枚jp, str隱ｬ譏取枚en);
+ this.bON = b蛻晄悄迥ｶ諷;
+ }
+ public override object obj迴ｾ蝨ｨ蛟､()
+ {
+ return ( this.bON ) ? "ON" : "OFF";
+ }
+ public override int GetIndex()
+ {
+ return ( this.bON ) ? 1 : 0;
+ }
+ public override void SetIndex( int index )
+ {
+ switch ( index )
+ {
+ case 0:
+ this.bON = false;
+ break;
+ case 1:
+ this.bON = true;
+ break;
+ default:
+ throw new ArgumentOutOfRangeException();
+ }
+ }
+ }
+}
diff --git a/TJAPlayer3/Plugins/CPluginHost.cs b/TJAPlayer3/Plugins/CPluginHost.cs
new file mode 100644
index 00000000..80710234
--- /dev/null
+++ b/TJAPlayer3/Plugins/CPluginHost.cs
@@ -0,0 +1,87 @@
+ｻｿusing System;
+using System.Collections.Generic;
+using System.Text;
+using System.IO;
+using System.Drawing;
+using SlimDX;
+using SlimDX.Direct3D9;
+using FDK;
+
+namespace TJAPlayer3
+{
+ internal class CPluginHost : IPluginHost
+ {
+ // 繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ
+
+ public CPluginHost()
+ {
+ this._DTXManiaVersion = new CDTXVersion( TJAPlayer3.VERSION );
+ }
+
+
+ // IPluginHost 螳溯｣
+
+ public CDTXVersion DTXManiaVersion
+ {
+ get { return this._DTXManiaVersion; }
+ }
+ public Device D3D9Device
+ {
+ get { return (TJAPlayer3.app != null ) ? TJAPlayer3.app.Device.UnderlyingDevice : null; }
+ }
+ public Format TextureFormat
+ {
+ get { return TJAPlayer3.TextureFormat; }
+ }
+ public CTimer Timer
+ {
+ get { return TJAPlayer3.Timer; }
+ }
+ public CSound邂｡逅 Sound邂｡逅
+ {
+ get { return TJAPlayer3.Sound邂｡逅; }
+ }
+ public Size ClientSize
+ {
+ get { return TJAPlayer3.app.Window.ClientSize; }
+ }
+ public CStage.E繧ｹ繝繝ｼ繧ｸ e迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ
+ {
+ get { return ( TJAPlayer3.r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ != null ) ? TJAPlayer3.r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ.e繧ｹ繝繝ｼ繧ｸID : CStage.E繧ｹ繝繝ｼ繧ｸ.菴輔ｂ縺励↑縺; }
+ }
+ public CStage.E繝輔ぉ繝ｼ繧ｺ e迴ｾ蝨ｨ縺ｮ繝輔ぉ繝ｼ繧ｺ
+ {
+ get { return ( TJAPlayer3.r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ != null ) ? TJAPlayer3.r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ.e繝輔ぉ繝ｼ繧ｺID : CStage.E繝輔ぉ繝ｼ繧ｺ.蜈ｱ騾喟騾壼ｸｸ迥ｶ諷; }
+ }
+ public bool t蜈･蜉帙ｒ蜊譛峨☆繧(IPluginActivity act)
+ {
+ if (TJAPlayer3.act迴ｾ蝨ｨ蜈･蜉帙ｒ蜊譛我ｸｭ縺ｮ繝励Λ繧ｰ繧､繝ｳ != null)
+ return false;
+
+ TJAPlayer3.act迴ｾ蝨ｨ蜈･蜉帙ｒ蜊譛我ｸｭ縺ｮ繝励Λ繧ｰ繧､繝ｳ = act;
+ return true;
+ }
+ public bool t蜈･蜉帙ｮ蜊譛峨ｒ隗｣髯､縺吶ｋ(IPluginActivity act)
+ {
+ if (TJAPlayer3.act迴ｾ蝨ｨ蜈･蜉帙ｒ蜊譛我ｸｭ縺ｮ繝励Λ繧ｰ繧､繝ｳ == null || TJAPlayer3.act迴ｾ蝨ｨ蜈･蜉帙ｒ蜊譛我ｸｭ縺ｮ繝励Λ繧ｰ繧､繝ｳ != act)
+ return false;
+
+ TJAPlayer3.act迴ｾ蝨ｨ蜈･蜉帙ｒ蜊譛我ｸｭ縺ｮ繝励Λ繧ｰ繧､繝ｳ = null;
+ return true;
+ }
+ public void t繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝峨ｒ蜀咲函縺吶ｋ( E繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝 sound )
+ {
+ if( TJAPlayer3.Skin != null )
+ TJAPlayer3.Skin[ sound ].t蜀咲函縺吶ｋ();
+ }
+
+
+ // 縺昴ｮ莉
+
+ #region [ private ]
+ //-----------------
+ private CDTXVersion _DTXManiaVersion;
+ //-----------------
+ #endregion
+ }
+}
diff --git a/TJAPlayer3/Plugins/IPluginActivity.cs b/TJAPlayer3/Plugins/IPluginActivity.cs
new file mode 100644
index 00000000..845b3208
--- /dev/null
+++ b/TJAPlayer3/Plugins/IPluginActivity.cs
@@ -0,0 +1,76 @@
+ｻｿnamespace TJAPlayer3
+{
+ ///
+ /// Activity 繝励Λ繧ｰ繧､繝ｳ縺ｸ縺ｮ繧､繝ｳ繧ｿ繝ｼ繝輔ぉ繝ｼ繧ｹ縲
+ /// DTXMania 縺ｯ縲！PluginActivity 縺ｫ蟇ｾ縺励※縲∽ｻ･荳九ｮ繝ｩ繧､繝輔し繧､繧ｯ繝ｫ繧貞ｮ溯｡後＠縺ｾ縺吶
+ /// (1) DTXMania 縺ｮ襍ｷ蜍募ｦ逅縺ｮ譛蠕鯉ｼ医そ繝繝医い繝繝礼判髱｢縺瑚｡ｨ遉ｺ縺輔ｌ繧狗峩蜑搾ｼ峨↓荳蠎ｦ縺縺代＾n蛻晄悄蛹()_OnManaged繝ｪ繧ｽ繝ｼ繧ｹ縺ｮ菴懈()_OnUnmanaged繝ｪ繧ｽ繝ｼ繧ｹ縺ｮ菴懈() 繧偵％縺ｮ鬆逡ｪ縺ｧ1蝗槭★縺､蜻ｼ縺ｳ蜃ｺ縺励∪縺吶
+ /// (2) DTXMania 縺ｮ邨ゆｺ蜃ｦ逅縺ｮ譛蛻晢ｼThank you for playing 縺梧ｶ医∴縺溽峩蠕鯉ｼ峨↓荳蠎ｦ縺縺代＾nUnmanaged繝ｪ繧ｽ繝ｼ繧ｹ縺ｮ隗｣謾ｾ()_OnManaged繝ｪ繧ｽ繝ｼ繧ｹ縺ｮ隗｣謾ｾ()_On邨ゆｺ() 繧偵％縺ｮ鬆逡ｪ縺ｧ1蝗槭★縺､蜻ｼ縺ｳ蜃ｺ縺励∪縺吶
+ /// (3) DTXMania 縺ｮ襍ｷ蜍穂ｸｭ縲√☆縺ｪ繧上■(1)ｽ(2)縺ｮ髢薙ｯ縲√←繧薙↑繧ｷ繝ｼ繝ｳ縺ｧ縺ゅ▲縺ｦ繧ゅ∝ｸｸ縺ｫ On騾ｲ陦梧緒逕ｻ() 繧1繝輔Ξ繝ｼ繝縺ｫ縺､縺1蝗槭★縺､蜻ｼ縺ｳ蜃ｺ縺励∪縺吶
+ /// (4) Direct3D 繝繝舌う繧ｹ縺ｮ繝ｪ繧ｻ繝繝域凾縺ｫ縺ｯ縲√ョ繝舌う繧ｹ縺ｮ繝ｪ繧ｻ繝繝亥燕縺ｫ OnUnmanaged繝ｪ繧ｽ繝ｼ繧ｹ縺ｮ隗｣謾ｾ() 繧1蝗槫他縺ｳ蜃ｺ縺励√ョ繝舌う繧ｹ繧偵Μ繧ｻ繝繝医＠縺溘ｮ縺｡縲＾nUnmanaged繝ｪ繧ｽ繝ｼ繧ｹ縺ｮ菴懈() 繧1蝗槫他縺ｳ蜃ｺ縺励∪縺吶
+ /// (5) Direct3D 繝繝舌う繧ｹ縺ｮ繝ｭ繧ｹ繝域凾縺ｫ縺ｯ縲√ョ繝舌う繧ｹ縺ｮ蜀咲函謌仙燕縺ｫ OnUnmanaged繝ｪ繧ｽ繝ｼ繧ｹ縺ｮ隗｣謾ｾ()_OnManaged繝ｪ繧ｽ繝ｼ繧ｹ縺ｮ隗｣謾ｾ() 繧1蝗槭★縺､蜻ｼ縺ｳ蜃ｺ縺励√ョ繝舌う繧ｹ繧貞咲函謌舌＠縺溘ｮ縺｡縲＾nManaged繝ｪ繧ｽ繝ｼ繧ｹ縺ｮ菴懈()_OnUnmanaged繝ｪ繧ｽ繝ｼ繧ｹ縺ｮ菴懈() 繧1蝗槭★縺､蜻ｼ縺ｳ蜃ｺ縺励∪縺吶
+ ///
+ public interface IPluginActivity
+ {
+ ///
+ /// 繝励Λ繧ｰ繧､繝ｳ縺ｮ蛻晄悄蛹悶ｒ陦後＞縺ｾ縺吶
+ /// DTXMania 縺ｮ襍ｷ蜍募ｦ逅縺ｮ譛蠕鯉ｼ医そ繝繝医い繝繝礼判髱｢縺瑚｡ｨ遉ｺ縺輔ｌ繧狗峩蜑搾ｼ峨↓縲．TXMania 縺九ｉ荳蠎ｦ縺縺大他縺ｳ蜃ｺ縺輔ｌ縺ｾ縺吶
+ /// 繝励Λ繧ｰ繧､繝ｳ縺後√帙せ繝茨ｼDTXManiaｼ峨ｮ諠蝣ｱ縺ｫ繧｢繧ｯ繧ｻ繧ｹ縺吶ｋ縺溘ａ縺ｮ繧ｪ繝悶ず繧ｧ繧ｯ繝医
+ ///
+ void On蛻晄悄蛹( global::TJAPlayer3.IPluginHost PluginHost );
+
+ ///
+ /// 繝励Λ繧ｰ繧､繝ｳ縺ｮ邨ゆｺ蜃ｦ逅繧定｡後＞縺ｾ縺吶
+ /// DTXMania 縺ｮ邨ゆｺ蜃ｦ逅縺ｮ譛蛻晢ｼThank you for playing 縺梧ｶ医∴縺溽峩蠕鯉ｼ峨↓縲．TXMania 縺九ｉ荳蠎ｦ縺縺大他縺ｳ蜃ｺ縺輔ｌ縺ｾ縺吶
+ ///
+ void On邨ゆｺ();
+
+ ///
+ /// Managed 繝ｪ繧ｽ繝ｼ繧ｹ繧剃ｽ懈舌＠縺ｾ縺吶
+ ///
+ void OnManaged繝ｪ繧ｽ繝ｼ繧ｹ縺ｮ菴懈();
+
+ ///
+ /// Unmanaged 繝ｪ繧ｽ繝ｼ繧ｹ繧剃ｽ懈舌＠縺ｾ縺吶
+ ///
+ void OnUnmanaged繝ｪ繧ｽ繝ｼ繧ｹ縺ｮ菴懈();
+
+ ///
+ /// Unmanaged 繝ｪ繧ｽ繝ｼ繧ｹ繧定ｧ｣謾ｾ縺励∪縺吶
+ ///
+ void OnUnmanaged繝ｪ繧ｽ繝ｼ繧ｹ縺ｮ隗｣謾ｾ();
+
+ ///
+ /// Managed 繝ｪ繧ｽ繝ｼ繧ｹ繧定ｧ｣謾ｾ縺励∪縺吶
+ ///
+ void OnManaged繝ｪ繧ｽ繝ｼ繧ｹ縺ｮ隗｣謾ｾ();
+
+ ///
+ /// 繝励Λ繧ｰ繧､繝ｳ縺ｮ騾ｲ陦後→謠冗判繧定｡後＞縺ｾ縺吶
+ /// 窶ｻ迴ｾ蝨ｨ縺ｮ DTXMania 縺ｧ縺ｯ縲騾ｲ陦後→謠冗判縺ｯ蛻髮｢縺輔ｌ縺ｦ縺縺ｾ縺帙ｓ縲
+ /// 窶ｻBeginScene()/EndScene() 縺ｯ DTXMania 蛛ｴ縺ｧ陦後≧縺溘ａ縲√励Λ繧ｰ繧､繝ｳ蛛ｴ縺ｧ縺ｯ荳崎ｦ√〒縺吶
+ /// 窶ｻkeyboard.t繝昴ｼ繝ｪ繝ｳ繧ｰ() 縺ｯ DTXMania 蛛ｴ縺ｧ陦後＞縺ｾ縺吶ｮ縺ｧ繝励Λ繧ｰ繧､繝ｳ蛛ｴ縺ｧ縺ｯ陦後ｏ縺ｪ縺縺ｧ荳九＆縺縲
+ /// 繝代ャ繝牙･蜉帙ゆｻ悶ｮ繝励Λ繧ｰ繧､繝ｳ縺悟･蜉帛頃譛我ｸｭ縺ｧ縺ゅｋ蝣ｴ蜷医ｯ null 縺梧ｸ｡縺輔ｌ縺ｾ縺吶
+ /// 繧ｭ繝ｼ繝懊ｼ繝牙･蜉帙ゆｻ悶ｮ繝励Λ繧ｰ繧､繝ｳ縺悟･蜉帛頃譛我ｸｭ縺ｧ縺ゅｋ蝣ｴ蜷医ｯ null 縺梧ｸ｡縺輔ｌ縺ｾ縺吶
+ ///
+ void On騾ｲ陦梧緒逕ｻ( global::TJAPlayer3.CPad pad, FDK.IInputDevice keyboard );
+
+ ///
+ /// 繧ｹ繝繝ｼ繧ｸ縺悟､峨ｏ繧句ｺｦ縺ｫ蜻ｼ縺ｳ蜃ｺ縺輔ｌ縺ｾ縺吶
+ /// 蜻ｼ縺ｳ蜃ｺ縺励ち繧､繝溘Φ繧ｰ縺ｯ縲∵眠縺励＞繧ｹ繝繝ｼ繧ｸ縺ｮ豢ｻ諤ｧ蛹也峩蠕後°縺､謠冗判髢句ｧ句燕縺ｧ縺吶
+ ///
+ void On繧ｹ繝繝ｼ繧ｸ螟画峩();
+
+ ///
+ /// 驕ｸ譖ｲ逕ｻ髱｢縺ｧ驕ｸ謚樊峇縺悟､画峩縺輔ｌ縺溷ｴ蜷医↓蜻ｼ縺ｳ蜃ｺ縺輔ｌ縺ｾ縺吶
+ /// 蜷後§ set.def 縺ｫ螻槭☆繧区峇縺ｮ髮｣譏灘ｺｦ縺鯉ｼHHﾃ2縺ｧｼ牙､画峩縺輔ｌ縺溷ｴ蜷医〒繧ょ他縺ｳ蜃ｺ縺輔ｌ縺ｾ縺吶
+ /// 縺溘□縺励驕ｸ謚槭′譖ｲ縺ｧ縺ｪ縺ｼBOX, BACK, RANDOM 縺ｪ縺ｩｼ牙ｴ蜷医↓縺ｯ蜻ｼ縺ｳ蜃ｺ縺輔ｌ縺ｾ縺帙ｓ縲
+ ///
+ /// 驕ｸ謚槭＆繧後※縺繧区峇縺ｮ繝輔ぃ繧､繝ｫ縺ｮ蜷榊燕縲らｵｶ蟇ｾ繝代せ縲
+ /// 驕ｸ謚槭＆繧後※縺繧区峇縺ｮ繝悶Ο繝繧ｯ蜀縺ｮ譖ｲ逡ｪ蜿ｷ(0ｽ4)縲
+ void On驕ｸ謚樊峇螟画峩( string str驕ｸ謚樊峇繝輔ぃ繧､繝ｫ蜷, int n譖ｲ逡ｪ蜿ｷin繝悶Ο繝繧ｯ );
+
+ void On貍泌･上け繝ｪ繧｢( global::TJAPlayer3.CScoreIni scoreIni );
+ void On貍泌･丞､ｱ謨( global::TJAPlayer3.CScoreIni scoreIni );
+ void On貍泌･上く繝｣繝ｳ繧ｻ繝ｫ( global::TJAPlayer3.CScoreIni scoreIni );
+ }
+}
diff --git a/TJAPlayer3/Plugins/IPluginHost.cs b/TJAPlayer3/Plugins/IPluginHost.cs
new file mode 100644
index 00000000..7e47436a
--- /dev/null
+++ b/TJAPlayer3/Plugins/IPluginHost.cs
@@ -0,0 +1,64 @@
+ｻｿnamespace TJAPlayer3
+{
+ ///
+ /// 繝励Λ繧ｰ繧､繝ｳ繝帙せ繝域ュ蝣ｱ謠蝉ｾ帙う繝ｳ繧ｿ繝ｼ繝輔ぉ繝ｼ繧ｹ縲
+ /// 繝励Λ繧ｰ繧､繝ｳ縺ｧ縺ｯ縲＾n蛻晄悄蛹() 縺ｧ貂｡縺輔ｌ繧九％縺ｮ繧､繝ｳ繧ｿ繝ｼ繝輔ぉ繝ｼ繧ｹ繧ｪ繝悶ず繧ｧ繧ｯ繝医ｒ騾壹§縺ｦ縲
+ /// DTXMania 縺ｮ謖√▽讒倥縺ｪ繝ｪ繧ｽ繝ｼ繧ｹ縺ｫ繧｢繧ｯ繧ｻ繧ｹ縺ｧ縺阪∪縺吶
+ ///
+ public interface IPluginHost
+ {
+ ///
+ /// DTXMania 縺ｮ繝舌ｼ繧ｸ繝ｧ繝ｳ繧定｡ｨ縺励∪縺吶
+ ///
+ global::TJAPlayer3.CDTXVersion DTXManiaVersion { get; }
+
+ ///
+ /// Direct3D9 繝繝舌う繧ｹ繧ｪ繝悶ず繧ｧ繧ｯ繝医
+ /// 繝ｭ繧ｹ繝医＠縺溘ｊ繝ｪ繧ｻ繝繝医＠縺溘ｊ縺吶ｋ縺薙→縺後≠繧九ｮ縺ｧ縲∝ｸｸ縺ｫ蜷後§蛟､縺ｧ縺ゅｋ縺ｨ縺ｯ菫晁ｨｼ縺輔ｌ縺ｾ縺帙ｓ縲
+ ///
+ SlimDX.Direct3D9.Device D3D9Device { get; }
+
+ ///
+ /// DirectSound 縺ｮ邂｡逅繧ｯ繝ｩ繧ｹ縲
+ /// WAV, XA, OGG, MP3 縺ｮ繧ｵ繧ｦ繝ｳ繝峨ヵ繧｡繧､繝ｫ縺九ｉ CSound 繧ｪ繝悶ず繧ｧ繧ｯ繝医ｒ逕滓舌〒縺阪∪縺吶
+ ///
+ FDK.CSound邂｡逅 Sound邂｡逅 { get; }
+
+ ///
+ /// 謠冗判繧ｨ繝ｪ繧｢縺ｮ繧ｵ繧､繧ｺ繧定ｿ斐＠縺ｾ縺呻ｼ医ヴ繧ｯ繧ｻ繝ｫ蜊倅ｽ搾ｼ峨
+ ///
+ System.Drawing.Size ClientSize { get; }
+
+ ///
+ /// 迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ縺ｮID繧定｡ｨ縺励∪縺吶
+ ///
+ global::TJAPlayer3.CStage.E繧ｹ繝繝ｼ繧ｸ e迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ { get; }
+
+ ///
+ /// 迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ縺ｫ縺翫¢繧九ヵ繧ｧ繝ｼ繧ｺ縺ｮID繧定｡ｨ縺励∪縺吶
+ ///
+ global::TJAPlayer3.CStage.E繝輔ぉ繝ｼ繧ｺ e迴ｾ蝨ｨ縺ｮ繝輔ぉ繝ｼ繧ｺ { get; }
+
+ ///
+ /// 閾ｪ蛻莉･螟悶ｯ蜈･蜉帙ョ繝ｼ繧ｿ繧呈桶縺｣縺ｦ縺ｯ縺ｪ繧峨↑縺縺薙→繧貞ｮ｣險縺励∪縺吶
+ /// DTXMania 譛ｬ菴薙ｯ蜈･蜉帙ョ繝ｼ繧ｿ縺ｮ繝昴ｼ繝ｪ繝ｳ繧ｰ縺ｮ縺ｿ繧定｡後＞縲∽ｻ悶ｮ繝励Λ繧ｰ繧､繝ｳ縺ｫ蟇ｾ縺励※縺ｯ縲＾n騾ｲ陦梧緒逕ｻ() 縺ｮ2縺､縺ｮ蜈･蜉帙↓ null 繧呈ｸ｡縺励∪縺吶
+ ///
+ /// 螳｣險縺吶ｋ繝励Λ繧ｰ繧､繝ｳｼ医☆縺ｪ繧上■ this 繧呈欠螳壹☆繧具ｼ
+ /// 蜊譛峨↓謌仙粥縺吶ｌ縺ｰ true 繧定ｿ斐＠縲∵里縺ｫ隱ｰ縺九′蜊譛我ｸｭ縺ｧ縺ゅｋ蝣ｴ蜷医↓縺ｯ false 繧定ｿ斐＠縺ｾ縺吶
+ bool t蜈･蜉帙ｒ蜊譛峨☆繧( IPluginActivity act );
+
+ ///
+ /// 閾ｪ蛻莉･螟悶′蜈･蜉帙ョ繝ｼ繧ｿ繧呈桶縺｣縺ｦ濶ｯ縺縺薙→繧貞ｮ｣險縺励∪縺吶
+ /// DTXMania 譛ｬ菴薙ｯ繝昴ｼ繝ｪ繝ｳ繧ｰ莉･螟悶ｮ蜈･蜉帛ｦ逅繧帝幕蟋九＠縲∽ｻ悶ｮ繝励Λ繧ｰ繧､繝ｳ縺ｫ蟇ｾ縺励※縺ｯ縲＾n騾ｲ陦梧緒逕ｻ() 縺ｮ2縺､縺ｮ蠑墓焚縺ｫ譛牙柑縺ｪ蛟､繧呈ｸ｡縺励∪縺吶
+ ///
+ /// 螳｣險縺吶ｋ繝励Λ繧ｰ繧､繝ｳｼ医☆縺ｪ繧上■ this 繧呈欠螳壹☆繧具ｼ
+ /// 蜊譛芽ｧ｣髯､縺ｫ謌仙粥縺吶ｌ縺ｰ true縲∝､ｱ謨励☆繧後ｰ flase 繧定ｿ斐＠縺ｾ縺吶
+ bool t蜈･蜉帙ｮ蜊譛峨ｒ隗｣髯､縺吶ｋ( IPluginActivity act );
+
+ ///
+ /// 謖螳壹＆繧後◆繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝会ｼ州GM繧貞咲函縺励∪縺吶
+ ///
+ /// 蜀咲函縺吶ｋ繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝峨ｮ隴伜挨蟄舌
+ void t繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝峨ｒ蜀咲函縺吶ｋ( E繧ｷ繧ｹ繝繝繧ｵ繧ｦ繝ｳ繝 sound );
+ }
+}
diff --git a/TJAPlayer3/Properties/AssemblyInfo.cs b/TJAPlayer3/Properties/AssemblyInfo.cs
new file mode 100644
index 00000000..26a12c0d
--- /dev/null
+++ b/TJAPlayer3/Properties/AssemblyInfo.cs
@@ -0,0 +1,42 @@
+ｻｿusing System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Resources;
+
+// 繧｢繧ｻ繝ｳ繝悶Μ縺ｫ髢｢縺吶ｋ荳闊ｬ諠蝣ｱ縺ｯ莉･荳九ｮ螻樊ｧ繧ｻ繝繝医ｒ縺ｨ縺翫＠縺ｦ蛻ｶ蠕｡縺輔ｌ縺ｾ縺吶
+// 繧｢繧ｻ繝ｳ繝悶Μ縺ｫ髢｢騾｣莉倥¢繧峨ｌ縺ｦ縺繧区ュ蝣ｱ繧貞､画峩縺吶ｋ縺ｫ縺ｯ縲
+// 縺薙ｌ繧峨ｮ螻樊ｧ蛟､繧貞､画峩縺励※縺上□縺輔＞縲
+[assembly: AssemblyTitle("TJAPlayer3 - A .tja file player.")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("TJAPlayer3")]
+[assembly: AssemblyCopyright("")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// ComVisible 繧 false 縺ｫ險ｭ螳壹☆繧九→縲√◎縺ｮ蝙九ｯ縺薙ｮ繧｢繧ｻ繝ｳ繝悶Μ蜀縺ｧ COM 繧ｳ繝ｳ繝昴ｼ繝阪Φ繝医°繧
+// 蜿らｧ荳榊庄閭ｽ縺ｫ縺ｪ繧翫∪縺吶COM 縺九ｉ縺薙ｮ繧｢繧ｻ繝ｳ繝悶Μ蜀縺ｮ蝙九↓繧｢繧ｯ繧ｻ繧ｹ縺吶ｋ蝣ｴ蜷医ｯ縲
+// 縺昴ｮ蝙九ｮ ComVisible 螻樊ｧ繧 true 縺ｫ險ｭ螳壹＠縺ｦ縺上□縺輔＞縲
+[assembly: ComVisible(false)]
+
+// 谺｡縺ｮ GUID 縺ｯ縲√％縺ｮ繝励Ο繧ｸ繧ｧ繧ｯ繝医′ COM 縺ｫ蜈ｬ髢九＆繧後ｋ蝣ｴ蜷医ｮ縲》ypelib 縺ｮ ID 縺ｧ縺
+[assembly: Guid("ee05cb8c-73a8-41c3-8677-a0afbe7401f7")]
+
+// 繧｢繧ｻ繝ｳ繝悶Μ縺ｮ繝舌ｼ繧ｸ繝ｧ繝ｳ諠蝣ｱ縺ｯ縲∽ｻ･荳九ｮ 4 縺､縺ｮ蛟､縺ｧ讒区舌＆繧後※縺縺ｾ縺:
+//
+// Major Version
+// Minor Version
+// Build Number
+// Revision
+//
+// 縺吶∋縺ｦ縺ｮ蛟､繧呈欠螳壹☆繧九°縲∽ｸ九ｮ繧医≧縺ｫ '*' 繧剃ｽｿ縺｣縺ｦ繝薙Ν繝峨♀繧医ｳ繝ｪ繝薙ず繝ｧ繝ｳ逡ｪ蜿ｷ繧
+// 譌｢螳壼､縺ｫ縺吶ｋ縺薙→縺後〒縺阪∪縺:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("0.1.0")]
+[assembly: AssemblyFileVersion("1.4.5.3")]
+[assembly: NeutralResourcesLanguage("ja-JP")]
+
+// 縺薙ｮ繧｢繧ｻ繝ｳ繝悶Μ縺ｯ縲後Λ繧､繝悶Λ繝ｪ縲阪〒縺ゅｋｼ磯屮隱ｭ蛹悶ヤ繝ｼ繝ｫ縺ｸ縺ｮ謖遉ｺｼ峨
+// 竊 繝繝輔か繝ｫ繝医ｮ true 縺ｮ縺ｾ縺ｾ縺縺ｨ縲√い繧ｻ繝ｳ繝悶Μ public 縺ｪ繝｡繝ｳ繝舌ｂ縺吶∋縺ｦ髮｣隱ｭ蛹悶＆繧後※縺励∪縺縲
+[assembly: ObfuscateAssembly( false )]
diff --git a/TJAPlayer3/Properties/Discord.Designer.cs b/TJAPlayer3/Properties/Discord.Designer.cs
new file mode 100644
index 00000000..8591c74c
--- /dev/null
+++ b/TJAPlayer3/Properties/Discord.Designer.cs
@@ -0,0 +1,117 @@
+ｻｿ//------------------------------------------------------------------------------
+//
+// 縺薙ｮ繧ｳ繝ｼ繝峨ｯ繝繝ｼ繝ｫ縺ｫ繧医▲縺ｦ逕滓舌＆繧後∪縺励◆縲
+// 繝ｩ繝ｳ繧ｿ繧､繝 繝舌ｼ繧ｸ繝ｧ繝ｳ:4.0.30319.42000
+//
+// 縺薙ｮ繝輔ぃ繧､繝ｫ縺ｸ縺ｮ螟画峩縺ｯ縲∽ｻ･荳九ｮ迥ｶ豕∽ｸ九〒荳肴ｭ｣縺ｪ蜍穂ｽ懊ｮ蜴溷屏縺ｫ縺ｪ縺｣縺溘ｊ縲
+// 繧ｳ繝ｼ繝峨′蜀咲函謌舌＆繧後ｋ縺ｨ縺阪↓謳榊､ｱ縺励◆繧翫＠縺ｾ縺吶
+//
+//------------------------------------------------------------------------------
+
+namespace TJAPlayer3.Properties {
+ using System;
+
+
+ ///
+ /// 繝ｭ繝ｼ繧ｫ繝ｩ繧､繧ｺ縺輔ｌ縺滓枚蟄怜励↑縺ｩ繧呈､懃ｴ｢縺吶ｋ縺溘ａ縺ｮ縲∝宍蟇縺ｫ蝙区欠螳壹＆繧後◆繝ｪ繧ｽ繝ｼ繧ｹ 繧ｯ繝ｩ繧ｹ縺ｧ縺吶
+ ///
+ // 縺薙ｮ繧ｯ繝ｩ繧ｹ縺ｯ StronglyTypedResourceBuilder 繧ｯ繝ｩ繧ｹ縺 ResGen
+ // 縺ｾ縺溘ｯ Visual Studio 縺ｮ繧医≧縺ｪ繝繝ｼ繝ｫ繧剃ｽｿ逕ｨ縺励※閾ｪ蜍慕函謌舌＆繧後∪縺励◆縲
+ // 繝｡繝ｳ繝舌ｼ繧定ｿｽ蜉縺ｾ縺溘ｯ蜑企勁縺吶ｋ縺ｫ縺ｯ縲.ResX 繝輔ぃ繧､繝ｫ繧堤ｷｨ髮縺励※縲/str 繧ｪ繝励す繝ｧ繝ｳ縺ｨ蜈ｱ縺ｫ
+ // ResGen 繧貞ｮ溯｡後＠逶ｴ縺吶°縲√∪縺溘ｯ VS 繝励Ο繧ｸ繧ｧ繧ｯ繝医ｒ繝薙Ν繝峨＠逶ｴ縺励∪縺吶
+ [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "16.0.0.0")]
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+ [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+ internal class Discord {
+
+ private static global::System.Resources.ResourceManager resourceMan;
+
+ private static global::System.Globalization.CultureInfo resourceCulture;
+
+ [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
+ internal Discord() {
+ }
+
+ ///
+ /// 縺薙ｮ繧ｯ繝ｩ繧ｹ縺ｧ菴ｿ逕ｨ縺輔ｌ縺ｦ縺繧九く繝｣繝繧ｷ繝･縺輔ｌ縺 ResourceManager 繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ繧定ｿ斐＠縺ｾ縺吶
+ ///
+ [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+ internal static global::System.Resources.ResourceManager ResourceManager {
+ get {
+ if (object.ReferenceEquals(resourceMan, null)) {
+ global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("TJAPlayer3.Properties.Discord", typeof(Discord).Assembly);
+ resourceMan = temp;
+ }
+ return resourceMan;
+ }
+ }
+
+ ///
+ /// 縺吶∋縺ｦ縺ｫ縺､縺縺ｦ縲∫樟蝨ｨ縺ｮ繧ｹ繝ｬ繝繝峨ｮ CurrentUICulture 繝励Ο繝代ユ繧｣繧偵が繝ｼ繝舌ｼ繝ｩ繧､繝峨＠縺ｾ縺
+ /// 迴ｾ蝨ｨ縺ｮ繧ｹ繝ｬ繝繝峨ｮ CurrentUICulture 繝励Ο繝代ユ繧｣繧偵が繝ｼ繝舌ｼ繝ｩ繧､繝峨＠縺ｾ縺吶
+ ///
+ [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+ internal static global::System.Globalization.CultureInfo Culture {
+ get {
+ return resourceCulture;
+ }
+ set {
+ resourceCulture = value;
+ }
+ }
+
+ ///
+ /// Auto 縺ｫ鬘樔ｼｼ縺励※縺繧九Ο繝ｼ繧ｫ繝ｩ繧､繧ｺ縺輔ｌ縺滓枚蟄怜励ｒ讀懃ｴ｢縺励∪縺吶
+ ///
+ internal static string Info_IsAuto {
+ get {
+ return ResourceManager.GetString("Info_IsAuto", resourceCulture);
+ }
+ }
+
+ ///
+ /// Playing 縺ｫ鬘樔ｼｼ縺励※縺繧九Ο繝ｼ繧ｫ繝ｩ繧､繧ｺ縺輔ｌ縺滓枚蟄怜励ｒ讀懃ｴ｢縺励∪縺吶
+ ///
+ internal static string Stage_InGame {
+ get {
+ return ResourceManager.GetString("Stage_InGame", resourceCulture);
+ }
+ }
+
+ ///
+ /// Result 縺ｫ鬘樔ｼｼ縺励※縺繧九Ο繝ｼ繧ｫ繝ｩ繧､繧ｺ縺輔ｌ縺滓枚蟄怜励ｒ讀懃ｴ｢縺励∪縺吶
+ ///
+ internal static string Stage_Result {
+ get {
+ return ResourceManager.GetString("Stage_Result", resourceCulture);
+ }
+ }
+
+ ///
+ /// Settings 縺ｫ鬘樔ｼｼ縺励※縺繧九Ο繝ｼ繧ｫ繝ｩ繧､繧ｺ縺輔ｌ縺滓枚蟄怜励ｒ讀懃ｴ｢縺励∪縺吶
+ ///
+ internal static string Stage_Settings {
+ get {
+ return ResourceManager.GetString("Stage_Settings", resourceCulture);
+ }
+ }
+
+ ///
+ /// SongSelect 縺ｫ鬘樔ｼｼ縺励※縺繧九Ο繝ｼ繧ｫ繝ｩ繧､繧ｺ縺輔ｌ縺滓枚蟄怜励ｒ讀懃ｴ｢縺励∪縺吶
+ ///
+ internal static string Stage_SongSelect {
+ get {
+ return ResourceManager.GetString("Stage_SongSelect", resourceCulture);
+ }
+ }
+
+ ///
+ /// Startup 縺ｫ鬘樔ｼｼ縺励※縺繧九Ο繝ｼ繧ｫ繝ｩ繧､繧ｺ縺輔ｌ縺滓枚蟄怜励ｒ讀懃ｴ｢縺励∪縺吶
+ ///
+ internal static string Stage_StartUp {
+ get {
+ return ResourceManager.GetString("Stage_StartUp", resourceCulture);
+ }
+ }
+ }
+}
diff --git a/TJAPlayer3/Properties/Discord.resx b/TJAPlayer3/Properties/Discord.resx
new file mode 100644
index 00000000..1219284d
--- /dev/null
+++ b/TJAPlayer3/Properties/Discord.resx
@@ -0,0 +1,138 @@
+ｻｿ
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ text/microsoft-resx
+
+
+ 2.0
+
+
+ System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
+
+
+ System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
+
+
+ Auto
+
+
+ Playing
+
+
+ Result
+
+
+ Settings
+
+
+ SongSelect
+
+
+ Startup
+
+
\ No newline at end of file
diff --git a/TJAPlayer3/Properties/Resources.Designer.cs b/TJAPlayer3/Properties/Resources.Designer.cs
new file mode 100644
index 00000000..be4b21fc
--- /dev/null
+++ b/TJAPlayer3/Properties/Resources.Designer.cs
@@ -0,0 +1,83 @@
+ｻｿ//------------------------------------------------------------------------------
+//
+// 縺薙ｮ繧ｳ繝ｼ繝峨ｯ繝繝ｼ繝ｫ縺ｫ繧医▲縺ｦ逕滓舌＆繧後∪縺励◆縲
+// 繝ｩ繝ｳ繧ｿ繧､繝 繝舌ｼ繧ｸ繝ｧ繝ｳ:4.0.30319.42000
+//
+// 縺薙ｮ繝輔ぃ繧､繝ｫ縺ｸ縺ｮ螟画峩縺ｯ縲∽ｻ･荳九ｮ迥ｶ豕∽ｸ九〒荳肴ｭ｣縺ｪ蜍穂ｽ懊ｮ蜴溷屏縺ｫ縺ｪ縺｣縺溘ｊ縲
+// 繧ｳ繝ｼ繝峨′蜀咲函謌舌＆繧後ｋ縺ｨ縺阪↓謳榊､ｱ縺励◆繧翫＠縺ｾ縺吶
+//
+//------------------------------------------------------------------------------
+
+namespace TJAPlayer3.Properties {
+ using System;
+
+
+ ///
+ /// 繝ｭ繝ｼ繧ｫ繝ｩ繧､繧ｺ縺輔ｌ縺滓枚蟄怜励↑縺ｩ繧呈､懃ｴ｢縺吶ｋ縺溘ａ縺ｮ縲∝宍蟇縺ｫ蝙区欠螳壹＆繧後◆繝ｪ繧ｽ繝ｼ繧ｹ 繧ｯ繝ｩ繧ｹ縺ｧ縺吶
+ ///
+ // 縺薙ｮ繧ｯ繝ｩ繧ｹ縺ｯ StronglyTypedResourceBuilder 繧ｯ繝ｩ繧ｹ縺 ResGen
+ // 縺ｾ縺溘ｯ Visual Studio 縺ｮ繧医≧縺ｪ繝繝ｼ繝ｫ繧剃ｽｿ逕ｨ縺励※閾ｪ蜍慕函謌舌＆繧後∪縺励◆縲
+ // 繝｡繝ｳ繝舌ｼ繧定ｿｽ蜉縺ｾ縺溘ｯ蜑企勁縺吶ｋ縺ｫ縺ｯ縲.ResX 繝輔ぃ繧､繝ｫ繧堤ｷｨ髮縺励※縲/str 繧ｪ繝励す繝ｧ繝ｳ縺ｨ蜈ｱ縺ｫ
+ // ResGen 繧貞ｮ溯｡後＠逶ｴ縺吶°縲√∪縺溘ｯ VS 繝励Ο繧ｸ繧ｧ繧ｯ繝医ｒ繝薙Ν繝峨＠逶ｴ縺励∪縺吶
+ [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "16.0.0.0")]
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+ [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+ internal class Resources {
+
+ private static global::System.Resources.ResourceManager resourceMan;
+
+ private static global::System.Globalization.CultureInfo resourceCulture;
+
+ [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
+ internal Resources() {
+ }
+
+ ///
+ /// 縺薙ｮ繧ｯ繝ｩ繧ｹ縺ｧ菴ｿ逕ｨ縺輔ｌ縺ｦ縺繧九く繝｣繝繧ｷ繝･縺輔ｌ縺 ResourceManager 繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ繧定ｿ斐＠縺ｾ縺吶
+ ///
+ [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+ internal static global::System.Resources.ResourceManager ResourceManager {
+ get {
+ if (object.ReferenceEquals(resourceMan, null)) {
+ global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("TJAPlayer3.Properties.Resources", typeof(Resources).Assembly);
+ resourceMan = temp;
+ }
+ return resourceMan;
+ }
+ }
+
+ ///
+ /// 縺吶∋縺ｦ縺ｫ縺､縺縺ｦ縲∫樟蝨ｨ縺ｮ繧ｹ繝ｬ繝繝峨ｮ CurrentUICulture 繝励Ο繝代ユ繧｣繧偵が繝ｼ繝舌ｼ繝ｩ繧､繝峨＠縺ｾ縺
+ /// 迴ｾ蝨ｨ縺ｮ繧ｹ繝ｬ繝繝峨ｮ CurrentUICulture 繝励Ο繝代ユ繧｣繧偵が繝ｼ繝舌ｼ繝ｩ繧､繝峨＠縺ｾ縺吶
+ ///
+ [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+ internal static global::System.Globalization.CultureInfo Culture {
+ get {
+ return resourceCulture;
+ }
+ set {
+ resourceCulture = value;
+ }
+ }
+
+ ///
+ /// (繧｢繧､繧ｳ繝ｳ) 縺ｫ鬘樔ｼｼ縺励◆蝙 System.Drawing.Icon 縺ｮ繝ｭ繝ｼ繧ｫ繝ｩ繧､繧ｺ縺輔ｌ縺溘Μ繧ｽ繝ｼ繧ｹ繧呈､懃ｴ｢縺励∪縺吶
+ ///
+ internal static System.Drawing.Icon dtx {
+ get {
+ object obj = ResourceManager.GetObject("dtx", resourceCulture);
+ return ((System.Drawing.Icon)(obj));
+ }
+ }
+
+ ///
+ /// (繧｢繧､繧ｳ繝ｳ) 縺ｫ鬘樔ｼｼ縺励◆蝙 System.Drawing.Icon 縺ｮ繝ｭ繝ｼ繧ｫ繝ｩ繧､繧ｺ縺輔ｌ縺溘Μ繧ｽ繝ｼ繧ｹ繧呈､懃ｴ｢縺励∪縺吶
+ ///
+ internal static System.Drawing.Icon tjap3 {
+ get {
+ object obj = ResourceManager.GetObject("tjap3", resourceCulture);
+ return ((System.Drawing.Icon)(obj));
+ }
+ }
+ }
+}
diff --git a/TJAPlayer3/Properties/Resources.resx b/TJAPlayer3/Properties/Resources.resx
new file mode 100644
index 00000000..ecc4e445
--- /dev/null
+++ b/TJAPlayer3/Properties/Resources.resx
@@ -0,0 +1,127 @@
+ｻｿ
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ text/microsoft-resx
+
+
+ 2.0
+
+
+ System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
+
+
+ System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
+
+
+
+ ..\dtx.ico;System.Drawing.Icon, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a
+
+
+ ..\Resources\TJAPlayer3-Develop-ReWrite.ico;System.Drawing.Icon, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a
+
+
\ No newline at end of file
diff --git a/TJAPlayer3/Properties/Settings.Designer.cs b/TJAPlayer3/Properties/Settings.Designer.cs
new file mode 100644
index 00000000..6e6c2f25
--- /dev/null
+++ b/TJAPlayer3/Properties/Settings.Designer.cs
@@ -0,0 +1,26 @@
+ｻｿ//------------------------------------------------------------------------------
+//
+// 縺薙ｮ繧ｳ繝ｼ繝峨ｯ繝繝ｼ繝ｫ縺ｫ繧医▲縺ｦ逕滓舌＆繧後∪縺励◆縲
+// 繝ｩ繝ｳ繧ｿ繧､繝 繝舌ｼ繧ｸ繝ｧ繝ｳ:4.0.30319.42000
+//
+// 縺薙ｮ繝輔ぃ繧､繝ｫ縺ｸ縺ｮ螟画峩縺ｯ縲∽ｻ･荳九ｮ迥ｶ豕∽ｸ九〒荳肴ｭ｣縺ｪ蜍穂ｽ懊ｮ蜴溷屏縺ｫ縺ｪ縺｣縺溘ｊ縲
+// 繧ｳ繝ｼ繝峨′蜀咲函謌舌＆繧後ｋ縺ｨ縺阪↓謳榊､ｱ縺励◆繧翫＠縺ｾ縺吶
+//
+//------------------------------------------------------------------------------
+
+namespace TJAPlayer3.Properties {
+
+
+ [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+ [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "16.7.0.0")]
+ internal sealed partial class Settings : global::System.Configuration.ApplicationSettingsBase {
+
+ private static Settings defaultInstance = ((Settings)(global::System.Configuration.ApplicationSettingsBase.Synchronized(new Settings())));
+
+ public static Settings Default {
+ get {
+ return defaultInstance;
+ }
+ }
+ }
+}
diff --git a/TJAPlayer3/Properties/Settings.settings b/TJAPlayer3/Properties/Settings.settings
new file mode 100644
index 00000000..39645652
--- /dev/null
+++ b/TJAPlayer3/Properties/Settings.settings
@@ -0,0 +1,7 @@
+ｻｿ
+
+
+
+
+
+
diff --git a/TJAPlayer3/Resources/TJAPlayer3-Develop-ReWrite.ico b/TJAPlayer3/Resources/TJAPlayer3-Develop-ReWrite.ico
new file mode 100644
index 00000000..0f583138
Binary files /dev/null and b/TJAPlayer3/Resources/TJAPlayer3-Develop-ReWrite.ico differ
diff --git a/TJAPlayer3/Songs/CBoxDef.cs b/TJAPlayer3/Songs/CBoxDef.cs
new file mode 100644
index 00000000..d693a985
--- /dev/null
+++ b/TJAPlayer3/Songs/CBoxDef.cs
@@ -0,0 +1,113 @@
+ｻｿusing System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Text;
+using System.IO;
+using System.Drawing;
+
+namespace TJAPlayer3
+{
+ internal class CBoxDef
+ {
+ // 繝励Ο繝代ユ繧｣
+
+ public Color Color;
+ public string Genre;
+ public string Title;
+ public string[] strBoxText = new string[3];
+ public Color ForeColor;
+ public Color BackColor;
+ public bool IsChangedForeColor;
+ public bool IsChangedBackColor;
+
+
+ // 繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ
+
+ public CBoxDef()
+ {
+ for (int i = 0; i < 3; i++)
+ this.strBoxText[i] = "";
+ this.Title = "";
+ this.Genre = "";
+ ForeColor = Color.White;
+ BackColor = Color.Black;
+
+ }
+ public CBoxDef( string boxdef繝輔ぃ繧､繝ｫ蜷 )
+ : this()
+ {
+ this.t隱ｭ縺ｿ霎ｼ縺ｿ( boxdef繝輔ぃ繧､繝ｫ蜷 );
+ }
+
+
+ // 繝｡繧ｽ繝繝
+
+ public void t隱ｭ縺ｿ霎ｼ縺ｿ( string boxdef繝輔ぃ繧､繝ｫ蜷 )
+ {
+ StreamReader reader = new StreamReader( boxdef繝輔ぃ繧､繝ｫ蜷, Encoding.GetEncoding( "Shift_JIS" ) );
+ string str = null;
+ while( ( str = reader.ReadLine() ) != null )
+ {
+ if( str.Length != 0 )
+ {
+ try
+ {
+ char[] ignoreCharsWoColon = new char[] { ' ', '\t' };
+
+ str = str.TrimStart( ignoreCharsWoColon );
+ if( ( str[ 0 ] == '#' ) && ( str[ 0 ] != ';' ) )
+ {
+ if( str.IndexOf( ';' ) != -1 )
+ {
+ str = str.Substring( 0, str.IndexOf( ';' ) );
+ }
+
+ char[] ignoreChars = new char[] { ':', ' ', '\t' };
+
+ if ( str.StartsWith( "#TITLE", StringComparison.OrdinalIgnoreCase ) )
+ {
+ this.Title = str.Substring( 6 ).Trim( ignoreChars );
+ }
+ else if( str.StartsWith( "#GENRE", StringComparison.OrdinalIgnoreCase ) )
+ {
+ this.Genre = str.Substring( 6 ).Trim( ignoreChars );
+ }
+ else if ( str.StartsWith( "#FONTCOLOR", StringComparison.OrdinalIgnoreCase ) )
+ {
+ this.Color = ColorTranslator.FromHtml( str.Substring( 10 ).Trim( ignoreChars ) );
+ }
+ else if (str.StartsWith("#FORECOLOR", StringComparison.OrdinalIgnoreCase))
+ {
+ this.ForeColor = ColorTranslator.FromHtml(str.Substring(10).Trim(ignoreChars));
+ IsChangedForeColor = true;
+ }
+ else if (str.StartsWith("#BACKCOLOR", StringComparison.OrdinalIgnoreCase))
+ {
+ this.BackColor = ColorTranslator.FromHtml(str.Substring(10).Trim(ignoreChars));
+ IsChangedBackColor = true;
+ }
+ else
+ {
+ for(int i = 0; i < 3; i++)
+ {
+ if (str.StartsWith("#BOXEXPLANATION" + (i + 1).ToString(), StringComparison.OrdinalIgnoreCase))
+ {
+ this.strBoxText[i] = str.Substring(16).Trim(ignoreChars);
+ }
+ }
+ }
+ }
+ continue;
+ }
+ catch (Exception e)
+ {
+ Trace.TraceError( e.ToString() );
+ Trace.TraceError( "萓句､悶′逋ｺ逕溘＠縺ｾ縺励◆縺悟ｦ逅繧堤ｶ咏ｶ壹＠縺ｾ縺吶 (178a9a36-a59e-4264-8e4c-b3c3459db43c)" );
+ continue;
+ }
+ }
+ }
+ reader.Close();
+ }
+ }
+}
diff --git a/TJAPlayer3/Songs/CCourse.cs b/TJAPlayer3/Songs/CCourse.cs
new file mode 100644
index 00000000..bb72afa1
--- /dev/null
+++ b/TJAPlayer3/Songs/CCourse.cs
@@ -0,0 +1,48 @@
+ｻｿusing System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+
+namespace TJAPlayer3
+{
+ public class CCourse
+ {
+ //2016.11.07 kairera0467
+ //縺ｨ繧翫≠縺医★繝｡繝｢莉｣繧上ｊ縺ｫ
+ //
+ //
+ //笳九さ繝ｼ繧ｹ繝繝ｼ繧ｿｼ.tjcｼ
+
+ //隍謨ｰ縺ｮ譖ｲ繧貞ｱ騾壹ｮ繧ｲ繝ｼ繧ｸ縺ｧ騾｣邯壹＠縺ｦ貍泌･上＠縺ｾ縺吶
+ //騾壼ｸｸ繧ｲ繝ｼ繧ｸ縺ｯ譟先ｮｵ菴崎ｪ榊ｮ壹▲縺ｽ縺蠅玲ｸ帙ｮ莉墓婿繧偵＠縺ｾ縺呻ｼ郁｣懈ｭ｣縺ｪ縺暦ｼ峨
+
+ //縺ｾ縺滓峇縺ｯ閾ｪ蜍慕噪縺ｫ蜀咲函縺輔ｌ繧九◆繧√√ｰ縺縺昴￥遲峨ｮ繧ｪ繝励す繝ｧ繝ｳ縺ｮ菴ｿ逕ｨ縺ｯ蜃ｺ譚･縺ｾ縺帙ｓ縲
+
+ //.tjc縺ｮ繝輔ぃ繧､繝ｫ縺ｯ莉悶ｮ隴憺擇ｼ.tja遲会ｼ峨→蜷梧ｧ倥↓謇ｱ繧上ｌ繧九ｮ縺ｧ隴憺擇繝繝ｼ繧ｿ縺ｨ蜷後§繝輔か繝ｫ繝縺ｫ蜈･繧後※繧よｧ九＞縺ｾ縺帙ｓ縲
+ //
+ // 笳上倥ャ繝
+
+ // TITLE: 繧ｳ繝ｼ繧ｹ縺ｮ蜷榊燕縲
+
+ // COURSE: 縲窪asy縲阪君ormal縲阪粂ard縲阪薫ni縲阪窪dit縲阪ｂ縺励￥縺ｯ0-4縺ｮ蛟､縲
+ // 隴憺擇縺ｮ髮｣譏灘ｺｦ縲ゑｼ医さ繝ｼ繧ｹ縺ｨ蜻ｼ縺ｶ縺ｨ繧繧縺薙＠縺縺ｧ縺吶′縺碑ｫ呈価縺上□縺輔＞ｼ
+ // 謖螳壹＠縺溯ｭ憺擇縺ｯ蜈ｨ縺ｦ縺薙％縺ｧ謖螳壹☆繧矩屮譏灘ｺｦ縺ｮ隴憺擇縺梧ｵ√ｌ縺ｾ縺吶
+ // 譖ｲ縺斐→縺ｮ謖螳壹ｯｼ井ｻ翫ｮ縺ｨ縺薙ｍｼ峨〒縺阪∪縺帙ｓ縲
+
+ // LIFE: 繝ｩ繧､繝輔ら怐逡･蜿ｯ縲
+ // 縺薙％縺ｫ蛟､繧貞･繧後ｋ縺ｨ騾壼ｸｸ繧ｲ繝ｼ繧ｸ縺ｮ莉｣繧上ｊ縺ｫ繝ｩ繧､繝募宛縺ｫ縺ｪ繧翫∪縺吶
+
+ // SONG: 譖ｲ繝繝ｼ繧ｿ縲
+ // 貍泌･上☆繧区峇縺ｮ繝輔ぃ繧､繝ｫ蜷搾ｼ.tja/.tjfｼ峨ｒtaikojiro.exe縺ｮ縺ゅｋ繝繧｣繝ｬ繧ｯ繝医Μ縺九ｉ縺ｮ逶ｸ蟇ｾ繝代せ縺ｧ謖螳壹
+ // 謖螳壹＆繧後◆繝繝ｼ繧ｿ縺ｯ荳翫↓縺ゅｋ繧ゅｮ縺九ｉ鬆縺ｫ貍泌･上＆繧後∪縺吶
+
+
+ public void t蜈･蜉( string str繝輔ぃ繧､繝ｫ蜷 )
+ {
+ StreamReader reader = new StreamReader( str繝輔ぃ繧､繝ｫ蜷 );
+ string str = reader.ReadToEnd();
+ reader.Close();
+ }
+ }
+}
diff --git a/TJAPlayer3/Songs/CDTX.cs b/TJAPlayer3/Songs/CDTX.cs
new file mode 100644
index 00000000..2d63b090
--- /dev/null
+++ b/TJAPlayer3/Songs/CDTX.cs
@@ -0,0 +1,8495 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Runtime.InteropServices;
+using System.Drawing;
+using System.Diagnostics;
+using System.IO;
+using System.Globalization;
+using System.Threading;
+using System.Text.RegularExpressions;
+using FDK;
+using FDK.ExtensionMethods;
+using TJAPlayer3;
+
+namespace TJAPlayer3
+{
+ internal class CDTX : CActivity
+ {
+ // 螳壽焚
+
+ public enum E遞ｮ蛻･ { DTX, GDA, G2D, BMS, BME, SMF }
+
+ // 繧ｯ繝ｩ繧ｹ
+
+ public class CAVI : IDisposable
+ {
+ public CAvi avi;
+ private bool bDispose貂医∩;
+ public int n逡ｪ蜿ｷ;
+ public string str繧ｳ繝｡繝ｳ繝域枚 = "";
+ public string str繝輔ぃ繧､繝ｫ蜷 = "";
+
+ public void OnDeviceCreated()
+ {
+ #region [ strAVI繝輔ぃ繧､繝ｫ蜷阪ｮ菴懈舌]
+ //-----------------
+ string strAVI繝輔ぃ繧､繝ｫ蜷;
+ if (!string.IsNullOrEmpty(TJAPlayer3.DTX.PATH_WAV))
+ strAVI繝輔ぃ繧､繝ｫ蜷 = TJAPlayer3.DTX.PATH_WAV + this.str繝輔ぃ繧､繝ｫ蜷;
+ else
+ strAVI繝輔ぃ繧､繝ｫ蜷 = TJAPlayer3.DTX.str繝輔か繝ｫ繝蜷 + this.str繝輔ぃ繧､繝ｫ蜷;
+ //-----------------
+ #endregion
+
+ if (!File.Exists(strAVI繝輔ぃ繧､繝ｫ蜷))
+ {
+ Trace.TraceWarning("繝輔ぃ繧､繝ｫ縺悟ｭ伜惠縺励∪縺帙ｓ縲({0})({1})", this.str繧ｳ繝｡繝ｳ繝域枚, strAVI繝輔ぃ繧､繝ｫ蜷);
+ this.avi = null;
+ return;
+ }
+
+ // AVI 縺ｮ逕滓舌
+
+ try
+ {
+ this.avi = new CAvi(strAVI繝輔ぃ繧､繝ｫ蜷);
+ Trace.TraceInformation("蜍慕判繧堤函謌舌＠縺ｾ縺励◆縲({0})({1})({2}frames)", this.str繧ｳ繝｡繝ｳ繝域枚, strAVI繝輔ぃ繧､繝ｫ蜷, this.avi.GetMaxFrameCount());
+ }
+ catch (Exception e)
+ {
+ Trace.TraceError(e.ToString());
+ Trace.TraceError("蜍慕判縺ｮ逕滓舌↓螟ｱ謨励＠縺ｾ縺励◆縲({0})({1})", this.str繧ｳ繝｡繝ｳ繝域枚, strAVI繝輔ぃ繧､繝ｫ蜷);
+ this.avi = null;
+ }
+ }
+ public override string ToString()
+ {
+ return string.Format("CAVI{0}: File:{1}, Comment:{2}", CDTX.tZZ(this.n逡ｪ蜿ｷ), this.str繝輔ぃ繧､繝ｫ蜷, this.str繧ｳ繝｡繝ｳ繝域枚);
+ }
+
+ #region [ IDisposable 螳溯｣ ]
+ //-----------------
+ public void Dispose()
+ {
+ if (this.bDispose貂医∩)
+ return;
+
+ if (this.avi != null)
+ {
+ #region [ strAVI繝輔ぃ繧､繝ｫ蜷 縺ｮ菴懈舌 ]
+ //-----------------
+ string strAVI繝輔ぃ繧､繝ｫ蜷;
+ if (!string.IsNullOrEmpty(TJAPlayer3.DTX.PATH_WAV))
+ strAVI繝輔ぃ繧､繝ｫ蜷 = TJAPlayer3.DTX.PATH_WAV + this.str繝輔ぃ繧､繝ｫ蜷;
+ else
+ strAVI繝輔ぃ繧､繝ｫ蜷 = TJAPlayer3.DTX.str繝輔か繝ｫ繝蜷 + this.str繝輔ぃ繧､繝ｫ蜷;
+ //-----------------
+ #endregion
+
+ this.avi.Dispose();
+ this.avi = null;
+
+ Trace.TraceInformation("蜍慕判繧定ｧ｣謾ｾ縺励∪縺励◆縲({0})({1})", this.str繧ｳ繝｡繝ｳ繝域枚, strAVI繝輔ぃ繧､繝ｫ蜷);
+ }
+
+ this.bDispose貂医∩ = true;
+ }
+ //-----------------
+ #endregion
+ }
+ public class CAVIPAN
+ {
+ public int nAVI逡ｪ蜿ｷ;
+ public int n遘ｻ蜍墓凾髢田t;
+ public int n逡ｪ蜿ｷ;
+ public Point pt蜍慕判蛛ｴ髢句ｧ倶ｽ咲ｽｮ = new Point(0, 0);
+ public Point pt蜍慕判蛛ｴ邨ゆｺ菴咲ｽｮ = new Point(0, 0);
+ public Point pt陦ｨ遉ｺ蛛ｴ髢句ｧ倶ｽ咲ｽｮ = new Point(0, 0);
+ public Point pt陦ｨ遉ｺ蛛ｴ邨ゆｺ菴咲ｽｮ = new Point(0, 0);
+ public Size sz髢句ｧ九し繧､繧ｺ = new Size(0, 0);
+ public Size sz邨ゆｺ繧ｵ繧､繧ｺ = new Size(0, 0);
+
+ public override string ToString()
+ {
+ return string.Format("CAVIPAN{0}: AVI:{14}, 髢句ｧ九し繧､繧ｺ:{1}x{2}, 邨ゆｺ繧ｵ繧､繧ｺ:{3}x{4}, 蜍慕判蛛ｴ髢句ｧ倶ｽ咲ｽｮ:{5}x{6}, 蜍慕判蛛ｴ邨ゆｺ菴咲ｽｮ:{7}x{8}, 陦ｨ遉ｺ蛛ｴ髢句ｧ倶ｽ咲ｽｮ:{9}x{10}, 陦ｨ遉ｺ蛛ｴ邨ゆｺ菴咲ｽｮ:{11}x{12}, 遘ｻ蜍墓凾髢:{13}ct",
+ CDTX.tZZ(this.n逡ｪ蜿ｷ),
+ this.sz髢句ｧ九し繧､繧ｺ.Width, this.sz髢句ｧ九し繧､繧ｺ.Height,
+ this.sz邨ゆｺ繧ｵ繧､繧ｺ.Width, this.sz邨ゆｺ繧ｵ繧､繧ｺ.Height,
+ this.pt蜍慕判蛛ｴ髢句ｧ倶ｽ咲ｽｮ.X, this.pt蜍慕判蛛ｴ髢句ｧ倶ｽ咲ｽｮ.Y,
+ this.pt蜍慕判蛛ｴ邨ゆｺ菴咲ｽｮ.X, this.pt蜍慕判蛛ｴ邨ゆｺ菴咲ｽｮ.Y,
+ this.pt陦ｨ遉ｺ蛛ｴ髢句ｧ倶ｽ咲ｽｮ.X, this.pt陦ｨ遉ｺ蛛ｴ髢句ｧ倶ｽ咲ｽｮ.Y,
+ this.pt陦ｨ遉ｺ蛛ｴ邨ゆｺ菴咲ｽｮ.X, this.pt陦ｨ遉ｺ蛛ｴ邨ゆｺ菴咲ｽｮ.Y,
+ this.n遘ｻ蜍墓凾髢田t,
+ CDTX.tZZ(this.nAVI逡ｪ蜿ｷ));
+ }
+ }
+ public class CDirectShow : IDisposable
+ {
+ public FDK.CDirectShow dshow;
+ private bool bDispose貂医∩;
+ public int n逡ｪ蜿ｷ;
+ public string str繧ｳ繝｡繝ｳ繝域枚 = "";
+ public string str繝輔ぃ繧､繝ｫ蜷 = "";
+
+ public void OnDeviceCreated()
+ {
+ #region [ str蜍慕判繝輔ぃ繧､繝ｫ蜷阪ｮ菴懈舌]
+ //-----------------
+ string str蜍慕判繝輔ぃ繧､繝ｫ蜷;
+ if (!string.IsNullOrEmpty(TJAPlayer3.DTX.PATH_WAV))
+ str蜍慕判繝輔ぃ繧､繝ｫ蜷 = TJAPlayer3.DTX.PATH_WAV + this.str繝輔ぃ繧､繝ｫ蜷;
+ else
+ str蜍慕判繝輔ぃ繧､繝ｫ蜷 = TJAPlayer3.DTX.str繝輔か繝ｫ繝蜷 + this.str繝輔ぃ繧､繝ｫ蜷;
+ //-----------------
+ #endregion
+
+ if (!File.Exists(str蜍慕判繝輔ぃ繧､繝ｫ蜷))
+ {
+ Trace.TraceWarning("繝輔ぃ繧､繝ｫ縺悟ｭ伜惠縺励∪縺帙ｓ縲({0})({1})", this.str繧ｳ繝｡繝ｳ繝域枚, str蜍慕判繝輔ぃ繧､繝ｫ蜷);
+ this.dshow = null;
+ }
+
+ // AVI 縺ｮ逕滓舌
+
+ try
+ {
+ this.dshow = new FDK.CDirectShow(TJAPlayer3.stage驕ｸ譖ｲ.r遒ｺ螳壹＆繧後◆繧ｹ繧ｳ繧｢.繝輔ぃ繧､繝ｫ諠蝣ｱ.繝輔か繝ｫ繝縺ｮ邨ｶ蟇ｾ繝代せ + this.str繝輔ぃ繧､繝ｫ蜷, TJAPlayer3.app.WindowHandle, true);
+ Trace.TraceInformation("DirectShow繧堤函謌舌＠縺ｾ縺励◆縲({0})({1})({2}byte)", this.str繧ｳ繝｡繝ｳ繝域枚, str蜍慕判繝輔ぃ繧､繝ｫ蜷, this.dshow.n繝繝ｼ繧ｿ繧ｵ繧､繧ｺbyte);
+ }
+ catch (Exception e)
+ {
+ Trace.TraceError(e.ToString());
+ Trace.TraceError("DirectShow縺ｮ逕滓舌↓螟ｱ謨励＠縺ｾ縺励◆縲({0})({1})", this.str繧ｳ繝｡繝ｳ繝域枚, str蜍慕判繝輔ぃ繧､繝ｫ蜷);
+ this.dshow = null;
+ }
+ }
+ public override string ToString()
+ {
+ return string.Format("CAVI{0}: File:{1}, Comment:{2}", CDTX.tZZ(this.n逡ｪ蜿ｷ), this.str繝輔ぃ繧､繝ｫ蜷, this.str繧ｳ繝｡繝ｳ繝域枚);
+ }
+
+ #region [ IDisposable 螳溯｣ ]
+ //-----------------
+ public void Dispose()
+ {
+ if (this.bDispose貂医∩)
+ return;
+
+ if (this.dshow != null)
+ {
+ #region [ strAVI繝輔ぃ繧､繝ｫ蜷 縺ｮ菴懈舌 ]
+ //-----------------
+ string str蜍慕判繝輔ぃ繧､繝ｫ蜷;
+ if (!string.IsNullOrEmpty(TJAPlayer3.DTX.PATH_WAV))
+ str蜍慕判繝輔ぃ繧､繝ｫ蜷 = TJAPlayer3.DTX.PATH_WAV + this.str繝輔ぃ繧､繝ｫ蜷;
+ else
+ str蜍慕判繝輔ぃ繧､繝ｫ蜷 = TJAPlayer3.DTX.str繝輔か繝ｫ繝蜷 + this.str繝輔ぃ繧､繝ｫ蜷;
+ //-----------------
+ #endregion
+
+ this.dshow.Dispose();
+ this.dshow = null;
+
+ Trace.TraceInformation("蜍慕判繧定ｧ｣謾ｾ縺励∪縺励◆縲({0})({1})", this.str繧ｳ繝｡繝ｳ繝域枚, str蜍慕判繝輔ぃ繧､繝ｫ蜷);
+ }
+
+ this.bDispose貂医∩ = true;
+ }
+ //-----------------
+ #endregion
+ }
+
+ public class CBPM
+ {
+ public double dbBPM蛟､;
+ public double bpm_change_time;
+ public double bpm_change_bmscroll_time;
+ public ECourse bpm_change_course = ECourse.eNormal;
+ public int n蜀驛ｨ逡ｪ蜿ｷ;
+ public int n陦ｨ險倅ｸ翫ｮ逡ｪ蜿ｷ;
+
+ public override string ToString()
+ {
+ StringBuilder builder = new StringBuilder(0x80);
+ if (this.n蜀驛ｨ逡ｪ蜿ｷ != this.n陦ｨ險倅ｸ翫ｮ逡ｪ蜿ｷ)
+ {
+ builder.Append(string.Format("CBPM{0}(蜀驛ｨ{1})", CDTX.tZZ(this.n陦ｨ險倅ｸ翫ｮ逡ｪ蜿ｷ), this.n蜀驛ｨ逡ｪ蜿ｷ));
+ }
+ else
+ {
+ builder.Append(string.Format("CBPM{0}", CDTX.tZZ(this.n陦ｨ險倅ｸ翫ｮ逡ｪ蜿ｷ)));
+ }
+ builder.Append(string.Format(", BPM:{0}", this.dbBPM蛟､));
+ return builder.ToString();
+ }
+ }
+ public class CSCROLL
+ {
+ public double dbSCROLL蛟､;
+ public double dbSCROLL蛟､Y;
+ public int n蜀驛ｨ逡ｪ蜿ｷ;
+ public int n陦ｨ險倅ｸ翫ｮ逡ｪ蜿ｷ;
+
+ public override string ToString()
+ {
+ StringBuilder builder = new StringBuilder(0x80);
+ if (this.n蜀驛ｨ逡ｪ蜿ｷ != this.n陦ｨ險倅ｸ翫ｮ逡ｪ蜿ｷ)
+ {
+ builder.Append(string.Format("CSCROLL{0}(蜀驛ｨ{1})", CDTX.tZZ(this.n陦ｨ險倅ｸ翫ｮ逡ｪ蜿ｷ), this.n蜀驛ｨ逡ｪ蜿ｷ));
+ }
+ else
+ {
+ builder.Append(string.Format("CSCROLL{0}", CDTX.tZZ(this.n陦ｨ險倅ｸ翫ｮ逡ｪ蜿ｷ)));
+ }
+ builder.Append(string.Format(", SCROLL:{0}", this.dbSCROLL蛟､));
+ return builder.ToString();
+ }
+ }
+ ///
+ /// 蛻､螳壹Λ繧､繝ｳ遘ｻ蜍募多莉､
+ ///
+ public class CJPOSSCROLL
+ {
+ public double db遘ｻ蜍墓凾髢;
+ public int n遘ｻ蜍戊ｷ晞屬px;
+ public int n遘ｻ蜍墓婿蜷; //遘ｻ蜍墓婿蜷代ｯ0(蟾ｦ)縲1(蜿ｳ)縺ｮ2縺､縺縺代
+ public int n蜀驛ｨ逡ｪ蜿ｷ;
+ public int n陦ｨ險倅ｸ翫ｮ逡ｪ蜿ｷ;
+
+ public override string ToString()
+ {
+ StringBuilder builder = new StringBuilder(0x80);
+ if (this.n蜀驛ｨ逡ｪ蜿ｷ != this.n陦ｨ險倅ｸ翫ｮ逡ｪ蜿ｷ)
+ {
+ builder.Append(string.Format("CJPOSSCROLL{0}(蜀驛ｨ{1})", CDTX.tZZ(this.n陦ｨ險倅ｸ翫ｮ逡ｪ蜿ｷ), this.n蜀驛ｨ逡ｪ蜿ｷ));
+ }
+ else
+ {
+ builder.Append(string.Format("CJPOSSCROLL{0}", CDTX.tZZ(this.n陦ｨ險倅ｸ翫ｮ逡ｪ蜿ｷ)));
+ }
+ builder.Append(string.Format(", JPOSSCROLL:{0}", this.db遘ｻ蜍墓凾髢));
+ return builder.ToString();
+ }
+ }
+
+ public class CDELAY
+ {
+ public int nDELAY蛟､; //譬ｼ邏肴凾縺ｫ縺ｯms縺ｫ縺ｪ縺｣縺ｦ縺繧九◆繧√‥ouble縺ｫ縺ｯ縺励↑縺縲
+ public int n蜀驛ｨ逡ｪ蜿ｷ;
+ public int n陦ｨ險倅ｸ翫ｮ逡ｪ蜿ｷ;
+ public double delay_time;
+ public double delay_bmscroll_time;
+ public double delay_bpm;
+ public ECourse delay_course = ECourse.eNormal;
+
+ public override string ToString()
+ {
+ StringBuilder builder = new StringBuilder(0x80);
+ if (this.n蜀驛ｨ逡ｪ蜿ｷ != this.n陦ｨ險倅ｸ翫ｮ逡ｪ蜿ｷ)
+ {
+ builder.Append(string.Format("CDELAY{0}(蜀驛ｨ{1})", CDTX.tZZ(this.n陦ｨ險倅ｸ翫ｮ逡ｪ蜿ｷ), this.n蜀驛ｨ逡ｪ蜿ｷ));
+ }
+ else
+ {
+ builder.Append(string.Format("CDELAY{0}", CDTX.tZZ(this.n陦ｨ險倅ｸ翫ｮ逡ｪ蜿ｷ)));
+ }
+ builder.Append(string.Format(", DELAY:{0}", this.nDELAY蛟､));
+ return builder.ToString();
+ }
+ }
+ public enum E蛻蟯千ｨｮ鬘
+ {
+ e邊ｾ蠎ｦ蛻蟯,
+ e騾｣謇灘蟯,
+ e繧ｹ繧ｳ繧｢蛻蟯,
+ e螟ｧ髻ｳ隨ｦ縺ｮ縺ｿ邊ｾ蠎ｦ蛻蟯
+ }
+ public class CBRANCH
+ {
+ public E蛻蟯千ｨｮ鬘 e蛻蟯舌ｮ遞ｮ鬘; //0:邊ｾ蠎ｦ蛻蟯 1:騾｣謇灘蟯 2:繧ｹ繧ｳ繧｢蛻蟯 3:螟ｧ髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ邊ｾ蠎ｦ蛻蟯
+ public double n譚｡莉ｶ謨ｰ蛟､A;
+ public double n譚｡莉ｶ謨ｰ蛟､B;
+ public double db蛻蟯先凾髢;
+ public double db蛻蟯先凾髢杜s;
+ public double db蛻､螳壽凾髢;
+ public double dbBMScrollTime;
+ public double dbBPM;
+ public double dbSCROLL;
+ public int n迴ｾ蝨ｨ縺ｮ蟆冗ｯ;
+ public int n蜻ｽ莉､譎ゅｮChipList逡ｪ蜿ｷ;
+
+ public int n陦ｨ險倅ｸ翫ｮ逡ｪ蜿ｷ;
+ public int n蜀驛ｨ逡ｪ蜿ｷ;
+
+ public override string ToString()
+ {
+ StringBuilder builder = new StringBuilder(0x80);
+ if (this.n蜀驛ｨ逡ｪ蜿ｷ != this.n陦ｨ險倅ｸ翫ｮ逡ｪ蜿ｷ)
+ {
+ builder.Append(string.Format("CBRANCH{0}(蜀驛ｨ{1})", CDTX.tZZ(this.n陦ｨ險倅ｸ翫ｮ逡ｪ蜿ｷ), this.n蜀驛ｨ逡ｪ蜿ｷ));
+ }
+ else
+ {
+ builder.Append(string.Format("CBRANCH{0}", CDTX.tZZ(this.n陦ｨ險倅ｸ翫ｮ逡ｪ蜿ｷ)));
+ }
+ builder.Append(string.Format(", BRANCH:{0}", this.e蛻蟯舌ｮ遞ｮ鬘));
+ return builder.ToString();
+ }
+ }
+
+
+ public class CChip : IComparable, ICloneable
+ {
+ public bool bHit;
+ public bool b蜿ｯ隕 = true;
+ public bool bShow;
+ public bool bShowRoll;
+ public bool bBranch = false;
+ public double db繝√ャ繝励し繧､繧ｺ蛟咲紫 = 1.0;
+ public double db螳滓焚蛟､;
+ public double dbBPM;
+ public float fNow_Measure_s = 4.0f;//蠑ｷ蛻ｶ蛻蟯舌ｮ縺溘ａ縺ｫ霑ｽ蜉.2020.04.21.akasoko26
+ public float fNow_Measure_m = 4.0f;//蠑ｷ蛻ｶ蛻蟯舌ｮ縺溘ａ縺ｫ霑ｽ蜉.2020.04.21.akasoko26
+ public bool IsEndedBranching = false;//蛻蟯舌′邨ゅｏ縺｣縺滓凾縺ｮ騾｣謇楢ｭ憺擇縺碁撼蜿ｯ隕門喧縺ｫ縺ｪ縺｣縺ｦ縺励∪縺縺溘ａ繝輔Λ繧ｰ繧定ｿｽ蜉.2020.04.21.akasoko26
+ public double dbSCROLL;
+ public double dbSCROLL_Y;
+ public ECourse n繧ｳ繝ｼ繧ｹ;
+ public int nSenote;
+ public int nState;
+ public int nRollCount;
+ public int nBalloon;
+ public int nProcessTime;
+ public int n繧ｹ繧ｯ繝ｭ繝ｼ繝ｫ譁ｹ蜷;
+ public int n謠冗判蜆ｪ蜈亥ｺｦ; //(迚ｹ谿)迴ｾ迥ｶ騾｣謇薙→縺ｮ蛻､譁ｭ逶ｮ逧縺ｧ菴ｿ逕ｨ
+ public ENoteState eNoteState;
+ public EAVI遞ｮ蛻･ eAVI遞ｮ蛻･;
+ public E讌ｽ蝎ｨ繝代ｼ繝 e讌ｽ蝎ｨ繝代ｼ繝 = E讌ｽ蝎ｨ繝代ｼ繝.UNKNOWN;
+ public int n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ;
+ public STDGBVALUE n繝舌ｼ縺九ｉ縺ｮ霍晞屬dot;
+ public int n繝舌ｼ縺九ｉ縺ｮ繝弱ｼ繝譛ｫ遶ｯ霍晞屬dot;
+ public int n謨ｴ謨ｰ蛟､;
+ public int n譁蟄玲焚 = 16;
+
+ public int n謨ｴ謨ｰ蛟､_蜀驛ｨ逡ｪ蜿ｷ;
+ public int n邱冗ｧｻ蜍墓凾髢;
+ public int n騾乗主ｺｦ = 0xff;
+ public int n逋ｺ螢ｰ菴咲ｽｮ;
+ public double n譚｡莉ｶ謨ｰ蛟､A;
+ public double n譚｡莉ｶ謨ｰ蛟､B;
+ public double db蛻蟯先凾髢薙ｮ繧ｺ繝ｬ;
+ public E蛻蟯千ｨｮ鬘 e蛻蟯舌ｮ遞ｮ鬘;
+
+ public double db逋ｺ螢ｰ菴咲ｽｮ; // 逋ｺ螢ｰ譎ょ綾繧呈ｼ邏阪＠縺ｦ縺縺溷､画焚縺ｮ縺縺｡縺ｮｼ代▽繧断loat蝙九°繧嬰ouble蝙九↓螟画峩縲(kairera0467)
+ public double fBMSCROLLTime;
+ public double fBMSCROLLTime_end;
+ public int n逋ｺ螢ｰ譎ょ綾ms;
+ public double n蛻蟯先凾蛻ｻms;
+
+
+ public double db逋ｺ螢ｰ譎ょ綾ms;
+ public int n繝弱ｼ繝邨ゆｺ菴咲ｽｮ;
+ public int n繝弱ｼ繝邨ゆｺ譎ょ綾ms;
+ public int n繝弱ｼ繝蜃ｺ迴ｾ譎ょ綾ms;
+ public int n繝弱ｼ繝遘ｻ蜍暮幕蟋区凾蛻ｻms;
+ public int n蛻蟯仙屓謨ｰ;
+ public int n騾｣謇馴浹隨ｦState;
+ public int nLag; // 2011.2.1 yyagi
+ public CDTX.CAVI rAVI;
+ public CDTX.CAVIPAN rAVIPan;
+ public CDTX.CDirectShow rDShow;
+ public double db逋ｺ螢ｰ譎ょ綾;
+ public double db蛻､螳夂ｵゆｺ譎ょ綾;//騾｣謇鍋ｳｻ髻ｳ隨ｦ縺ｧ菴ｿ逕ｨ
+ public double dbProcess_Time;
+ public int nPlayerSide;
+ public bool bGOGOTIME = false; //2018.03.11 k1airera0467 繧ｴ繝ｼ繧ｴ繝ｼ繧ｿ繧､繝蜀縺ｮ繝√ャ繝励〒縺ゅｋ縺
+ public int nList荳翫ｮ菴咲ｽｮ;
+ public bool IsFixedSENote;
+ public bool IsHitted = false;
+ public bool IsMissed = false;
+
+ public bool bBPM繝√ャ繝励〒縺ゅｋ
+ {
+ get
+ {
+ if (this.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 3 || this.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 8)
+ {
+ return true;
+ }
+ else
+ {
+ return false;
+ }
+ }
+ }
+ public bool b閾ｪ蜍募咲函髻ｳ繝√Ε繝ｳ繝阪Ν縺ｧ縺ゅｋ
+ {
+ get
+ {
+ int num = this.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ;
+ if ((((num != 1) && ((0x61 > num) || (num > 0x69))) && ((0x70 > num) || (num > 0x79))) && ((0x80 > num) || (num > 0x89)))
+ {
+ return ((0x90 <= num) && (num <= 0x92));
+ }
+ return true;
+ }
+ }
+
+
+
+ public bool b貍泌･冗ｵゆｺ蠕後ｂ蜀咲函縺檎ｶ壹￥繝√ャ繝励〒縺ゅｋ; // #32248 2013.10.14 yyagi
+ public CCounter RollDelay; // 18.9.22 AioiLight Add 騾｣謇捺凾縺ｫ襍､縺上↑繧九ｄ縺､縺ｮ繧ｿ繧､繝槭ｼ
+ public CCounter RollInputTime; // 18.9.22 AioiLight Add 騾｣謇灘･蜉帛ｾ後ヽollDelay縺御ｽ懷虚縺吶ｋ縺ｾ縺ｧ縺ｮ繧ｿ繧､繝槭ｼ
+ public int RollEffectLevel; // 18.9.22 AioiLight Add 騾｣謇捺凾縺ｫ襍､縺上↑繧九ｄ縺､縺ｮ蠎ｦ蜷医＞
+
+ public CChip()
+ {
+ this.n繝舌ｼ縺九ｉ縺ｮ霍晞屬dot = new STDGBVALUE()
+ {
+ Drums = 0,
+ Guitar = 0,
+ Bass = 0,
+ Taiko = 0
+ };
+ }
+ public void t蛻晄悄蛹()
+ {
+ this.bBranch = false;
+ this.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ = 0;
+ this.n謨ｴ謨ｰ蛟､ = 0; //謨ｴ謨ｰ蛟､繧鱈ist荳翫ｮ逡ｪ蜿ｷ縺ｨ縺励※逕ｨ縺繧九
+ this.n謨ｴ謨ｰ蛟､_蜀驛ｨ逡ｪ蜿ｷ = 0;
+ this.db螳滓焚蛟､ = 0.0;
+ this.n逋ｺ螢ｰ菴咲ｽｮ = 0;
+ this.db逋ｺ螢ｰ菴咲ｽｮ = 0.0D;
+ this.n逋ｺ螢ｰ譎ょ綾ms = 0;
+ this.db逋ｺ螢ｰ譎ょ綾ms = 0.0D;
+ this.fBMSCROLLTime = 0;
+ this.n繝弱ｼ繝邨ゆｺ菴咲ｽｮ = 0;
+ this.n繝弱ｼ繝邨ゆｺ譎ょ綾ms = 0;
+ this.n謠冗判蜆ｪ蜈亥ｺｦ = 0;
+ this.nLag = -999;
+ this.b貍泌･冗ｵゆｺ蠕後ｂ蜀咲函縺檎ｶ壹￥繝√ャ繝励〒縺ゅｋ = false;
+ this.nList荳翫ｮ菴咲ｽｮ = 0;
+ this.db繝√ャ繝励し繧､繧ｺ蛟咲紫 = 1.0;
+ this.bHit = false;
+ this.IsMissed = false;
+ this.b蜿ｯ隕 = true;
+ this.e讌ｽ蝎ｨ繝代ｼ繝 = E讌ｽ蝎ｨ繝代ｼ繝.UNKNOWN;
+ this.n騾乗主ｺｦ = 0xff;
+ this.n繝舌ｼ縺九ｉ縺ｮ霍晞屬dot.Drums = 0;
+ this.n繝舌ｼ縺九ｉ縺ｮ霍晞屬dot.Guitar = 0;
+ this.n繝舌ｼ縺九ｉ縺ｮ霍晞屬dot.Bass = 0;
+ this.n繝舌ｼ縺九ｉ縺ｮ霍晞屬dot.Taiko = 0;
+ this.n繝舌ｼ縺九ｉ縺ｮ繝弱ｼ繝譛ｫ遶ｯ霍晞屬dot = 0;
+ this.n邱冗ｧｻ蜍墓凾髢 = 0;
+ this.dbBPM = 120.0;
+ this.fNow_Measure_m = 4.0f;
+ this.fNow_Measure_s = 4.0f;
+ this.n繧ｹ繧ｯ繝ｭ繝ｼ繝ｫ譁ｹ蜷 = 0;
+ this.dbSCROLL = 1.0;
+ this.dbSCROLL_Y = 0.0f;
+ }
+ public override string ToString()
+ {
+
+ //2016.10.07 kairera0467 霑第律荳ｭ縺ｫ蜀咲ｷｨ謌蝉ｺ亥ｮ
+ string[] chToStr =
+ {
+ //繧ｷ繧ｹ繝繝
+ "??", "繝舌ャ繧ｯ繧ｳ繝ｼ繝ｩ繧ｹ", "蟆冗ｯ髟ｷ螟画峩", "BPM螟画峩", "??", "??", "??", "??",
+ "BPM螟画峩(諡｡蠑ｵ)", "??", "??", "??", "??", "??", "??", "??",
+
+ //螟ｪ鮠1P(遘ｻ蜍穂ｺ亥ｮ)
+ "??", "繝峨Φ", "繧ｫ繝", "繝峨Φ(螟ｧ)", "繧ｫ繝(螟ｧ)", "騾｣謇", "騾｣謇(螟ｧ)", "縺ｵ縺縺帙ｓ騾｣謇",
+ "騾｣謇鍋ｵらせ", "闃", "繝峨Φ(謇)", "繧ｫ繝(謇)", "??", "??", "??", "AD-LIB",
+
+ //螟ｪ鮠謎ｺ亥ｙ
+ "??", "??", "??", "??", "??", "??", "??", "??",
+ "??", "??", "??", "??", "??", "??", "??", "??",
+
+ //螟ｪ鮠謎ｺ亥ｙ
+ "??", "??", "??", "??", "??", "??", "??", "??",
+ "??", "??", "??", "??", "??", "??", "??", "??",
+
+ //螟ｪ鮠謎ｺ亥ｙ
+ "??", "??", "??", "??", "??", "??", "??", "??",
+ "??", "??", "??", "??", "??", "??", "??", "??",
+
+ //繧ｷ繧ｹ繝繝
+ "蟆冗ｯ邱", "諡咲ｷ", "??", "??", "AVI", "??", "??", "??",
+ "??", "??", "??", "??", "??", "??", "??", "??",
+
+ //繧ｷ繧ｹ繝繝(遘ｻ蜍穂ｺ亥ｮ)
+ "SCROLL", "DELAY", "繧ｴ繝ｼ繧ｴ繝ｼ繧ｿ繧､繝髢句ｧ", "繧ｴ繝ｼ繧ｴ繝ｼ繧ｿ繧､繝邨ゆｺ", "??", "??", "??", "??",
+ "??", "??", "??", "??", "??", "??", "??", "??",
+
+ "??", "??", "??", "??", "??", "??", "??", "??",
+ "??", "??", "??", "??", "??", "??", "??", "??",
+
+ "??", "??", "??", "??", "??", "??", "??", "??",
+ "??", "??", "??", "??", "??", "??", "??", "??",
+
+ //螟ｪ鮠1P縲√す繧ｹ繝繝(迴ｾ陦)
+ "??", "??", "??", "螟ｪ鮠点襍､", "螟ｪ鮠点髱", "螟ｪ鮠点襍､(螟ｧ)", "螟ｪ鮠点髱(螟ｧ)", "螟ｪ鮠点鮟",
+ "螟ｪ鮠点鮟(螟ｧ)", "螟ｪ鮠点鬚ｨ闊ｹ", "螟ｪ鮠点騾｣謇捺忰遶ｯ", "螟ｪ鮠点闃", "??", "SCROLL", "繧ｴ繝ｼ繧ｴ繝ｼ繧ｿ繧､繝髢句ｧ", "繧ｴ繝ｼ繧ｴ繝ｼ繧ｿ繧､繝邨ゆｺ",
+
+ "??", "??", "??", "??", "??", "??", "??", "??",
+ "??", "??", "??", "??", "??", "??", "??", "螟ｪ鮠 AD-LIB",
+
+ "??", "??", "??", "??", "??", "??", "??", "??",
+ "??", "??", "??", "??", "??", "??", "??", "??",
+
+ "??", "??", "??", "??", "0xC4", "0xC5", "0xC6", "??",
+ "??", "??", "0xCA", "??", "??", "??", "??", "0xCF",
+
+ //繧ｷ繧ｹ繝繝(迴ｾ陦)
+ "0xD0", "??", "??", "??", "??", "??", "??", "??",
+ "??", "??", "繝溘く繧ｵ繝ｼ霑ｽ蜉", "繝溘く繧ｵ繝ｼ蜑企勁", "DELAY", "隴憺擇蛻蟯舌Μ繧ｻ繝繝", "隴憺擇蛻蟯舌い繝九Γ", "隴憺擇蛻蟯仙驛ｨ蜃ｦ逅",
+
+ //繧ｷ繧ｹ繝繝(迴ｾ陦)
+ "蟆冗ｯ邱唹N/OFF", "蛻蟯仙崋螳", "蛻､螳壽棧遘ｻ蜍", "", "", "", "", "",
+ "", "", "", "", "", "", "", "",
+
+ "0xF0", "豁瑚ｩ", "??", "SUDDEN", "??", "??", "??", "??",
+ "??", "??", "??", "??", "??", "??", "??", "??", "隴憺擇邨ゆｺ"
+ };
+ return string.Format("CChip: 菴咲ｽｮ:{0:D4}.{1:D3}, 譎ょ綾{2:D6}, Ch:{3:X2}({4}), Pn:{5}({11})(蜀驛ｨ{6}), Pd:{7}, Sz:{8}, BMScroll:{9}, Auto:{10}, 繧ｳ繝ｼ繧ｹ:{11}",
+ this.n逋ｺ螢ｰ菴咲ｽｮ / 384, this.n逋ｺ螢ｰ菴咲ｽｮ % 384,
+ this.n逋ｺ螢ｰ譎ょ綾ms,
+ this.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ, chToStr[this.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ],
+ this.n謨ｴ謨ｰ蛟､, this.n謨ｴ謨ｰ蛟､_蜀驛ｨ逡ｪ蜿ｷ,
+ this.db螳滓焚蛟､,
+ this.db繝√ャ繝励し繧､繧ｺ蛟咲紫,
+ this.fBMSCROLLTime,
+ this.b閾ｪ蜍募咲函髻ｳ繝√Ε繝ｳ繝阪Ν縺ｧ縺ゅｋ,
+ this.n繧ｳ繝ｼ繧ｹ,
+ CDTX.tZZ(this.n謨ｴ謨ｰ蛟､));
+ }
+ ///
+ /// 繝√ャ繝励ｮ蜀咲函髟ｷ繧貞叙蠕励☆繧九ら樟迥ｶ縲仝AV繝√ャ繝励→BGA繝√ャ繝励〒縺ｮ縺ｿ菴ｿ逕ｨ蜿ｯ閭ｽ縲
+ ///
+ /// 蜀咲函髟ｷ(ms)
+ public int GetDuration()
+ {
+ int nDuration = 0;
+
+ if (this.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x01) // WAV
+ {
+ CDTX.CWAV wc;
+ TJAPlayer3.DTX.listWAV.TryGetValue(this.n謨ｴ謨ｰ蛟､_蜀驛ｨ逡ｪ蜿ｷ, out wc);
+ if (wc == null)
+ {
+ nDuration = 0;
+ }
+ else
+ {
+ nDuration = (wc.rSound[0] == null) ? 0 : wc.rSound[0].n邱乗ｼ泌･乗凾髢杜s;
+ }
+ }
+ else if (this.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x54) // AVI
+ {
+ if (this.rAVI != null && this.rAVI.avi != null)
+ {
+ int dwRate = (int)this.rAVI.avi.dw繝ｬ繝ｼ繝;
+ int dwScale = (int)this.rAVI.avi.dw繧ｹ繧ｱ繝ｼ繝ｫ;
+ nDuration = (int)(1000.0f * dwScale / dwRate * this.rAVI.avi.GetMaxFrameCount());
+ }
+ }
+
+ double _db蜀咲函騾溷ｺｦ = (TJAPlayer3.DTXVmode.Enabled) ? TJAPlayer3.DTX.dbDTXVPlaySpeed : TJAPlayer3.DTX.db蜀咲函騾溷ｺｦ;
+ return (int)(nDuration / _db蜀咲函騾溷ｺｦ);
+ }
+
+ #region [ IComparable 螳溯｣ ]
+ //-----------------
+
+ private static readonly byte[] n蜆ｪ蜈亥ｺｦ = new byte[] {
+ 5, 5, 3, 7, 5, 5, 5, 5, 3, 5, 5, 5, 5, 5, 5, 5, //0x00
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, //0x10
+ 7, 7, 7, 7, 7, 7, 7, 7, 5, 5, 5, 5, 5, 5, 5, 5, //0x20
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, //0x30
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, //0x40
+ 9, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, //0x50
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, //0x60
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, //0x70
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, //0x80
+ 5, 5, 5, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 9, 9, 9, //0x90
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, //0xA0
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, //0xB0
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, //0xC0
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 3, 4, 4, //0xD0
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, //0xE0
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, //0xF0
+ };
+
+ public int CompareTo(CDTX.CChip other)
+ {
+ // 縺ｾ縺壹ｯ菴咲ｽｮ縺ｧ豈碑ｼ縲
+
+ //BGM繝√ャ繝励□縺醍匱螢ｰ菴咲ｽｮ
+ //if( this.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x01 || this.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x02 )
+ //{
+ // if( this.n逋ｺ螢ｰ菴咲ｽｮ < other.n逋ｺ螢ｰ菴咲ｽｮ )
+ // return -1;
+
+ // if( this.n逋ｺ螢ｰ菴咲ｽｮ > other.n逋ｺ螢ｰ菴咲ｽｮ )
+ // return 1;
+ //}
+
+ //if( this.n逋ｺ螢ｰ菴咲ｽｮ < other.n逋ｺ螢ｰ菴咲ｽｮ )
+ // return -1;
+
+ //if( this.n逋ｺ螢ｰ菴咲ｽｮ > other.n逋ｺ螢ｰ菴咲ｽｮ )
+ // return 1;
+
+ //隴憺擇隗｣譫舌Γ繧ｽ繝繝鰻4縺ｧ縺ｯ逋ｺ螢ｰ譎ょ綾ms縺ｧ豈碑ｼ縺吶ｋ縲
+ var n逋ｺ螢ｰ譎ょ綾msCompareToResult = 0;
+ n逋ｺ螢ｰ譎ょ綾msCompareToResult = this.n逋ｺ螢ｰ譎ょ綾ms.CompareTo(other.n逋ｺ螢ｰ譎ょ綾ms);
+ if (n逋ｺ螢ｰ譎ょ綾msCompareToResult != 0)
+ {
+ return n逋ｺ螢ｰ譎ょ綾msCompareToResult;
+ }
+
+ n逋ｺ螢ｰ譎ょ綾msCompareToResult = this.db逋ｺ螢ｰ譎ょ綾ms.CompareTo(other.db逋ｺ螢ｰ譎ょ綾ms);
+ if (n逋ｺ螢ｰ譎ょ綾msCompareToResult != 0)
+ {
+ return n逋ｺ螢ｰ譎ょ綾msCompareToResult;
+ }
+
+ // 菴咲ｽｮ縺悟酔縺倥↑繧牙━蜈亥ｺｦ縺ｧ豈碑ｼ縲
+ return n蜆ｪ蜈亥ｺｦ[this.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ].CompareTo(n蜆ｪ蜈亥ｺｦ[other.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ]);
+ }
+ //-----------------
+ #endregion
+ ///
+ /// shallow copy縺ｧ縺吶
+ ///
+ ///
+ public object Clone()
+ {
+ return MemberwiseClone();
+ }
+ }
+ public class CWAV : IDisposable
+ {
+ public bool bBGM縺ｨ縺励※菴ｿ縺;
+ public List list縺薙ｮWAV繧剃ｽｿ逕ｨ縺吶ｋ繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ縺ｮ髮蜷 = new List(16);
+ public int n繝√ャ繝励し繧､繧ｺ = 100;
+ public int n菴咲ｽｮ;
+ public long[] n荳譎ょ●豁｢譎ょ綾 = new long[TJAPlayer3.ConfigIni.nPoliphonicSounds]; // 4
+ public int SongVol = CSound.DefaultSongVol;
+ public LoudnessMetadata? SongLoudnessMetadata = null;
+ public int n迴ｾ蝨ｨ蜀咲函荳ｭ縺ｮ繧ｵ繧ｦ繝ｳ繝臥分蜿ｷ;
+ public long[] n蜀咲函髢句ｧ区凾蛻ｻ = new long[TJAPlayer3.ConfigIni.nPoliphonicSounds]; // 4
+ public int n蜀驛ｨ逡ｪ蜿ｷ;
+ public int n陦ｨ險倅ｸ翫ｮ逡ｪ蜿ｷ;
+ public CSound[] rSound = new CSound[TJAPlayer3.ConfigIni.nPoliphonicSounds]; // 4
+ public string str繧ｳ繝｡繝ｳ繝域枚 = "";
+ public string str繝輔ぃ繧､繝ｫ蜷 = "";
+ public bool bBGM縺ｨ縺励※菴ｿ繧上↑縺
+ {
+ get
+ {
+ return !this.bBGM縺ｨ縺励※菴ｿ縺;
+ }
+ set
+ {
+ this.bBGM縺ｨ縺励※菴ｿ縺 = !value;
+ }
+ }
+ public bool bIsBassSound = false;
+ public bool bIsGuitarSound = false;
+ public bool bIsDrumsSound = false;
+ public bool bIsSESound = false;
+ public bool bIsBGMSound = false;
+
+ public override string ToString()
+ {
+ var sb = new StringBuilder(128);
+
+ if (this.n陦ｨ險倅ｸ翫ｮ逡ｪ蜿ｷ == this.n蜀驛ｨ逡ｪ蜿ｷ)
+ {
+ sb.Append(string.Format("CWAV{0}: ", CDTX.tZZ(this.n陦ｨ險倅ｸ翫ｮ逡ｪ蜿ｷ)));
+ }
+ else
+ {
+ sb.Append(string.Format("CWAV{0}(蜀驛ｨ{1}): ", CDTX.tZZ(this.n陦ｨ險倅ｸ翫ｮ逡ｪ蜿ｷ), this.n蜀驛ｨ逡ｪ蜿ｷ));
+ }
+ sb.Append(
+ $"{nameof(SongVol)}:{this.SongVol}, {nameof(LoudnessMetadata.Integrated)}:{this.SongLoudnessMetadata?.Integrated}, {nameof(LoudnessMetadata.TruePeak)}:{this.SongLoudnessMetadata?.TruePeak}, 菴咲ｽｮ:{this.n菴咲ｽｮ}, 繧ｵ繧､繧ｺ:{this.n繝√ャ繝励し繧､繧ｺ}, BGM:{(this.bBGM縺ｨ縺励※菴ｿ縺 ? 'Y' : 'N')}, File:{this.str繝輔ぃ繧､繝ｫ蜷閤, Comment:{this.str繧ｳ繝｡繝ｳ繝域枚}");
+
+ return sb.ToString();
+ }
+
+ #region [ Dispose-Finalize 繝代ち繝ｼ繝ｳ螳溯｣ ]
+ //-----------------
+ public void Dispose()
+ {
+ this.Dispose(true);
+ GC.SuppressFinalize(this);
+ }
+ public void Dispose(bool bManaged繝ｪ繧ｽ繝ｼ繧ｹ縺ｮ隗｣謾ｾ繧り｡後≧)
+ {
+ if (this.bDisposed貂医∩)
+ return;
+
+ if (bManaged繝ｪ繧ｽ繝ｼ繧ｹ縺ｮ隗｣謾ｾ繧り｡後≧)
+ {
+ for (int i = 0; i < TJAPlayer3.ConfigIni.nPoliphonicSounds; i++) // 4
+ {
+ if (this.rSound[i] != null)
+ TJAPlayer3.Sound邂｡逅.t繧ｵ繧ｦ繝ｳ繝峨ｒ遐ｴ譽縺吶ｋ(this.rSound[i]);
+ this.rSound[i] = null;
+
+ if ((i == 0) && TJAPlayer3.ConfigIni.bLog菴懈占ｧ｣謾ｾ繝ｭ繧ｰ蜃ｺ蜉)
+ Trace.TraceInformation("繧ｵ繧ｦ繝ｳ繝峨ｒ隗｣謾ｾ縺励∪縺励◆縲({0})({1})", this.str繧ｳ繝｡繝ｳ繝域枚, this.str繝輔ぃ繧､繝ｫ蜷);
+ }
+ }
+
+ this.bDisposed貂医∩ = true;
+ }
+ ~CWAV()
+ {
+ this.Dispose(false);
+ }
+ //-----------------
+ #endregion
+
+ #region [ private ]
+ //-----------------
+ private bool bDisposed貂医∩;
+ //-----------------
+ #endregion
+ }
+
+ public class DanSongs
+ {
+ public CTexture TitleTex;
+ public CTexture SubTitleTex;
+ public string Title;
+ public string SubTitle;
+ public string FileName;
+ public string Genre;
+ public int ScoreInit;
+ public int ScoreDiff;
+ public int Level;
+ public int Difficulty;
+ public static int Number = 0;
+ public bool bTitleShow;
+ public Dan_C[] Dan_C = new Dan_C[4];
+ public CWAV Wave;
+
+ public DanSongs()
+ {
+ Number++;
+ }
+ }
+
+ public struct STLYRIC
+ {
+ public long Time;
+ public Bitmap TextTex;
+ public string Text;
+ public int index;
+ }
+
+
+ // 讒矩菴
+
+ public struct STLANEINT
+ {
+ public int HH;
+ public int SD;
+ public int BD;
+ public int HT;
+ public int LT;
+ public int CY;
+ public int FT;
+ public int HHO;
+ public int RD;
+ public int LC;
+ public int LP;
+ public int LBD;
+
+ public int Drums
+ {
+ get
+ {
+ return this.HH + this.SD + this.BD + this.HT + this.LT + this.CY + this.FT + this.HHO + this.RD + this.LC + this.LP + this.LBD;
+ }
+ }
+ public int Guitar;
+ public int Bass;
+ public int Taiko_Red;
+ public int Taiko_Blue;
+
+ public int this[int index]
+ {
+ get
+ {
+ switch (index)
+ {
+ case 0:
+ return this.HH;
+
+ case 1:
+ return this.SD;
+
+ case 2:
+ return this.BD;
+
+ case 3:
+ return this.HT;
+
+ case 4:
+ return this.LT;
+
+ case 5:
+ return this.CY;
+
+ case 6:
+ return this.FT;
+
+ case 7:
+ return this.HHO;
+
+ case 8:
+ return this.RD;
+
+ case 9:
+ return this.LC;
+
+ case 10:
+ return this.LP;
+
+ case 11:
+ return this.LBD;
+
+ case 12:
+ return this.Guitar;
+
+ case 13:
+ return this.Bass;
+
+ case 14:
+ return this.Taiko_Red;
+
+ case 15:
+ return this.Taiko_Blue;
+ }
+ throw new IndexOutOfRangeException();
+ }
+ set
+ {
+ if (value < 0)
+ {
+ throw new ArgumentOutOfRangeException();
+ }
+ switch (index)
+ {
+ case 0:
+ this.HH = value;
+ return;
+
+ case 1:
+ this.SD = value;
+ return;
+
+ case 2:
+ this.BD = value;
+ return;
+
+ case 3:
+ this.HT = value;
+ return;
+
+ case 4:
+ this.LT = value;
+ return;
+
+ case 5:
+ this.CY = value;
+ return;
+
+ case 6:
+ this.FT = value;
+ return;
+
+ case 7:
+ this.HHO = value;
+ return;
+
+ case 8:
+ this.RD = value;
+ return;
+
+ case 9:
+ this.LC = value;
+ return;
+
+ case 10:
+ this.LP = value;
+ return;
+
+ case 11:
+ this.LBD = value;
+ return;
+
+ case 12:
+ this.Guitar = value;
+ return;
+
+ case 13:
+ this.Bass = value;
+ return;
+
+ case 14:
+ this.Taiko_Red = value;
+ return;
+
+ case 15:
+ this.Taiko_Blue = value;
+ return;
+ }
+ throw new IndexOutOfRangeException();
+ }
+ }
+ }
+ public struct STRESULT
+ {
+ public string SS;
+ public string S;
+ public string A;
+ public string B;
+ public string C;
+ public string D;
+ public string E;
+
+ public string this[int index]
+ {
+ get
+ {
+ switch (index)
+ {
+ case 0:
+ return this.SS;
+
+ case 1:
+ return this.S;
+
+ case 2:
+ return this.A;
+
+ case 3:
+ return this.B;
+
+ case 4:
+ return this.C;
+
+ case 5:
+ return this.D;
+
+ case 6:
+ return this.E;
+ }
+ throw new IndexOutOfRangeException();
+ }
+ set
+ {
+ switch (index)
+ {
+ case 0:
+ this.SS = value;
+ return;
+
+ case 1:
+ this.S = value;
+ return;
+
+ case 2:
+ this.A = value;
+ return;
+
+ case 3:
+ this.B = value;
+ return;
+
+ case 4:
+ this.C = value;
+ return;
+
+ case 5:
+ this.D = value;
+ return;
+
+ case 6:
+ this.E = value;
+ return;
+ }
+ throw new IndexOutOfRangeException();
+ }
+ }
+ }
+ public struct ST繝√ャ繝励′縺ゅｋ
+ {
+ public bool Drums;
+ public bool Guitar;
+ public bool Bass;
+
+ public bool HHOpen;
+ public bool Ride;
+ public bool LeftCymbal;
+ public bool OpenGuitar;
+ public bool OpenBass;
+
+ public bool Branch;
+
+ public bool this[int index]
+ {
+ get
+ {
+ switch (index)
+ {
+ case 0:
+ return this.Drums;
+
+ case 1:
+ return this.Guitar;
+
+ case 2:
+ return this.Bass;
+
+ case 3:
+ return this.HHOpen;
+
+ case 4:
+ return this.Ride;
+
+ case 5:
+ return this.LeftCymbal;
+
+ case 6:
+ return this.OpenGuitar;
+
+ case 7:
+ return this.OpenBass;
+
+ case 8:
+ return this.Branch;
+ }
+ throw new IndexOutOfRangeException();
+ }
+ set
+ {
+ switch (index)
+ {
+ case 0:
+ this.Drums = value;
+ return;
+
+ case 1:
+ this.Guitar = value;
+ return;
+
+ case 2:
+ this.Bass = value;
+ return;
+
+ case 3:
+ this.HHOpen = value;
+ return;
+
+ case 4:
+ this.Ride = value;
+ return;
+
+ case 5:
+ this.LeftCymbal = value;
+ return;
+
+ case 6:
+ this.OpenGuitar = value;
+ return;
+
+ case 7:
+ this.OpenBass = value;
+ return;
+
+ case 8:
+ this.Branch = value;
+ return;
+ }
+ throw new IndexOutOfRangeException();
+ }
+ }
+ }
+ public enum ECourse
+ {
+ eNormal,
+ eExpert,
+ eMaster
+ }
+ public class CLine
+ {
+ public int n蟆冗ｯ逡ｪ蜿ｷ;
+ public int n譁蟄玲焚;
+ public double db逋ｺ螢ｰ譎ょ綾;
+ public double dbBMS譎ょ綾;
+ public ECourse n繧ｳ繝ｼ繧ｹ = ECourse.eNormal;
+ public int n繧ｿ繧､繝;
+ }
+
+ // 繝励Ο繝代ユ繧｣
+
+
+ public class CBranchStartInfo
+ {
+ public int nMeasureCount;
+ public double dbTime;
+ public double dbBPM;
+ public double dbSCROLL;
+ public double dbSCROLLY;
+ public double dbBMScollTime;
+ public double db遘ｻ蜍募ｾ讖滓凾蛻ｻ;
+ public double db蜃ｺ迴ｾ譎ょ綾;
+ public double db蜀咲函騾溷ｺｦ;
+ public float fMeasure_s;
+ public float fMeasure_m;
+ }
+
+ ///
+ /// 蛻蟯宣幕蟋区凾縺ｮ諠蝣ｱ繧定ｨ倬鹸縺吶ｋ縺溘ａ縺ｮ縺ゅｌ 2020.04.21
+ ///
+ public CBranchStartInfo cBranchStart = new CBranchStartInfo();
+
+ public int nBGMAdjust
+ {
+ get;
+ private set;
+ }
+ public bool b蛻蟯舌ｒ荳蝗槭〒繧る幕蟋九＠縺 = false; //2020.04.22 akasoko26 蛻蟯占ｭ憺擇縺ｮ縺ｿ蛟､繧剃ｻ｣蜈･縺吶ｋ繧医≧縺ｫ縲
+
+ public int nPlayerSide; //2017.08.14 kairera0467 蠑墓焚縺ｧ謖螳壹☆繧
+ public bool bSession隴憺擇繧定ｪｭ縺ｿ霎ｼ繧;
+ public string ARTIST;
+ public string BACKGROUND;
+ public string BACKGROUND_GR;
+ public double BASEBPM;
+ public double BPM;
+ public ST繝√ャ繝励′縺ゅｋ b繝√ャ繝励′縺ゅｋ;
+ public string COMMENT;
+ public double db蜀咲函騾溷ｺｦ;
+ public string GENRE;
+ public E繧ｸ繝｣繝ｳ繝ｫ e繧ｸ繝｣繝ｳ繝ｫ;
+ public bool HIDDENLEVEL;
+ public STDGBVALUE LEVEL;
+ public bool bLyrics;
+ public int[] LEVELtaiko = new int[(int)Difficulty.Total] { -1, -1, -1, -1, -1, -1, -1 };
+ public Dictionary listAVI;
+ public Dictionary listAVIPAN;
+ public Dictionary listDS;
+ public Dictionary listBPM;
+ public List listChip;
+ public List[] listChip_Branch;
+ public Dictionary listWAV;
+ public Dictionary listSCROLL;
+ public Dictionary listSCROLL_Normal;
+ public Dictionary listSCROLL_Expert;
+ public Dictionary listSCROLL_Master;
+ public Dictionary listJPOSSCROLL;
+ public List List_DanSongs;
+
+
+ private double[] dbNowSCROLL_Normal;
+ private double[] dbNowSCROLL_Expert;
+ private double[] dbNowSCROLL_Master;
+
+
+ public Dictionary listDELAY;
+ public Dictionary listBRANCH;
+ public STLANEINT n蜿ｯ隕悶メ繝繝玲焚;
+ public const int n譛螟ｧ髻ｳ謨ｰ = 4;
+ public const int n蟆冗ｯ縺ｮ隗｣蜒丞ｺｦ = 384;
+ public string PANEL;
+ public string PATH_WAV;
+ public string PREIMAGE;
+ public string PREVIEW;
+ public string str繝上ャ繧ｷ繝･ofDTX繝輔ぃ繧､繝ｫ;
+ public string str繝輔ぃ繧､繝ｫ蜷;
+ public string str繝輔ぃ繧､繝ｫ蜷阪ｮ邨ｶ蟇ｾ繝代せ;
+ public string str繝輔か繝ｫ繝蜷;
+ public string SUBTITLE;
+ public string TITLE;
+ public double dbDTXVPlaySpeed;
+ public double dbScrollSpeed;
+ public int n繝繝｢BGM繧ｪ繝輔そ繝繝;
+
+ private int n迴ｾ蝨ｨ縺ｮ蟆冗ｯ謨ｰ = 1;
+
+ private int nNowRoll = 0;
+ private int nNowRollCount = 0;
+
+ private int[] n騾｣謇薙メ繝繝誉temp = new int[3];
+ public int nOFFSET = 0;
+ private bool bOFFSET縺ｮ蛟､縺後槭う繝翫せ縺ｧ縺ゅｋ = false;
+ private int nMOVIEOFFSET = 0;
+ private bool bMOVIEOFFSET縺ｮ蛟､縺後槭う繝翫せ縺ｧ縺ゅｋ = false;
+ private double dbNowBPM = 120.0;
+ private int nDELAY = 0;
+ public bool[] bHasBranch = new bool[(int)Difficulty.Total] { false, false, false, false, false, false, false };
+
+ //蛻蟯宣未騾｣
+ private ECourse n迴ｾ蝨ｨ縺ｮ繧ｳ繝ｼ繧ｹ = ECourse.eNormal;
+
+ private bool b譛蛻昴ｮ蛻蟯舌〒縺ゅｋ;
+ public int[] n繝弱ｼ繝謨ｰ = new int[4]; //3:蜈ｱ騾
+ public int[] nDan_NotesCount = new int[1];
+ public int[] n繝弱ｼ繝謨ｰ_Branch = new int[4]; //
+ public CChip[] pDan_LastChip;
+ public int[] n鬚ｨ闊ｹ謨ｰ = new int[4]; //0ｽ2:蜷繧ｳ繝ｼ繧ｹ 3:蜈ｱ騾
+
+ private List listLine;
+ private int nLineCountTemp; //蛻蟯宣幕蟋区凾縺ｮ蟆冗ｯ謨ｰ繧定ｨ倬鹸縲
+ private ECourse nLineCountCourseTemp = ECourse.eNormal; //迴ｾ蝨ｨ繧ｫ繧ｦ繝ｳ繝井ｸｭ縺ｮ繧ｳ繝ｼ繧ｹ繧定ｨ倬鹸縲
+
+ public int n蜿らｧ荳ｭ縺ｮ髮｣譏灘ｺｦ = 3;
+ public int nScoreModeTmp = 99; //2017.01.28 DD
+ public int[,] nScoreInit = new int[2, (int)Difficulty.Total]; //[ x, y ] x=騾壼ｸｸor逵滓遠 y=繧ｳ繝ｼ繧ｹ
+ public int[] nScoreDiff = new int[(int)Difficulty.Total]; //[y]
+ public bool[,] b驟咲せ縺梧欠螳壹＆繧後※縺繧 = new bool[3, (int)Difficulty.Total]; //2017.06.04 kairera0467 [ x, y ] x=騾壼ｸｸ(Init)or逵滓遠orDiff y=繧ｳ繝ｼ繧ｹ
+
+ private double dbBarLength;
+ public float fNow_Measure_s = 4.0f;
+ public float fNow_Measure_m = 4.0f;
+ public double dbNowTime = 0.0;
+ public double dbNowBMScollTime = 0.0;
+ public double dbNowScroll = 1.0;
+ public double dbNowScrollY = 0.0; //2016.08.13 kairera0467 隍邏謨ｰ繧ｹ繧ｯ繝ｭ繝ｼ繝ｫ
+ public double dbLastTime = 0.0; //逶ｴ蜑阪ｮ蟆冗ｯ縺ｮ髢句ｧ区凾髢
+ public double dbLastBMScrollTime = 0.0;
+
+ public int[] bBARLINECUE = new int[2]; //蜻ｽ莉､繧貞･繧後◆谺｡縺ｮ蟆冗ｯ縺ｮ謫堺ｽ懊ｒ螳溽樟縺吶ｋ縺溘ａ縺ｮ繝輔Λ繧ｰ縲0 = mainflag, 1 = cuetype
+ public bool b蟆冗ｯ邱壹ｒ謖ｿ蜈･縺励※縺繧 = false;
+
+ //Normal Regular Master縺ｫ縺励◆縺縺代←縺薙％縺ｯ謌第｢縲
+ private List listBalloon_Normal;
+ private List listBalloon_Expert;
+ private List listBalloon_Master;
+ private List listBalloon; //譌ｧ讒区枚逕ｨ
+
+ public List listLyric; //豁瑚ｩ槭ｒ譬ｼ邏阪＠縺ｦ縺縺上Μ繧ｹ繝医ゅせ繝壹Ν蠢倥ｌ縺(縺峨＞
+ public List listLyric2;
+
+ private int listBalloon_Normal_謨ｰ蛟､邂｡逅;
+ private int listBalloon_Expert_謨ｰ蛟､邂｡逅;
+ private int listBalloon_Master_謨ｰ蛟､邂｡逅;
+
+ public bool[] b隴憺擇縺悟ｭ伜惠縺吶ｋ = new bool[(int)Difficulty.Total];
+
+ private string[] dlmtSpace = { " " };
+ private string[] dlmtEnter = { "\n" };
+ private string[] dlmtCOURSE = { "COURSE:" };
+
+ private int n繧ｹ繧ｯ繝ｭ繝ｼ繝ｫ譁ｹ蜷 = 0;
+ //2015.09.18 kairera0467
+ //繝舌ち繝輔Λ繧､繧ｹ繝ｩ繧､繝峨∩縺溘＞縺ｪ繧｢繝ｬ繧偵ｄ繧翫◆縺縺後◆繧√↓螳溯｣縲
+ //谺｡驛2縺ｿ縺溘＞縺ｪ隍邏謨ｰ縺ｨ縺九ｯ諢丞袖荳肴弱↑縺ｮ縺ｧ縲∵婿蜷代ｒ謖螳壹＠縺ｦ繧ｹ繧ｯ繝ｭ繝ｼ繝ｫ縺輔○繧九％縺ｨ縺ｫ縺励◆縲
+ //0:騾壼ｸｸ
+ //1:荳
+ //2:荳
+ //3:蜿ｳ荳
+ //4:蜿ｳ荳
+ //5:蟾ｦ
+ //6:蟾ｦ荳
+ //7:蟾ｦ荳
+
+ public string strBGIMAGE_PATH;
+ public string strBGVIDEO_PATH;
+
+ public double db蜃ｺ迴ｾ譎ょ綾;
+ public double db遘ｻ蜍募ｾ讖滓凾蛻ｻ;
+
+ public string strBGM_PATH;
+ public int SongVol;
+ public LoudnessMetadata? SongLoudnessMetadata;
+
+ public bool bHIDDENBRANCH; //2016.04.01 kairera0467 驕ｸ譖ｲ逕ｻ髱｢荳翫∬ｭ憺擇蛻蟯宣幕蟋句燕縺ｾ縺ｧ隴憺擇蛻蟯舌ｮ陦ｨ遉ｺ繧帝國縺
+ public bool bGOGOTIME; //2018.03.11 kairera0467
+
+ public bool[] IsBranchBarDraw = new bool[4]; // 莉墓ｧ伜､画峩縺ｫ繧医ｊ縲鮟濶ｲline縺ｮ陦ｨ遉ｺ豕輔ｒ螟画峩.2020.04.21.akasoko26
+ public bool IsEndedBranching; // BRANCHEND縺悟他縺ｳ蜃ｺ縺輔ｌ縺溘°縺ｩ縺縺
+ public Dan_C[] Dan_C;
+
+ public bool IsEnabledFixSENote;
+ public int FixSENote;
+ public GaugeIncreaseMode GaugeIncreaseMode;
+
+
+
+#if TEST_NOTEOFFMODE
+ public STLANEVALUE b貍泌･上〒逶ｴ蜑阪ｮ髻ｳ繧呈ｶ磯浹縺吶ｋ;
+// public bool bHH貍泌･上〒逶ｴ蜑阪ｮHH繧呈ｶ磯浹縺吶ｋ;
+// public bool bGUITAR貍泌･上〒逶ｴ蜑阪ｮGUITAR繧呈ｶ磯浹縺吶ｋ;
+// public bool bBASS貍泌･上〒逶ｴ蜑阪ｮBASS繧呈ｶ磯浹縺吶ｋ;
+#endif
+ // 繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ
+
+ public CDTX()
+ {
+ this.nPlayerSide = 0;
+ this.TITLE = "";
+ this.SUBTITLE = "";
+ this.ARTIST = "";
+ this.COMMENT = "";
+ this.PANEL = "";
+ this.GENRE = "";
+ this.bLyrics = false;
+ this.e繧ｸ繝｣繝ｳ繝ｫ = E繧ｸ繝｣繝ｳ繝ｫ.None;
+ this.PREVIEW = "";
+ this.PREIMAGE = "";
+ this.BACKGROUND = "";
+ this.BACKGROUND_GR = "";
+ this.PATH_WAV = "";
+ this.BPM = 120.0;
+ STDGBVALUE stdgbvalue = new STDGBVALUE();
+ stdgbvalue.Drums = 0;
+ stdgbvalue.Guitar = 0;
+ stdgbvalue.Bass = 0;
+ this.LEVEL = stdgbvalue;
+ this.bHIDDENBRANCH = false;
+ this.db蜀咲函騾溷ｺｦ = 1.0;
+ this.b繝√ャ繝励′縺ゅｋ = new ST繝√ャ繝励′縺ゅｋ();
+ this.b繝√ャ繝励′縺ゅｋ.Drums = false;
+ this.b繝√ャ繝励′縺ゅｋ.Guitar = false;
+ this.b繝√ャ繝励′縺ゅｋ.Bass = false;
+ this.b繝√ャ繝励′縺ゅｋ.HHOpen = false;
+ this.b繝√ャ繝励′縺ゅｋ.Ride = false;
+ this.b繝√ャ繝励′縺ゅｋ.LeftCymbal = false;
+ this.b繝√ャ繝励′縺ゅｋ.OpenGuitar = false;
+ this.b繝√ャ繝励′縺ゅｋ.OpenBass = false;
+ this.str繝輔ぃ繧､繝ｫ蜷 = "";
+ this.str繝輔か繝ｫ繝蜷 = "";
+ this.str繝輔ぃ繧､繝ｫ蜷阪ｮ邨ｶ蟇ｾ繝代せ = "";
+ this.n辟｡髯千ｮ｡逅WAV = new int[36 * 36];
+ this.n辟｡髯千ｮ｡逅BPM = new int[36 * 36];
+ this.n辟｡髯千ｮ｡逅PAN = new int[36 * 36];
+ this.n辟｡髯千ｮ｡逅SIZE = new int[36 * 36];
+ this.listBalloon_Normal_謨ｰ蛟､邂｡逅 = 0;
+ this.listBalloon_Expert_謨ｰ蛟､邂｡逅 = 0;
+ this.listBalloon_Master_謨ｰ蛟､邂｡逅 = 0;
+ this.nRESULTIMAGE逕ｨ蜆ｪ蜈磯菴 = new int[7];
+ this.nRESULTMOVIE逕ｨ蜆ｪ蜈磯菴 = new int[7];
+ this.nRESULTSOUND逕ｨ蜆ｪ蜈磯菴 = new int[7];
+
+ #region [ 2011.1.1 yyagi GDA->DTX螟画鋤繝繝ｼ繝悶Ν 繝ｪ繝輔ぃ繧ｯ繧ｿ蠕 ]
+ STGDAPARAM[] stgdaparamArray = new STGDAPARAM[] { // GDA->DTX conversion table
+ new STGDAPARAM("TC", 0x03), new STGDAPARAM("BL", 0x02), new STGDAPARAM("GS", 0x29),
+ new STGDAPARAM("DS", 0x30), new STGDAPARAM("FI", 0x53), new STGDAPARAM("HH", 0x11),
+ new STGDAPARAM("SD", 0x12), new STGDAPARAM("BD", 0x13), new STGDAPARAM("HT", 0x14),
+ new STGDAPARAM("LT", 0x15), new STGDAPARAM("CY", 0x16), new STGDAPARAM("G1", 0x21),
+ new STGDAPARAM("G2", 0x22), new STGDAPARAM("G3", 0x23), new STGDAPARAM("G4", 0x24),
+ new STGDAPARAM("G5", 0x25), new STGDAPARAM("G6", 0x26), new STGDAPARAM("G7", 0x27),
+ new STGDAPARAM("GW", 0x28), new STGDAPARAM("01", 0x61), new STGDAPARAM("02", 0x62),
+ new STGDAPARAM("03", 0x63), new STGDAPARAM("04", 0x64), new STGDAPARAM("05", 0x65),
+ new STGDAPARAM("06", 0x66), new STGDAPARAM("07", 0x67), new STGDAPARAM("08", 0x68),
+ new STGDAPARAM("09", 0x69), new STGDAPARAM("0A", 0x70), new STGDAPARAM("0B", 0x71),
+ new STGDAPARAM("0C", 0x72), new STGDAPARAM("0D", 0x73), new STGDAPARAM("0E", 0x74),
+ new STGDAPARAM("0F", 0x75), new STGDAPARAM("10", 0x76), new STGDAPARAM("11", 0x77),
+ new STGDAPARAM("12", 0x78), new STGDAPARAM("13", 0x79), new STGDAPARAM("14", 0x80),
+ new STGDAPARAM("15", 0x81), new STGDAPARAM("16", 0x82), new STGDAPARAM("17", 0x83),
+ new STGDAPARAM("18", 0x84), new STGDAPARAM("19", 0x85), new STGDAPARAM("1A", 0x86),
+ new STGDAPARAM("1B", 0x87), new STGDAPARAM("1C", 0x88), new STGDAPARAM("1D", 0x89),
+ new STGDAPARAM("1E", 0x90), new STGDAPARAM("1F", 0x91), new STGDAPARAM("20", 0x92),
+ new STGDAPARAM("B1", 0xA1), new STGDAPARAM("B2", 0xA2), new STGDAPARAM("B3", 0xA3),
+ new STGDAPARAM("B4", 0xA4), new STGDAPARAM("B5", 0xA5), new STGDAPARAM("B6", 0xA6),
+ new STGDAPARAM("B7", 0xA7), new STGDAPARAM("BW", 0xA8), new STGDAPARAM("G0", 0x20),
+ new STGDAPARAM("B0", 0xA0)
+ };
+ this.stGDAParam = stgdaparamArray;
+ #endregion
+ this.nBGMAdjust = 0;
+ this.nPolyphonicSounds = TJAPlayer3.ConfigIni.nPoliphonicSounds;
+ this.dbDTXVPlaySpeed = 1.0f;
+
+ //this.nScoreModeTmp = 1;
+ for (int y = 0; y < (int)Difficulty.Total; y++)
+ {
+ this.nScoreInit[0, y] = 300;
+ this.nScoreInit[1, y] = 1000;
+ this.nScoreDiff[y] = 120;
+ this.b驟咲せ縺梧欠螳壹＆繧後※縺繧擬0, y] = false;
+ this.b驟咲せ縺梧欠螳壹＆繧後※縺繧擬1, y] = false;
+ this.b驟咲せ縺梧欠螳壹＆繧後※縺繧擬2, y] = false;
+ }
+
+ this.dbBarLength = 1.0;
+
+ this.b譛蛻昴ｮ蛻蟯舌〒縺ゅｋ = true;
+
+ this.SongVol = CSound.DefaultSongVol;
+ this.SongLoudnessMetadata = null;
+
+ GaugeIncreaseMode = GaugeIncreaseMode.Normal;
+
+#if TEST_NOTEOFFMODE
+ this.bHH貍泌･上〒逶ｴ蜑阪ｮHH繧呈ｶ磯浹縺吶ｋ = true;
+ this.bGUITAR貍泌･上〒逶ｴ蜑阪ｮGUITAR繧呈ｶ磯浹縺吶ｋ = true;
+ this.bBASS貍泌･上〒逶ｴ蜑阪ｮBASS繧呈ｶ磯浹縺吶ｋ = true;
+#endif
+
+ Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture; // Change default culture to invariant, fixes (Purota)
+ Dan_C = new Dan_C[4];
+ pDan_LastChip = new CChip[1];
+ DanSongs.Number = 0;
+ }
+ public CDTX(string str蜈ｨ蜈･蜉帶枚蟄怜, int difficulty)
+ : this()
+ {
+ this.On豢ｻ諤ｧ蛹();
+ this.t蜈･蜉媽蜈ｨ蜈･蜉帶枚蟄怜励°繧(str蜈ｨ蜈･蜉帶枚蟄怜, difficulty);
+ }
+ public CDTX(string str繝輔ぃ繧､繝ｫ蜷, bool b繝倥ャ繝縺ｮ縺ｿ, int difficulty)
+ : this()
+ {
+ this.On豢ｻ諤ｧ蛹();
+ this.t蜈･蜉(str繝輔ぃ繧､繝ｫ蜷, b繝倥ャ繝縺ｮ縺ｿ, difficulty);
+ }
+ public CDTX(string str蜈ｨ蜈･蜉帶枚蟄怜, double db蜀咲函騾溷ｺｦ, int nBGMAdjust, int difficulty)
+ : this()
+ {
+ this.On豢ｻ諤ｧ蛹();
+ this.t蜈･蜉媽蜈ｨ蜈･蜉帶枚蟄怜励°繧(str蜈ｨ蜈･蜉帶枚蟄怜, str蜈ｨ蜈･蜉帶枚蟄怜, db蜀咲函騾溷ｺｦ, nBGMAdjust, difficulty);
+ }
+ public CDTX(string str繝輔ぃ繧､繝ｫ蜷, bool b繝倥ャ繝縺ｮ縺ｿ, double db蜀咲函騾溷ｺｦ, int nBGMAdjust, int difficulty)
+ : this()
+ {
+ this.On豢ｻ諤ｧ蛹();
+ this.t蜈･蜉(str繝輔ぃ繧､繝ｫ蜷, b繝倥ャ繝縺ｮ縺ｿ, db蜀咲函騾溷ｺｦ, nBGMAdjust, 0, 0, false, difficulty);
+ }
+ public CDTX(string str繝輔ぃ繧､繝ｫ蜷, bool b繝倥ャ繝縺ｮ縺ｿ, double db蜀咲函騾溷ｺｦ, int nBGMAdjust, int nReadVersion, int difficulty)
+ : this()
+ {
+ this.On豢ｻ諤ｧ蛹();
+ this.t蜈･蜉(str繝輔ぃ繧､繝ｫ蜷, b繝倥ャ繝縺ｮ縺ｿ, db蜀咲函騾溷ｺｦ, nBGMAdjust, nReadVersion, 0, false, difficulty);
+ }
+ public CDTX(string str繝輔ぃ繧､繝ｫ蜷, bool b繝倥ャ繝縺ｮ縺ｿ, double db蜀咲函騾溷ｺｦ, int nBGMAdjust, int nReadVersion, int nPlayerSide, bool bSession, int difficulty)
+ : this()
+ {
+ this.On豢ｻ諤ｧ蛹();
+ this.t蜈･蜉(str繝輔ぃ繧､繝ｫ蜷, b繝倥ャ繝縺ｮ縺ｿ, db蜀咲函騾溷ｺｦ, nBGMAdjust, nReadVersion, nPlayerSide, bSession, difficulty);
+ }
+
+
+ // 繝｡繧ｽ繝繝
+
+ public void tAVI縺ｮ隱ｭ縺ｿ霎ｼ縺ｿ()
+ {
+ if (this.listAVI != null)
+ {
+ foreach (CAVI cavi in this.listAVI.Values)
+ {
+ cavi.OnDeviceCreated();
+ }
+ }
+ if (this.listDS != null)
+ {
+ foreach (CDirectShow cds in this.listDS.Values)
+ {
+ cds.OnDeviceCreated();
+ }
+ }
+ if (!this.b繝倥ャ繝縺ｮ縺ｿ)//&& this.b蜍慕判隱ｭ縺ｿ霎ｼ縺ｿ )
+ {
+ foreach (CChip chip in this.listChip)
+ {
+ if (chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x54 || chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x5A)
+ {
+ chip.eAVI遞ｮ蛻･ = EAVI遞ｮ蛻･.Unknown;
+ chip.rAVI = null;
+ chip.rDShow = null;
+ chip.rAVIPan = null;
+ if (this.listAVIPAN.TryGetValue(chip.n謨ｴ謨ｰ蛟､, out CAVIPAN cavipan))
+ {
+ if (this.listAVI.TryGetValue(cavipan.nAVI逡ｪ蜿ｷ, out CAVI cavi) && (cavi.avi != null))
+ {
+ chip.eAVI遞ｮ蛻･ = EAVI遞ｮ蛻･.AVIPAN;
+ chip.rAVI = cavi;
+ //if( CDTXMania.ConfigIni.bDirectShowMode == true )
+ chip.rDShow = this.listDS[cavipan.nAVI逡ｪ蜿ｷ];
+ chip.rAVIPan = cavipan;
+ continue;
+ }
+ }
+
+ CDirectShow ds = null;
+ if (this.listAVI.TryGetValue(chip.n謨ｴ謨ｰ蛟､, out CAVI cavi2) && (cavi2.avi != null) || (this.listDS.TryGetValue(chip.n謨ｴ謨ｰ蛟､, out ds) && (ds.dshow != null)))
+ {
+ chip.eAVI遞ｮ蛻･ = EAVI遞ｮ蛻･.AVI;
+ chip.rAVI = cavi2;
+ //if(CDTXMania.ConfigIni.bDirectShowMode == true)
+ chip.rDShow = ds;
+ }
+ }
+ }
+ }
+ }
+
+ public void tWave蜀咲函菴咲ｽｮ閾ｪ蜍戊｣懈ｭ｣()
+ {
+ foreach (CWAV cwav in this.listWAV.Values)
+ {
+ this.tWave蜀咲函菴咲ｽｮ閾ｪ蜍戊｣懈ｭ｣(cwav);
+ }
+ }
+ public void tWave蜀咲函菴咲ｽｮ閾ｪ蜍戊｣懈ｭ｣(CWAV wc)
+ {
+ if (wc.rSound[0] != null && wc.rSound[0].n邱乗ｼ泌･乗凾髢杜s >= 5000)
+ {
+ for (int i = 0; i < nPolyphonicSounds; i++)
+ {
+ if ((wc.rSound[i] != null) && (wc.rSound[i].b蜀咲函荳ｭ))
+ {
+ long nCurrentTime = CSound邂｡逅.rc貍泌･冗畑繧ｿ繧､繝.n繧ｷ繧ｹ繝繝譎ょ綾ms;
+ if (nCurrentTime > wc.n蜀咲函髢句ｧ区凾蛻ｻ[i])
+ {
+ long nAbsTimeFromStartPlaying = nCurrentTime - wc.n蜀咲函髢句ｧ区凾蛻ｻ[i];
+ //Trace.TraceInformation( "蜀咲函菴咲ｽｮ閾ｪ蜍戊｣懈ｭ｣: {0}, seek蜈={1}ms, 蜈ｨ髻ｳ髟ｷ={2}ms",
+ // Path.GetFileName( wc.rSound[ 0 ].str繝輔ぃ繧､繝ｫ蜷 ),
+ // nAbsTimeFromStartPlaying,
+ // wc.rSound[ 0 ].n邱乗ｼ泌･乗凾髢杜s
+ //);
+ // wc.rSound[ i ].t蜀咲函菴咲ｽｮ繧貞､画峩縺吶ｋ( wc.rSound[ i ].t譎ょ綾縺九ｉ菴咲ｽｮ繧定ｿ斐☆( nAbsTimeFromStartPlaying ) );
+ // WASAPI/ASIO逕ｨ竊
+ if (!TJAPlayer3.stage貍泌･上ラ繝ｩ繝逕ｻ髱｢.bPAUSE)
+ {
+ if (wc.rSound[i].b荳譎ょ●豁｢荳ｭ) wc.rSound[i].t蜀咲函繧貞埼幕縺吶ｋ(nAbsTimeFromStartPlaying);
+ else wc.rSound[i].t蜀咲函菴咲ｽｮ繧貞､画峩縺吶ｋ(nAbsTimeFromStartPlaying);
+ }
+ else
+ {
+ wc.rSound[i].t蜀咲函繧剃ｸ譎ょ●豁｢縺吶ｋ();
+ }
+ }
+ }
+ }
+ }
+ }
+ public void tWav縺ｮ蜀咲函蛛懈ｭ｢(int nWave縺ｮ蜀驛ｨ逡ｪ蜿ｷ)
+ {
+ tWav縺ｮ蜀咲函蛛懈ｭ｢(nWave縺ｮ蜀驛ｨ逡ｪ蜿ｷ, false);
+ }
+ public void tWav縺ｮ蜀咲函蛛懈ｭ｢(int nWave縺ｮ蜀驛ｨ逡ｪ蜿ｷ, bool b繝溘く繧ｵ繝ｼ縺九ｉ繧ょ炎髯､縺吶ｋ)
+ {
+ if (this.listWAV.TryGetValue(nWave縺ｮ蜀驛ｨ逡ｪ蜿ｷ, out CWAV cwav))
+ {
+ for (int i = 0; i < nPolyphonicSounds; i++)
+ {
+ if (cwav.rSound[i] != null && cwav.rSound[i].b蜀咲函荳ｭ)
+ {
+ if (b繝溘く繧ｵ繝ｼ縺九ｉ繧ょ炎髯､縺吶ｋ)
+ {
+ cwav.rSound[i].t繧ｵ繧ｦ繝ｳ繝峨ｒ蛛懈ｭ｢縺励※Mixer縺九ｉ繧ょ炎髯､縺吶ｋ();
+ }
+ else
+ {
+ cwav.rSound[i].t蜀咲函繧貞●豁｢縺吶ｋ();
+ }
+ }
+ }
+ }
+ }
+ public void tWAV縺ｮ隱ｭ縺ｿ霎ｼ縺ｿ(CWAV cwav)
+ {
+ string str = string.IsNullOrEmpty(this.PATH_WAV) ? this.str繝輔か繝ｫ繝蜷 : this.PATH_WAV;
+ str = str + cwav.str繝輔ぃ繧､繝ｫ蜷;
+
+ try
+ {
+ #region [ 蜷梧凾逋ｺ髻ｳ謨ｰ繧偵√メ繝｣繝ｳ繝阪Ν縺ｫ繧医▲縺ｦ螟峨∴繧 ]
+
+ int nPoly = nPolyphonicSounds;
+ if (TJAPlayer3.Sound邂｡逅.GetCurrentSoundDeviceType() != "DirectSound") // DShow縺ｧ縺ｮ蜀咲函縺ｮ蝣ｴ蜷医ｯ繝溘く繧ｷ繝ｳ繧ｰ雋闕ｷ縺碁ｫ倥￥縺ｪ縺縺溘ａ縲
+ {
+ // 繝√ャ繝励ｮ繝ｩ繧､繝輔ち繧､繝邂｡逅繧定｡後ｏ縺ｪ縺
+ if (cwav.bIsBassSound) nPoly = (nPolyphonicSounds >= 2) ? 2 : 1;
+ else if (cwav.bIsGuitarSound) nPoly = (nPolyphonicSounds >= 2) ? 2 : 1;
+ else if (cwav.bIsSESound) nPoly = 1;
+ else if (cwav.bIsBGMSound) nPoly = 1;
+ }
+
+ if (cwav.bIsBGMSound) nPoly = 1;
+
+ #endregion
+
+ for (int i = 0; i < nPoly; i++)
+ {
+ try
+ {
+ cwav.rSound[i] = TJAPlayer3.Sound邂｡逅.t繧ｵ繧ｦ繝ｳ繝峨ｒ逕滓舌☆繧(str, ESoundGroup.SongPlayback);
+
+ if (!TJAPlayer3.ConfigIni.bDynamicBassMixerManagement)
+ {
+ cwav.rSound[i].tBASS繧ｵ繧ｦ繝ｳ繝峨ｒ繝溘く繧ｵ繝ｼ縺ｫ霑ｽ蜉縺吶ｋ();
+ }
+
+ if (TJAPlayer3.ConfigIni.bLog菴懈占ｧ｣謾ｾ繝ｭ繧ｰ蜃ｺ蜉)
+ {
+ Trace.TraceInformation("繧ｵ繧ｦ繝ｳ繝峨ｒ菴懈舌＠縺ｾ縺励◆縲({3})({0})({1})({2}bytes)", cwav.str繧ｳ繝｡繝ｳ繝域枚, str,
+ cwav.rSound[0].n繧ｵ繧ｦ繝ｳ繝峨ヰ繝繝輔ぃ繧ｵ繧､繧ｺ, cwav.rSound[0].b繧ｹ繝医Μ繝ｼ繝蜀咲函縺吶ｋ ? "Stream" : "OnMemory");
+ }
+ }
+ catch (Exception e)
+ {
+ cwav.rSound[i] = null;
+ Trace.TraceError("繧ｵ繧ｦ繝ｳ繝峨ｮ菴懈舌↓螟ｱ謨励＠縺ｾ縺励◆縲({0})({1})", cwav.str繧ｳ繝｡繝ｳ繝域枚, str);
+ Trace.TraceError(e.ToString());
+ }
+ }
+ }
+ catch (Exception exception)
+ {
+ Trace.TraceError("繧ｵ繧ｦ繝ｳ繝峨ｮ逕滓舌↓螟ｱ謨励＠縺ｾ縺励◆縲({0})({1})", cwav.str繧ｳ繝｡繝ｳ繝域枚, str);
+ Trace.TraceError(exception.ToString());
+
+ for (int j = 0; j < nPolyphonicSounds; j++)
+ {
+ cwav.rSound[j] = null;
+ }
+
+ //continue;
+ }
+ }
+
+ public static string tZZ(int n)
+ {
+ if (n < 0 || n >= 36 * 36)
+ return "!!"; // 繧ｪ繝ｼ繝舌ｼｼ上い繝ｳ繝繝ｼ繝輔Ο繝ｼ縲
+
+ // n 繧36騾ｲ謨ｰ2譯√ｮ譁蟄怜励↓縺励※霑斐☆縲
+
+ string str = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+ return new string(new char[] { str[n / 36], str[n % 36] });
+ }
+ public void t繧ｮ繧ｿ繝ｼ縺ｨ繝吶ｼ繧ｹ縺ｮ繝ｩ繝ｳ繝繝蛹(E讌ｽ蝎ｨ繝代ｼ繝 part, E繝ｩ繝ｳ繝繝繝｢繝ｼ繝 eRandom)
+ {
+ }
+ public void t螟ｪ鮠薙メ繝繝励ｮ繝ｩ繝ｳ繝繝蛹(E繝ｩ繝ｳ繝繝繝｢繝ｼ繝 eRandom)
+ {
+ //2016.02.11 kairera0467
+ //縺ｪ繧薙□繧医％縺ｮ繧ｯ繧ｽ螳溯｣縺ｯ(諤)
+ Random rnd = new System.Random();
+
+ switch (eRandom)
+ {
+ case E繝ｩ繝ｳ繝繝繝｢繝ｼ繝.MIRROR:
+ foreach (var chip in this.listChip)
+ {
+ switch (chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ)
+ {
+ case 0x11:
+ chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ = 0x12;
+ break;
+ case 0x12:
+ chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ = 0x11;
+ break;
+ case 0x13:
+ chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ = 0x14;
+ chip.nSenote = 6;
+ break;
+ case 0x14:
+ chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ = 0x13;
+ chip.nSenote = 5;
+ break;
+ }
+ }
+ break;
+ case E繝ｩ繝ｳ繝繝繝｢繝ｼ繝.RANDOM:
+ foreach (var chip in this.listChip)
+ {
+ int n = rnd.Next(50);
+
+ if (n >= 5 && n <= 10)
+ {
+ switch (chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ)
+ {
+ case 0x11:
+ chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ = 0x12;
+ break;
+ case 0x12:
+ chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ = 0x11;
+ break;
+ case 0x13:
+ chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ = 0x14;
+ chip.nSenote = 6;
+ break;
+ case 0x14:
+ chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ = 0x13;
+ chip.nSenote = 5;
+ break;
+ }
+ }
+ }
+ break;
+ case E繝ｩ繝ｳ繝繝繝｢繝ｼ繝.SUPERRANDOM:
+ foreach (var chip in this.listChip)
+ {
+ int n = rnd.Next(80);
+
+ if (n >= 3 && n <= 43)
+ {
+ switch (chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ)
+ {
+ case 0x11:
+ chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ = 0x12;
+ break;
+ case 0x12:
+ chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ = 0x11;
+ break;
+ case 0x13:
+ chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ = 0x14;
+ chip.nSenote = 6;
+ break;
+ case 0x14:
+ chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ = 0x13;
+ chip.nSenote = 5;
+ break;
+ }
+ }
+ }
+ break;
+ case E繝ｩ繝ｳ繝繝繝｢繝ｼ繝.HYPERRANDOM:
+ foreach (var chip in this.listChip)
+ {
+ int n = rnd.Next(100);
+
+ if (n >= 20 && n <= 80)
+ {
+ switch (chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ)
+ {
+ case 0x11:
+ chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ = 0x12;
+ break;
+ case 0x12:
+ chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ = 0x11;
+ break;
+ case 0x13:
+ chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ = 0x14;
+ chip.nSenote = 6;
+ break;
+ case 0x14:
+ chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ = 0x13;
+ chip.nSenote = 5;
+ break;
+ }
+ }
+ }
+ break;
+ case E繝ｩ繝ｳ繝繝繝｢繝ｼ繝.OFF:
+ default:
+ break;
+ }
+ if (eRandom != E繝ｩ繝ｳ繝繝繝｢繝ｼ繝.OFF)
+ {
+ #region[ list菴懈 ]
+ //縺ｲ縺ｨ縺ｾ縺壹メ繝繝励□縺代ｮ繝ｪ繧ｹ繝医ｒ菴懈舌＠縺ｦ縺翫￥縲
+ List list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝;
+ list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝 = new List();
+ int nCount = 0;
+ int dkdkCount = 0;
+
+ foreach (CChip chip in this.listChip)
+ {
+ if (chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ >= 0x11 && chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ < 0x18)
+ {
+ list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝.Add(chip);
+ }
+ }
+ #endregion
+
+ this.tSenotes_Core_V2(list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝);
+
+ }
+
+
+ }
+
+ #region [ 繝√ャ繝励ｮ蜀咲函縺ｨ蛛懈ｭ｢ ]
+ public void t繝√ャ繝励ｮ蜀咲函(CChip pChip, long n蜀咲函髢句ｧ九す繧ｹ繝繝譎ょ綾ms)
+ {
+ if (TJAPlayer3.ConfigIni.b貍泌･城溷ｺｦ縺御ｸ蛟埼溘〒縺ゅｋ縺ｨ縺堺ｻ･螟夜浹螢ｰ繧貞咲函縺励↑縺 && TJAPlayer3.ConfigIni.n貍泌･城溷ｺｦ != 20)
+ return;
+
+ if (pChip.n謨ｴ謨ｰ蛟､_蜀驛ｨ逡ｪ蜿ｷ >= 0)
+ {
+ if (this.listWAV.TryGetValue(pChip.n謨ｴ謨ｰ蛟､_蜀驛ｨ逡ｪ蜿ｷ, out CWAV wc))
+ {
+ int index = wc.n迴ｾ蝨ｨ蜀咲函荳ｭ縺ｮ繧ｵ繧ｦ繝ｳ繝臥分蜿ｷ = (wc.n迴ｾ蝨ｨ蜀咲函荳ｭ縺ｮ繧ｵ繧ｦ繝ｳ繝臥分蜿ｷ + 1) % nPolyphonicSounds;
+ if ((wc.rSound[0] != null) &&
+ (wc.rSound[0].b繧ｹ繝医Μ繝ｼ繝蜀咲函縺吶ｋ || wc.rSound[index] == null))
+ {
+ index = wc.n迴ｾ蝨ｨ蜀咲函荳ｭ縺ｮ繧ｵ繧ｦ繝ｳ繝臥分蜿ｷ = 0;
+ }
+ CSound sound = wc.rSound[index];
+ if (sound != null)
+ {
+ sound.db蜀咲函騾溷ｺｦ = ((double)TJAPlayer3.ConfigIni.n貍泌･城溷ｺｦ) / 20.0;
+ // 蜀咲函騾溷ｺｦ縺ｫ繧医▲縺ｦ縲仝ASAPI/ASIO縺ｧ菴ｿ縺菴ｿ逕ｨmixer縺梧ｱｺ縺ｾ繧九◆繧√∽ｻ倬囂諠蝣ｱ縺ｮ險ｭ螳(髻ｳ驥/PAN)縺ｯ縲∝咲函騾溷ｺｦ縺ｮ險ｭ螳壼ｾ後↓陦後≧
+
+ // 2018-08-27 twopointzero - DON'T attempt to load (or queue scanning) loudness metadata here.
+ // This code is called right after loading the .tja, and that code
+ // will have just made such an attempt.
+ TJAPlayer3.SongGainController.Set(wc.SongVol, wc.SongLoudnessMetadata, sound);
+
+ sound.n菴咲ｽｮ = wc.n菴咲ｽｮ;
+ sound.t蜀咲函繧帝幕蟋九☆繧();
+ }
+ wc.n蜀咲函髢句ｧ区凾蛻ｻ[wc.n迴ｾ蝨ｨ蜀咲函荳ｭ縺ｮ繧ｵ繧ｦ繝ｳ繝臥分蜿ｷ] = n蜀咲函髢句ｧ九す繧ｹ繝繝譎ょ綾ms;
+ this.tWave蜀咲函菴咲ｽｮ閾ｪ蜍戊｣懈ｭ｣(wc);
+ }
+ }
+ }
+ public void t蜷閾ｪ蜍募咲函髻ｳ繝√ャ繝励ｮ蜀咲函譎ょ綾繧貞､画峩縺吶ｋ(int nBGMAdjust縺ｮ蠅玲ｸ帛､)
+ {
+ this.nBGMAdjust += nBGMAdjust縺ｮ蠅玲ｸ帛､;
+ for (int i = 0; i < this.listChip.Count; i++)
+ {
+ int nChannelNumber = this.listChip[i].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ;
+ if (((
+ (nChannelNumber == 1) ||
+ ((0x61 <= nChannelNumber) && (nChannelNumber <= 0x69))
+ ) ||
+ ((0x70 <= nChannelNumber) && (nChannelNumber <= 0x79))
+ ) ||
+ (((0x80 <= nChannelNumber) && (nChannelNumber <= 0x89)) || ((0x90 <= nChannelNumber) && (nChannelNumber <= 0x92)))
+ )
+ {
+ this.listChip[i].n逋ｺ螢ｰ譎ょ綾ms += nBGMAdjust縺ｮ蠅玲ｸ帛､;
+ }
+ }
+ foreach (CWAV cwav in this.listWAV.Values)
+ {
+ for (int j = 0; j < nPolyphonicSounds; j++)
+ {
+ if ((cwav.rSound[j] != null) && cwav.rSound[j].b蜀咲函荳ｭ)
+ {
+ cwav.n蜀咲函髢句ｧ区凾蛻ｻ[j] += nBGMAdjust縺ｮ蠅玲ｸ帛､;
+ }
+ }
+ }
+ }
+ public void t蜈ｨ繝√ャ繝励ｮ蜀咲函荳譎ょ●豁｢()
+ {
+ foreach (CWAV cwav in this.listWAV.Values)
+ {
+ for (int i = 0; i < nPolyphonicSounds; i++)
+ {
+ if ((cwav.rSound[i] != null) && cwav.rSound[i].b蜀咲函荳ｭ)
+ {
+ cwav.rSound[i].t蜀咲函繧剃ｸ譎ょ●豁｢縺吶ｋ();
+ cwav.n荳譎ょ●豁｢譎ょ綾[i] = CSound邂｡逅.rc貍泌･冗畑繧ｿ繧､繝.n繧ｷ繧ｹ繝繝譎ょ綾ms;
+ }
+ }
+ }
+ }
+ public void t蜈ｨ繝√ャ繝励ｮ蜀咲函蜀埼幕()
+ {
+ foreach (CWAV cwav in this.listWAV.Values)
+ {
+ for (int i = 0; i < nPolyphonicSounds; i++)
+ {
+ if ((cwav.rSound[i] != null) && cwav.rSound[i].b荳譎ょ●豁｢荳ｭ)
+ {
+ //long num1 = cwav.n荳譎ょ●豁｢譎ょ綾[ i ];
+ //long num2 = cwav.n蜀咲函髢句ｧ区凾蛻ｻ[ i ];
+ cwav.rSound[i].t蜀咲函繧貞埼幕縺吶ｋ(cwav.n荳譎ょ●豁｢譎ょ綾[i] - cwav.n蜀咲函髢句ｧ区凾蛻ｻ[i]);
+ cwav.n蜀咲函髢句ｧ区凾蛻ｻ[i] += CSound邂｡逅.rc貍泌･冗畑繧ｿ繧､繝.n繧ｷ繧ｹ繝繝譎ょ綾ms - cwav.n荳譎ょ●豁｢譎ょ綾[i];
+ }
+ }
+ }
+ }
+ public void t蜈ｨ繝√ャ繝励ｮ蜀咲函蛛懈ｭ｢()
+ {
+ foreach (CWAV cwav in this.listWAV.Values)
+ {
+ this.tWav縺ｮ蜀咲函蛛懈ｭ｢(cwav.n蜀驛ｨ逡ｪ蜿ｷ);
+ }
+ }
+ public void t蜈ｨ繝√ャ繝励ｮ蜀咲函蛛懈ｭ｢縺ｨ繝溘く繧ｵ繝ｼ縺九ｉ縺ｮ蜑企勁()
+ {
+ foreach (CWAV cwav in this.listWAV.Values)
+ {
+ this.tWav縺ｮ蜀咲函蛛懈ｭ｢(cwav.n蜀驛ｨ逡ｪ蜿ｷ, true);
+ }
+ }
+ #endregion
+
+ public void t蜈･蜉(string str繝輔ぃ繧､繝ｫ蜷, bool b繝倥ャ繝縺ｮ縺ｿ, int difficulty)
+ {
+ this.t蜈･蜉(str繝輔ぃ繧､繝ｫ蜷, b繝倥ャ繝縺ｮ縺ｿ, 1.0, 0, 0, 0, false, difficulty);
+ }
+ public void t蜈･蜉(string str繝輔ぃ繧､繝ｫ蜷, bool b繝倥ャ繝縺ｮ縺ｿ, double db蜀咲函騾溷ｺｦ, int nBGMAdjust, int nReadVersion, int nPlayerSide, bool bSession, int difficulty)
+ {
+ this.b繝倥ャ繝縺ｮ縺ｿ = b繝倥ャ繝縺ｮ縺ｿ;
+ this.str繝輔ぃ繧､繝ｫ蜷阪ｮ邨ｶ蟇ｾ繝代せ = Path.GetFullPath(str繝輔ぃ繧､繝ｫ蜷);
+ this.str繝輔ぃ繧､繝ｫ蜷 = Path.GetFileName(this.str繝輔ぃ繧､繝ｫ蜷阪ｮ邨ｶ蟇ｾ繝代せ);
+ this.str繝輔か繝ｫ繝蜷 = Path.GetDirectoryName(this.str繝輔ぃ繧､繝ｫ蜷阪ｮ邨ｶ蟇ｾ繝代せ) + @"\";
+ //if ( this.e遞ｮ蛻･ != E遞ｮ蛻･.SMF )
+ {
+ try
+ {
+ this.nPlayerSide = nPlayerSide;
+ this.bSession隴憺擇繧定ｪｭ縺ｿ霎ｼ繧 = bSession;
+ if (nReadVersion != 0)
+ {
+ //DTX譁ｹ蠑
+
+ //DateTime timeBeginLoad = DateTime.Now;
+ //TimeSpan span;
+ string[] files = Directory.GetFiles(this.str繝輔か繝ｫ繝蜷, "*.tja");
+
+ StreamReader reader = new StreamReader(str繝輔ぃ繧､繝ｫ蜷, Encoding.GetEncoding("Shift_JIS"));
+ string str2 = reader.ReadToEnd();
+ reader.Close();
+
+ //StreamReader reader2 = new StreamReader( this.str繝輔か繝ｫ繝蜷 + "test.tja", Encoding.GetEncoding( "Shift_JIS" ) );
+ StreamReader reader2 = new StreamReader(files[0], Encoding.GetEncoding("Shift_JIS"));
+ string str3 = reader2.ReadToEnd();
+ reader2.Close();
+
+ //span = (TimeSpan) ( DateTime.Now - timeBeginLoad );
+ //Trace.TraceInformation( "DTXfileload譎る俣: {0}", span.ToString() );
+
+ this.t蜈･蜉媽蜈ｨ蜈･蜉帶枚蟄怜励°繧(str2, str3, db蜀咲函騾溷ｺｦ, nBGMAdjust, difficulty);
+ }
+ else
+ {
+ //谺｡驛取婿蠑
+
+ //DateTime timeBeginLoad = DateTime.Now;
+ //TimeSpan span;
+
+ StreamReader reader = new StreamReader(str繝輔ぃ繧､繝ｫ蜷, Encoding.GetEncoding("Shift_JIS"));
+ string str2 = reader.ReadToEnd();
+ reader.Close();
+
+ //StreamReader reader2 = new StreamReader( this.str繝輔か繝ｫ繝蜷 + "test.tja", Encoding.GetEncoding( "Shift_JIS" ) );
+ //StreamReader reader2 = new StreamReader( str繝輔ぃ繧､繝ｫ蜷, Encoding.GetEncoding( "Shift_JIS" ) );
+ //string str3 = reader2.ReadToEnd();
+ //reader2.Close();
+ string str3 = str2;
+
+ //span = (TimeSpan) ( DateTime.Now - timeBeginLoad );
+ //Trace.TraceInformation( "DTXfileload譎る俣: {0}", span.ToString() );
+
+ this.t蜈･蜉媽蜈ｨ蜈･蜉帶枚蟄怜励°繧(str2, str3, db蜀咲函騾溷ｺｦ, nBGMAdjust, difficulty);
+ }
+ }
+ catch (Exception ex)
+ {
+ //MessageBox.Show( "縺翫ｄ?繧ｨ繝ｩ繝ｼ縺悟ｺ縺溘ｈ縺縺ｧ縺吶ゅ♀蜈讒倥" );
+ Trace.TraceError("縺翫ｄ?繧ｨ繝ｩ繝ｼ縺悟ｺ縺溘ｈ縺縺ｧ縺吶ゅ♀蜈讒倥");
+ Trace.TraceError(ex.ToString());
+ Trace.TraceError("萓句､悶′逋ｺ逕溘＠縺ｾ縺励◆縺悟ｦ逅繧堤ｶ咏ｶ壹＠縺ｾ縺吶 (79ff8639-9b3c-477f-bc4a-f2eea9784860)");
+ }
+ }
+ }
+ public void t蜈･蜉媽蜈ｨ蜈･蜉帶枚蟄怜励°繧(string str蜈ｨ蜈･蜉帶枚蟄怜, int difficulty)
+ {
+ this.t蜈･蜉媽蜈ｨ蜈･蜉帶枚蟄怜励°繧(str蜈ｨ蜈･蜉帶枚蟄怜, str蜈ｨ蜈･蜉帶枚蟄怜, 1.0, 0, difficulty);
+ }
+ public void t蜈･蜉媽蜈ｨ蜈･蜉帶枚蟄怜励°繧(string str蜈ｨ蜈･蜉帶枚蟄怜, string str1, double db蜀咲函騾溷ｺｦ, int nBGMAdjust, int Difficulty)
+ {
+ //DateTime timeBeginLoad = DateTime.Now;
+ //TimeSpan span;
+
+ if (!string.IsNullOrEmpty(str蜈ｨ蜈･蜉帶枚蟄怜))
+ {
+ #region [ 謾ｹ陦後き繝繝 ]
+ this.db蜀咲函騾溷ｺｦ = db蜀咲函騾溷ｺｦ;
+ str蜈ｨ蜈･蜉帶枚蟄怜 = str蜈ｨ蜈･蜉帶枚蟄怜.Replace(Environment.NewLine, "\n");
+ str蜈ｨ蜈･蜉帶枚蟄怜 = str蜈ｨ蜈･蜉帶枚蟄怜.Replace('\t', ' ');
+ str蜈ｨ蜈･蜉帶枚蟄怜 = str蜈ｨ蜈･蜉帶枚蟄怜 + "\n";
+ #endregion
+ //span = (TimeSpan) ( DateTime.Now - timeBeginLoad );
+ //Trace.TraceInformation( "謾ｹ陦後き繝繝域凾髢: {0}", span.ToString() );
+ //timeBeginLoad = DateTime.Now;
+ #region [ 蛻晄悄蛹 ]
+ for (int j = 0; j < 36 * 36; j++)
+ {
+ this.n辟｡髯千ｮ｡逅WAV[j] = -j;
+ this.n辟｡髯千ｮ｡逅BPM[j] = -j;
+ this.n辟｡髯千ｮ｡逅PAN[j] = -10000 - j;
+ this.n辟｡髯千ｮ｡逅SIZE[j] = -j;
+ }
+ this.n蜀驛ｨ逡ｪ蜿ｷWAV1to = 1;
+ this.n蜀驛ｨ逡ｪ蜿ｷBPM1to = 1;
+ this.bstackIF縺九ｉENDIF繧偵せ繧ｭ繝繝励☆繧 = new Stack();
+ this.bstackIF縺九ｉENDIF繧偵せ繧ｭ繝繝励☆繧.Push(false);
+ this.n迴ｾ蝨ｨ縺ｮ荵ｱ謨ｰ = 0;
+ for (int k = 0; k < 7; k++)
+ {
+ this.nRESULTIMAGE逕ｨ蜆ｪ蜈磯菴梗k] = 0;
+ this.nRESULTMOVIE逕ｨ蜆ｪ蜈磯菴梗k] = 0;
+ this.nRESULTSOUND逕ｨ蜆ｪ蜈磯菴梗k] = 0;
+ }
+ #endregion
+ #region [ 蜈･蜉/陦瑚ｧ｣譫 ]
+ #region[蛻晄悄蛹望
+ this.dbNowScroll = 1.0;
+ this.dbNowSCROLL_Normal = new double[] { 1.0, 0.0 };
+ this.dbNowSCROLL_Expert = new double[] { 1.0, 0.0 };
+ this.dbNowSCROLL_Master = new double[] { 1.0, 0.0 };
+ this.n迴ｾ蝨ｨ縺ｮ繧ｳ繝ｼ繧ｹ = ECourse.eNormal;
+ #endregion
+ CharEnumerator ce = str蜈ｨ蜈･蜉帶枚蟄怜.GetEnumerator();
+ if (ce.MoveNext())
+ {
+ this.n迴ｾ蝨ｨ縺ｮ陦梧焚 = 1;
+ do
+ {
+ if (!this.t蜈･蜉媽遨ｺ逋ｽ縺ｨ謾ｹ陦後ｒ繧ｹ繧ｭ繝繝励☆繧(ref ce))
+ {
+ break;
+ }
+ if (this.listChip.Count == 0)
+ {
+ //this.t蜈･蜉(str1);
+ //this.t蜈･蜉媽V3( str1, 3 );
+ this.t蜈･蜉媽V4(str1, Difficulty);
+ }
+ if (ce.Current == '#')
+ {
+ if (ce.MoveNext())
+ {
+ StringBuilder builder = new StringBuilder(0x20);
+ if (this.t蜈･蜉媽繧ｳ繝槭Φ繝画枚蟄怜励ｒ謚懊″蜃ｺ縺(ref ce, ref builder))
+ {
+ StringBuilder builder2 = new StringBuilder(0x400);
+ if (this.t蜈･蜉媽繝代Λ繝｡繝ｼ繧ｿ譁蟄怜励ｒ謚懊″蜃ｺ縺(ref ce, ref builder2))
+ {
+ StringBuilder builder3 = new StringBuilder(0x400);
+ if (this.t蜈･蜉媽繧ｳ繝｡繝ｳ繝域枚蟄怜励ｒ謚懊″蜃ｺ縺(ref ce, ref builder3))
+ {
+ this.t蜈･蜉媽陦瑚ｧ｣譫(ref builder, ref builder2, ref builder3);
+
+ this.n迴ｾ蝨ｨ縺ｮ陦梧焚++;
+ continue;
+ }
+ }
+ }
+ }
+ break;
+ }
+ //this.t蜈･蜉(str1);
+ }
+ while (this.t蜈･蜉媽繧ｳ繝｡繝ｳ繝医ｒ繧ｹ繧ｭ繝繝励☆繧(ref ce));
+
+ #endregion
+ //span = (TimeSpan) ( DateTime.Now - timeBeginLoad );
+ //Trace.TraceInformation( "謚懊″蜃ｺ縺玲凾髢: {0}", span.ToString() );
+ //timeBeginLoad = DateTime.Now;
+ this.n辟｡髯千ｮ｡逅WAV = null;
+ this.n辟｡髯千ｮ｡逅BPM = null;
+ this.n辟｡髯千ｮ｡逅PAN = null;
+ this.n辟｡髯千ｮ｡逅SIZE = null;
+ //this.t蜈･蜉媽陦瑚ｧ｣譫舌倥ャ繝( str1 );
+ if (!this.b繝倥ャ繝縺ｮ縺ｿ)
+ {
+ #region [ BPM/BMP蛻晄悄蛹 ]
+ int ch;
+ CBPM cbpm = null;
+ foreach (CBPM cbpm2 in this.listBPM.Values)
+ {
+ if (cbpm2.n陦ｨ險倅ｸ翫ｮ逡ｪ蜿ｷ == 0)
+ {
+ cbpm = cbpm2;
+ break;
+ }
+ }
+ if (cbpm == null)
+ {
+ cbpm = new CBPM();
+ cbpm.n蜀驛ｨ逡ｪ蜿ｷ = this.n蜀驛ｨ逡ｪ蜿ｷBPM1to++;
+ cbpm.n陦ｨ險倅ｸ翫ｮ逡ｪ蜿ｷ = 0;
+ cbpm.dbBPM蛟､ = 120.0;
+ this.listBPM.Add(cbpm.n蜀驛ｨ逡ｪ蜿ｷ, cbpm);
+ CChip chip = new CChip();
+ chip.n逋ｺ螢ｰ菴咲ｽｮ = 0;
+ chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ = 8; // 諡｡蠑ｵBPM
+ chip.n謨ｴ謨ｰ蛟､ = 0;
+ chip.n謨ｴ謨ｰ蛟､_蜀驛ｨ逡ｪ蜿ｷ = cbpm.n蜀驛ｨ逡ｪ蜿ｷ;
+ this.listChip.Insert(0, chip);
+ }
+ else
+ {
+ CChip chip = new CChip();
+ chip.n逋ｺ螢ｰ菴咲ｽｮ = 0;
+ chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ = 8; // 諡｡蠑ｵBPM
+ chip.n謨ｴ謨ｰ蛟､ = 0;
+ chip.n謨ｴ謨ｰ蛟､_蜀驛ｨ逡ｪ蜿ｷ = cbpm.n蜀驛ｨ逡ｪ蜿ｷ;
+ this.listChip.Insert(0, chip);
+ }
+ #endregion
+ //span = (TimeSpan) ( DateTime.Now - timeBeginLoad );
+ //Trace.TraceInformation( "蜑肴ｺ門ｙ螳御ｺ譎る俣: {0}", span.ToString() );
+ //timeBeginLoad = DateTime.Now;
+ #region [ CWAV蛻晄悄蛹 ]
+ foreach (CWAV cwav in this.listWAV.Values)
+ {
+ if (cwav.n繝√ャ繝励し繧､繧ｺ < 0)
+ {
+ cwav.n繝√ャ繝励し繧､繧ｺ = 100;
+ }
+ if (cwav.n菴咲ｽｮ <= -10000)
+ {
+ cwav.n菴咲ｽｮ = 0;
+ }
+ }
+ #endregion
+ //span = (TimeSpan) ( DateTime.Now - timeBeginLoad );
+ //Trace.TraceInformation( "CWAV蜑肴ｺ門ｙ譎る俣: {0}", span.ToString() );
+ //timeBeginLoad = DateTime.Now;
+ #region [ 繝√ャ繝怜咲紫險ｭ螳 ] // #28145 2012.4.22 yyagi 莠碁阪Ν繝ｼ繝励ｒ1驥阪Ν繝ｼ繝励↓螟画峩縺励※鬮倬溷喧)
+ //foreach ( CWAV cwav in this.listWAV.Values )
+ //{
+ // foreach( CChip chip in this.listChip )
+ // {
+ // if( chip.n謨ｴ謨ｰ蛟､_蜀驛ｨ逡ｪ蜿ｷ == cwav.n蜀驛ｨ逡ｪ蜿ｷ )
+ // {
+ // chip.db繝√ャ繝励し繧､繧ｺ蛟咲紫 = ( (double) cwav.n繝√ャ繝励し繧､繧ｺ ) / 100.0;
+ // if (chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x01 ) // BGM縺縺｣縺溘ｉ
+ // {
+ // cwav.bIsOnBGMLane = true;
+ // }
+ // }
+ // }
+ //}
+ foreach (CChip chip in this.listChip)
+ {
+ if (this.listWAV.TryGetValue(chip.n謨ｴ謨ｰ蛟､_蜀驛ｨ逡ｪ蜿ｷ, out CWAV cwav))
+ //foreach ( CWAV cwav in this.listWAV.Values )
+ {
+ // if ( chip.n謨ｴ謨ｰ蛟､_蜀驛ｨ逡ｪ蜿ｷ == cwav.n蜀驛ｨ逡ｪ蜿ｷ )
+ // {
+ chip.db繝√ャ繝励し繧､繧ｺ蛟咲紫 = ((double)cwav.n繝√ャ繝励し繧､繧ｺ) / 100.0;
+ //if ( chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x01 ) // BGM縺縺｣縺溘ｉ
+ //{
+ // cwav.bIsOnBGMLane = true;
+ //}
+ // }
+ }
+ }
+ #endregion
+ //span = (TimeSpan) ( DateTime.Now - timeBeginLoad );
+ //Trace.TraceInformation( "CWAV蜈ｨ貅門ｙ譎る俣: {0}", span.ToString() );
+ //timeBeginLoad = DateTime.Now;
+ #region [ 蠢隕√↓蠢懊§縺ｦ遨ｺ謇薙■髻ｳ繧0蟆冗ｯ縺ｫ螳夂ｾｩ縺吶ｋ ]
+ //for ( int m = 0xb1; m <= 0xbc; m++ ) // #28146 2012.4.21 yyagi; bb -> bc
+ //{
+ // foreach ( CChip chip in this.listChip )
+ // {
+ // if ( chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == m )
+ // {
+ // CChip c = new CChip();
+ // c.n逋ｺ螢ｰ菴咲ｽｮ = 0;
+ // c.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ = chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ;
+ // c.n謨ｴ謨ｰ蛟､ = chip.n謨ｴ謨ｰ蛟､;
+ // c.n謨ｴ謨ｰ蛟､_蜀驛ｨ逡ｪ蜿ｷ = chip.n謨ｴ謨ｰ蛟､_蜀驛ｨ逡ｪ蜿ｷ;
+ // this.listChip.Insert( 0, c );
+ // break;
+ // }
+ // }
+ //}
+ #endregion
+ //span = (TimeSpan) ( DateTime.Now - timeBeginLoad );
+ //Trace.TraceInformation( "遨ｺ謇鍋｢ｺ隱肴凾髢: {0}", span.ToString() );
+ //timeBeginLoad = DateTime.Now;
+ #region [ 諡榊ｭ神諡咲ｷ壹ｮ謖ｿ蜈･ ]
+ if (this.listChip.Count > 0)
+ {
+ this.listChip.Sort(); // 鬮倬溷喧縺ｮ縺溘ａ縺ｫ縺ｯ縺薙ｌ繧貞炎繧翫◆縺縺後〕istChip縺ｮ譛蠕後′n逋ｺ螢ｰ菴咲ｽｮ縺ｮ邨らｫｯ縺ｧ縺ゅｋ蠢隕√′縺ゅｋ縺ｮ縺ｧ縲
+ // 菫晏ｮ域ｧ遒ｺ菫昴ｒ蜆ｪ蜈医＠縺ｦ縺薙％縺ｧ縺ｮ繧ｽ繝ｼ繝医ｯ谿九＠縺ｦ縺翫￥
+ // 縺ｪ縺翫093譎らせ縺ｧ縺ｯ縲√％縺ｮ繧ｽ繝ｼ繝医ｒ蜑企勁縺励※繧ょ虚菴懊☆繧九ｈ縺縺ｫ縺ｯ縺励※縺ゅｋ縲
+ // (縺薙％縺ｾ縺ｧ縺ｮ荳驛ｨ繝√ャ繝礼匳骭ｲ繧偵〕istChip.Add(c)縺九ｉ蜷栗nsert(0,c)縺ｫ螟画峩縺励※縺ゅｋ)
+ // 縺薙ｌ縺ｫ繧医ｊ縲∵焚ms遞句ｺｦ縺ｪ縺後ｉ縺薙％縺ｧ縺ｮ繧ｽ繝ｼ繝医ｂ鬮倬溷喧縺輔ｌ縺ｦ縺繧九
+
+ //double barlength = 1.0;
+ //int nEndOfSong = ( this.listChip[ this.listChip.Count - 1 ].n逋ｺ螢ｰ菴咲ｽｮ + 384 ) - ( this.listChip[ this.listChip.Count - 1 ].n逋ｺ螢ｰ菴咲ｽｮ % 384 );
+ //for ( int tick384 = 0; tick384 <= nEndOfSong; tick384 += 384 ) // 蟆冗ｯ邱壹ｮ謖ｿ蜈･縲(蠕後↓蜃ｺ縺ｦ縺上ｋ諡榊ｭ千ｷ壹→繝ｫ繝ｼ繝励ｒ縺ｾ縺ｨ繧√ｈ縺縺ｨ縺吶ｋ縺ｪ繧峨’or繝ｫ繝ｼ繝励ｮ邨ゆｺ譚｡莉ｶ縺ｮ蠕ｮ螯吶↑驕輔＞縺ｫ豕ｨ諢上′蠢隕)
+ //{
+ // CChip chip = new CChip();
+ // chip.n逋ｺ螢ｰ菴咲ｽｮ = tick384;
+ // chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ = 0x50; // 蟆冗ｯ邱
+ // chip.n謨ｴ謨ｰ蛟､ = 36 * 36 - 1;
+ // chip.dbSCROLL = 1.0;
+ // this.listChip.Add( chip );
+ //}
+ ////this.listChip.Sort(); // 縺薙％縺ｧ縺ｮ繧ｽ繝ｼ繝医ｯ荳崎ｦ√ゅ◆縺縺玲怙蠕後↓繧ｽ繝ｼ繝医☆繧九％縺ｨ
+ //int nChipNo_BarLength = 0;
+ //int nChipNo_C1 = 0;
+
+ //this.listChip.Sort();
+ }
+ #endregion
+ //span = (TimeSpan) ( DateTime.Now - timeBeginLoad );
+ //Trace.TraceInformation( "諡榊ｭ神諡咲ｷ壽諺蜈･譎る俣: {0}", span.ToString() );
+ //timeBeginLoad = DateTime.Now;
+ #region [ C2 [諡咲ｷ喟蟆冗ｯ邱夊｡ｨ遉ｺ謖螳咯 縺ｮ蜃ｦ逅 ] // #28145 2012.4.21 yyagi; 2驥阪Ν繝ｼ繝励ｒ縺ｻ縺ｼ1驥阪↓縺励※鬮倬溷喧
+ bool bShowBeatBarLine = true;
+ for (int i = 0; i < this.listChip.Count; i++)
+ {
+ bool bChangedBeatBarStatus = false;
+ if ((this.listChip[i].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0xc2))
+ {
+ if (this.listChip[i].n謨ｴ謨ｰ蛟､ == 1) // BAR/BEAT LINE = ON
+ {
+ bShowBeatBarLine = true;
+ bChangedBeatBarStatus = true;
+ }
+ else if (this.listChip[i].n謨ｴ謨ｰ蛟､ == 2) // BAR/BEAT LINE = OFF
+ {
+ bShowBeatBarLine = false;
+ bChangedBeatBarStatus = true;
+ }
+ }
+ int startIndex = i;
+ if (bChangedBeatBarStatus) // C2繝√ャ繝励ｮ蜑阪↓50/51繝√ャ繝励′譚･縺ｦ縺繧句庄閭ｽ諤ｧ縺ｫ驟肴ｮ
+ {
+ while (startIndex > 0 && this.listChip[startIndex].n逋ｺ螢ｰ菴咲ｽｮ == this.listChip[i].n逋ｺ螢ｰ菴咲ｽｮ)
+ {
+ startIndex--;
+ }
+ startIndex++; // 1縺､蟆上＆縺城℃縺弱※縺繧九ｮ縺ｧ縲∵綾縺
+ }
+ for (int j = startIndex; j <= i; j++)
+ {
+ if (((this.listChip[j].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x50) || (this.listChip[j].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x51)) &&
+ (this.listChip[j].n謨ｴ謨ｰ蛟､ == (36 * 36 - 1)))
+ {
+ this.listChip[j].b蜿ｯ隕 = bShowBeatBarLine;
+ }
+ }
+ }
+ #endregion
+ //span = (TimeSpan) ( DateTime.Now - timeBeginLoad );
+ //Trace.TraceInformation( "C2 [諡咲ｷ喟蟆冗ｯ邱夊｡ｨ遉ｺ謖螳咯: {0}", span.ToString() );
+ //timeBeginLoad = DateTime.Now;
+ this.n蜀驛ｨ逡ｪ蜿ｷBRANCH1to = 0;
+ this.n蜀驛ｨ逡ｪ蜿ｷJSCROLL1to = 0;
+ #region [ 逋ｺ螢ｰ譎ょ綾縺ｮ險育ｮ ]
+ double bpm = 120.0;
+ //double dbBarLength = 1.0;
+ int n逋ｺ螢ｰ菴咲ｽｮ = 0;
+ int ms = 0;
+ int nBar = 0;
+ int nCount = 0;
+ this.nNowRollCount = 0;
+
+ List tmplistlyric = new List();
+ int BGM逡ｪ蜿ｷ = 0;
+
+ foreach (CChip chip in this.listChip)
+ {
+ if (chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x02) { }
+ //else if( chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x03 ){}
+ else if (chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x01) { }
+ else if (chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x08) { }
+ else if (chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ >= 0x11 && chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ <= 0x1F) { }
+ else if (chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x50) { }
+ else if (chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x51) { }
+ else if (chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x54) { }
+ else if (chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x08) { }
+ else if (chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0xF1) { }
+ else if (chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0xF2) { }
+ else if (chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0xFF) { }
+ else if (chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0xDD) { chip.n逋ｺ螢ｰ譎ょ綾ms = ms + ((int)(((625 * (chip.n逋ｺ螢ｰ菴咲ｽｮ - n逋ｺ螢ｰ菴咲ｽｮ)) * this.dbBarLength) / bpm)); }
+ else if (chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0xDF) { chip.n逋ｺ螢ｰ譎ょ綾ms = ms + ((int)(((625 * (chip.n逋ｺ螢ｰ菴咲ｽｮ - n逋ｺ螢ｰ菴咲ｽｮ)) * this.dbBarLength) / bpm)); }
+ else if (chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ < 0x93)
+ chip.n逋ｺ螢ｰ譎ょ綾ms = ms + ((int)(((625 * (chip.n逋ｺ螢ｰ菴咲ｽｮ - n逋ｺ螢ｰ菴咲ｽｮ)) * this.dbBarLength) / bpm));
+ else if ((chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ > 0x9F && chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ < 0xA0) || (chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ >= 0xF0 && chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ < 0xFE))
+ chip.n逋ｺ螢ｰ譎ょ綾ms = ms + ((int)(((625 * (chip.n逋ｺ螢ｰ菴咲ｽｮ - n逋ｺ螢ｰ菴咲ｽｮ)) * this.dbBarLength) / bpm));
+ nBar = chip.n逋ｺ螢ｰ菴咲ｽｮ / 384;
+ ch = chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ;
+
+ nCount++;
+ this.nNowRollCount++;
+
+ switch (ch)
+ {
+ case 0x01:
+ {
+ n逋ｺ螢ｰ菴咲ｽｮ = chip.n逋ｺ螢ｰ菴咲ｽｮ;
+
+ if (this.bOFFSET縺ｮ蛟､縺後槭う繝翫せ縺ｧ縺ゅｋ == false)
+ chip.n逋ｺ螢ｰ譎ょ綾ms += this.nOFFSET;
+ ms = chip.n逋ｺ螢ｰ譎ょ綾ms;
+
+ #region[listlyric2縺ｮ譎る俣蜷医ｏ縺嫋
+ for (int ind = 0; ind < listLyric2.Count; ind++)
+ {
+ if (listLyric2[ind].index == BGM逡ｪ蜿ｷ)
+ {
+ STLYRIC lyrictmp = this.listLyric2[ind];
+
+ lyrictmp.Time += chip.n逋ｺ螢ｰ譎ょ綾ms;
+
+ tmplistlyric.Add(lyrictmp);
+ }
+ }
+
+
+ BGM逡ｪ蜿ｷ++;
+ #endregion
+ continue;
+ }
+ case 0x02: // BarLength
+ {
+ n逋ｺ螢ｰ菴咲ｽｮ = chip.n逋ｺ螢ｰ菴咲ｽｮ;
+ if (this.bOFFSET縺ｮ蛟､縺後槭う繝翫せ縺ｧ縺ゅｋ == false)
+ chip.n逋ｺ螢ｰ譎ょ綾ms += this.nOFFSET;
+ ms = chip.n逋ｺ螢ｰ譎ょ綾ms;
+ dbBarLength = chip.db螳滓焚蛟､;
+ continue;
+ }
+ case 0x03: // BPM
+ {
+ n逋ｺ螢ｰ菴咲ｽｮ = chip.n逋ｺ螢ｰ菴咲ｽｮ;
+ if (this.bOFFSET縺ｮ蛟､縺後槭う繝翫せ縺ｧ縺ゅｋ == false)
+ chip.n逋ｺ螢ｰ譎ょ綾ms += this.nOFFSET;
+ ms = chip.n逋ｺ螢ｰ譎ょ綾ms;
+ bpm = this.BASEBPM + chip.n謨ｴ謨ｰ蛟､;
+ this.dbNowBPM = bpm;
+ continue;
+ }
+ case 0x04: // BGA (繝ｬ繧､繝､BGA1)
+ case 0x07: // 繝ｬ繧､繝､BGA2
+ break;
+
+ case 0x15:
+ case 0x16:
+ case 0x17:
+ {
+ if (this.bOFFSET縺ｮ蛟､縺後槭う繝翫せ縺ｧ縺ゅｋ)
+ {
+ chip.n逋ｺ螢ｰ譎ょ綾ms += this.nOFFSET;
+ chip.n繝弱ｼ繝邨ゆｺ譎ょ綾ms += this.nOFFSET;
+ }
+
+ this.nNowRoll = this.nNowRollCount - 1;
+ continue;
+ }
+ case 0x18:
+ {
+ if (this.bOFFSET縺ｮ蛟､縺後槭う繝翫せ縺ｧ縺ゅｋ)
+ {
+ chip.n逋ｺ螢ｰ譎ょ綾ms += this.nOFFSET;
+ }
+ continue;
+ }
+
+ case 0x55:
+ case 0x56:
+ case 0x57:
+ case 0x58:
+ case 0x59:
+ case 0x60:
+ break;
+
+ case 0x50:
+ {
+ if (this.bOFFSET縺ｮ蛟､縺後槭う繝翫せ縺ｧ縺ゅｋ)
+ chip.n逋ｺ螢ｰ譎ょ綾ms += this.nOFFSET;
+ //chip.n逋ｺ螢ｰ譎ょ綾ms += this.nDELAY;
+ //chip.dbBPM = this.dbNowBPM;
+ //chip.dbSCROLL = this.dbNowSCROLL;
+
+ if (this.n蜀驛ｨ逡ｪ蜿ｷBRANCH1to + 1 > this.listBRANCH.Count)
+ continue;
+
+ if (this.listBRANCH[this.n蜀驛ｨ逡ｪ蜿ｷBRANCH1to].n迴ｾ蝨ｨ縺ｮ蟆冗ｯ == nBar)
+ {
+ chip.bBranch = true;
+ this.n蜀驛ｨ逡ｪ蜿ｷBRANCH1to++;
+ }
+
+ //switch (this.n迴ｾ蝨ｨ縺ｮ繧ｳ繝ｼ繧ｹ)
+ //{
+ // case 0:
+ // chip.dbSCROLL = this.dbNowSCROLL_Normal;
+ // break;
+ // case 1:
+ // chip.dbSCROLL = this.dbNowSCROLL_Expert;
+ // break;
+ // case 2:
+ // chip.dbSCROLL = this.dbNowSCROLL_Master;
+ // break;
+ //}
+
+ //if( this.bBarLine == true )
+ // chip.b蜿ｯ隕 = true;
+ //else
+ // chip.b蜿ｯ隕 = false;
+
+ //if( this.b谺｡縺ｮ蟆冗ｯ縺悟蟯舌〒縺ゅｋ )
+ //{
+ // chip.bBranch = true;
+ // this.b谺｡縺ｮ蟆冗ｯ縺悟蟯舌〒縺ゅｋ = false;
+ //}
+ continue;
+ }
+
+ case 0x05: // Extended Object (髱槫ｯｾ蠢)
+ case 0x06: // Miss繧｢繝九Γ (髱槫ｯｾ蠢)
+ case 0x5A: // 譛ｪ螳夂ｾｩ
+ case 0x5b: // 譛ｪ螳夂ｾｩ
+ case 0x5c: // 譛ｪ螳夂ｾｩ
+ case 0x5d: // 譛ｪ螳夂ｾｩ
+ case 0x5e: // 譛ｪ螳夂ｾｩ
+ case 0x5f: // 譛ｪ螳夂ｾｩ
+ {
+ continue;
+ }
+ case 0x08: // 諡｡蠑ｵBPM
+ {
+ n逋ｺ螢ｰ菴咲ｽｮ = chip.n逋ｺ螢ｰ菴咲ｽｮ;
+ if (this.bOFFSET縺ｮ蛟､縺後槭う繝翫せ縺ｧ縺ゅｋ == false)
+ chip.n逋ｺ螢ｰ譎ょ綾ms += this.nOFFSET;
+ ms = chip.n逋ｺ螢ｰ譎ょ綾ms;
+ if (this.listBPM.TryGetValue(chip.n謨ｴ謨ｰ蛟､_蜀驛ｨ逡ｪ蜿ｷ, out CBPM cBPM))
+ {
+ bpm = (cBPM.n陦ｨ險倅ｸ翫ｮ逡ｪ蜿ｷ == 0 ? 0.0 : this.BASEBPM) + cBPM.dbBPM蛟､;
+ this.dbNowBPM = bpm;
+ }
+ continue;
+ }
+ case 0x54: // 蜍慕判蜀咲函
+ {
+ if (this.bOFFSET縺ｮ蛟､縺後槭う繝翫せ縺ｧ縺ゅｋ == false)
+ chip.n逋ｺ螢ｰ譎ょ綾ms += this.nOFFSET;
+ if (this.bMOVIEOFFSET縺ｮ蛟､縺後槭う繝翫せ縺ｧ縺ゅｋ == false)
+ chip.n逋ｺ螢ｰ譎ょ綾ms += this.nMOVIEOFFSET;
+ else
+ chip.n逋ｺ螢ｰ譎ょ綾ms -= this.nMOVIEOFFSET;
+ if (this.listAVIPAN.TryGetValue(chip.n謨ｴ謨ｰ蛟､, out CAVIPAN cavipan))
+ {
+ int num21 = ms + ((int)(((0x271 * (chip.n逋ｺ螢ｰ菴咲ｽｮ - n逋ｺ螢ｰ菴咲ｽｮ)) * this.dbBarLength) / bpm));
+ int num22 = ms + ((int)(((0x271 * ((chip.n逋ｺ螢ｰ菴咲ｽｮ + cavipan.n遘ｻ蜍墓凾髢田t) - n逋ｺ螢ｰ菴咲ｽｮ)) * this.dbBarLength) / bpm));
+ chip.n邱冗ｧｻ蜍墓凾髢 = num22 - num21;
+ }
+ continue;
+ }
+ case 0x97:
+ case 0x98:
+ case 0x99:
+ {
+ if (this.bOFFSET縺ｮ蛟､縺後槭う繝翫せ縺ｧ縺ゅｋ)
+ {
+ chip.n逋ｺ螢ｰ譎ょ綾ms += this.nOFFSET;
+ chip.n繝弱ｼ繝邨ゆｺ譎ょ綾ms += this.nOFFSET;
+ }
+
+ //chip.dbBPM = this.dbNowBPM;
+ //chip.dbSCROLL = this.dbNowSCROLL;
+ this.nNowRoll = this.nNowRollCount - 1;
+
+ //chip.n繝弱ｼ繝邨ゆｺ譎ょ綾ms = ms + ( (int) ( ( ( 0x271 * ( chip.n繝弱ｼ繝邨ゆｺ菴咲ｽｮ - n逋ｺ螢ｰ菴咲ｽｮ ) ) * dbBarLength ) / bpm ) );
+
+ #region[繝√ャ繝礼分蜿ｷ繧定ｨ倬鹸]
+ //switch(chip.n繧ｳ繝ｼ繧ｹ)
+ //{
+ // case 0:
+ // this.n騾｣謇薙メ繝繝誉temp[0] = this.nNowRoll;
+ // this.dbSCROLL_temp[0] = this.dbNowSCROLL;
+ // break;
+ // case 1:
+ // this.n騾｣謇薙メ繝繝誉temp[1] = this.nNowRoll;
+ // this.dbSCROLL_temp[1] = this.dbNowSCROLL;
+ // break;
+ // case 2:
+ // this.n騾｣謇薙メ繝繝誉temp[2] = this.nNowRoll;
+ // this.dbSCROLL_temp[2] = this.dbNowSCROLL;
+ // break;
+ //}
+
+ #endregion
+
+ continue;
+ }
+ case 0x9A:
+ {
+
+ if (this.bOFFSET縺ｮ蛟､縺後槭う繝翫せ縺ｧ縺ゅｋ)
+ {
+ chip.n逋ｺ螢ｰ譎ょ綾ms += this.nOFFSET;
+ }
+ //chip.n逋ｺ螢ｰ譎ょ綾ms += this.nDELAY;
+ //chip.dbBPM = this.dbNowBPM;
+ //chip.dbSCROLL = this.dbNowSCROLL;
+
+ #region[繝√ャ繝礼分蜿ｷ繧定ｨ倬鹸]
+ //鬚ｨ闊ｹ縺ｯ迴ｾ譎らせ縺ｧ縺ｯ譛ｪ螳溯｣縺ｮ縺溘ａ蜃ｦ逅縺励↑縺縲
+
+
+ //switch (chip.n繧ｳ繝ｼ繧ｹ)
+ //{
+ // case 0:
+ // if (this.listChip[this.n騾｣謇薙メ繝繝誉temp[0]].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x99) break;
+ // this.listChip[this.n騾｣謇薙メ繝繝誉temp[0]].n繝弱ｼ繝邨ゆｺ譎ょ綾ms = chip.n逋ｺ螢ｰ譎ょ綾ms;
+ // this.listChip[this.n騾｣謇薙メ繝繝誉temp[0]].dbSCROLL = this.dbSCROLL_temp[0];
+ // break;
+ // case 1:
+ // if (this.listChip[this.n騾｣謇薙メ繝繝誉temp[1]].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x99) break;
+ // this.listChip[this.n騾｣謇薙メ繝繝誉temp[1]].n繝弱ｼ繝邨ゆｺ譎ょ綾ms = chip.n逋ｺ螢ｰ譎ょ綾ms;
+ // this.listChip[this.n騾｣謇薙メ繝繝誉temp[1]].dbSCROLL = this.dbSCROLL_temp[1];
+ // break;
+ // case 2:
+ // if (this.listChip[this.n騾｣謇薙メ繝繝誉temp[2]].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x99) break;
+ // this.listChip[this.n騾｣謇薙メ繝繝誉temp[2]].n繝弱ｼ繝邨ゆｺ譎ょ綾ms = chip.n逋ｺ螢ｰ譎ょ綾ms;
+ // this.listChip[this.n騾｣謇薙メ繝繝誉temp[2]].dbSCROLL = this.dbSCROLL_temp[2];
+ // break;
+ //}
+
+ #endregion
+
+ //this.listChip[this.nNowRoll].n繝弱ｼ繝邨ゆｺ譎ょ綾ms = chip.n逋ｺ螢ｰ譎ょ綾ms;
+ //this.listChip[this.nNowRoll].dbSCROLL = this.dbNowSCROLL;
+ //this.listChip[this.nNowRoll].dbBPM = this.dbNowBPM;
+ continue;
+ }
+ case 0x9D:
+ {
+ //if ( this.listSCROLL.ContainsKey( chip.n謨ｴ謨ｰ蛟､_蜀驛ｨ逡ｪ蜿ｷ ) )
+ //{
+ //this.dbNowSCROLL = ( ( this.listSCROLL[ chip.n謨ｴ謨ｰ蛟､_蜀驛ｨ逡ｪ蜿ｷ ].n陦ｨ險倅ｸ翫ｮ逡ｪ蜿ｷ == 0 ) ? 0.0 : 1.0 ) + this.listSCROLL[ chip.n謨ｴ謨ｰ蛟､_蜀驛ｨ逡ｪ蜿ｷ ].dbSCROLL蛟､;
+ //}
+
+ //switch (chip.n繧ｳ繝ｼ繧ｹ)
+ //{
+ // case 0:
+ // this.dbNowSCROLL_Normal = this.dbNowSCROLL;
+ // this.n迴ｾ蝨ｨ縺ｮ繧ｳ繝ｼ繧ｹ = 0;
+ // break;
+ // case 1:
+ // this.dbNowSCROLL_Expert = this.dbNowSCROLL;
+ // this.n迴ｾ蝨ｨ縺ｮ繧ｳ繝ｼ繧ｹ = 1;
+ // break;
+ // case 2:
+ // this.dbNowSCROLL_Master = this.dbNowSCROLL;
+ // this.n迴ｾ蝨ｨ縺ｮ繧ｳ繝ｼ繧ｹ = 2;
+ // break;
+ //}
+
+ continue;
+ }
+ case 0xDC:
+ {
+ if (this.bOFFSET縺ｮ蛟､縺後槭う繝翫せ縺ｧ縺ゅｋ)
+ chip.n逋ｺ螢ｰ譎ょ綾ms += this.nOFFSET;
+ //if ( this.listDELAY.ContainsKey( chip.n謨ｴ謨ｰ蛟､_蜀驛ｨ逡ｪ蜿ｷ ) )
+ //{
+ // this.nDELAY = ( ( this.listDELAY[ chip.n謨ｴ謨ｰ蛟､_蜀驛ｨ逡ｪ蜿ｷ ].n陦ｨ險倅ｸ翫ｮ逡ｪ蜿ｷ == 0 ) ? 0 : 0 ) + this.listDELAY[ chip.n謨ｴ謨ｰ蛟､_蜀驛ｨ逡ｪ蜿ｷ ].nDELAY蛟､;
+ //}
+ continue;
+ }
+ case 0xDE:
+ {
+ if (this.bOFFSET縺ｮ蛟､縺後槭う繝翫せ縺ｧ縺ゅｋ)
+ {
+ chip.n逋ｺ螢ｰ譎ょ綾ms += this.nOFFSET;
+ chip.n蛻蟯先凾蛻ｻms += this.nOFFSET;
+ }
+ this.n迴ｾ蝨ｨ縺ｮ繧ｳ繝ｼ繧ｹ = chip.n繧ｳ繝ｼ繧ｹ;
+ continue;
+ }
+ case 0x52:
+ {
+ if (this.bOFFSET縺ｮ蛟､縺後槭う繝翫せ縺ｧ縺ゅｋ)
+ {
+ chip.n逋ｺ螢ｰ譎ょ綾ms += this.nOFFSET;
+ chip.n蛻蟯先凾蛻ｻms += this.nOFFSET;
+ }
+ this.n迴ｾ蝨ｨ縺ｮ繧ｳ繝ｼ繧ｹ = chip.n繧ｳ繝ｼ繧ｹ;
+ continue;
+ }
+ case 0xDF:
+ {
+ if (this.bOFFSET縺ｮ蛟､縺後槭う繝翫せ縺ｧ縺ゅｋ)
+ chip.n逋ｺ螢ｰ譎ょ綾ms += this.nOFFSET;
+ //if ( this.listBRANCH.ContainsKey( chip.n謨ｴ謨ｰ蛟､_蜀驛ｨ逡ｪ蜿ｷ ) )
+ //{
+ //this.listBRANCH[chip.n謨ｴ謨ｰ蛟､_蜀驛ｨ逡ｪ蜿ｷ].db蛻蟯先凾髢杜s = chip.n逋ｺ螢ｰ譎ょ綾ms + ( this.bOFFSET縺ｮ蛟､縺後槭う繝翫せ縺ｧ縺ゅｋ ? this.nOFFSET : 0 );
+ //}
+
+ continue;
+ }
+ case 0xE0:
+ {
+ //if (this.bOFFSET縺ｮ蛟､縺後槭う繝翫せ縺ｧ縺ゅｋ)
+ // chip.n逋ｺ螢ｰ譎ょ綾ms += this.nOFFSET;
+
+ //chip.dbBPM = this.dbNowBPM;
+ //chip.dbSCROLL = this.dbNowSCROLL;
+ //if( chip.n謨ｴ謨ｰ蛟､_蜀驛ｨ逡ｪ蜿ｷ == 1 )
+ // this.bBarLine = false;
+ //else
+ // this.bBarLine = true;
+ continue;
+ }
+ default:
+ {
+ if (this.bOFFSET縺ｮ蛟､縺後槭う繝翫せ縺ｧ縺ゅｋ)
+ chip.n逋ｺ螢ｰ譎ょ綾ms += this.nOFFSET;
+ //chip.n逋ｺ螢ｰ譎ょ綾ms += this.nDELAY;
+ chip.dbBPM = this.dbNowBPM;
+ //chip.dbSCROLL = this.dbNowSCROLL;
+ continue;
+ }
+ }
+ }
+ if (this.db蜀咲函騾溷ｺｦ > 0.0)
+ {
+ double _db蜀咲函騾溷ｺｦ = (TJAPlayer3.DTXVmode.Enabled) ? this.dbDTXVPlaySpeed : this.db蜀咲函騾溷ｺｦ;
+ foreach (CChip chip in this.listChip)
+ {
+ chip.n逋ｺ螢ｰ譎ょ綾ms = (int)(((double)chip.n逋ｺ螢ｰ譎ょ綾ms) / _db蜀咲函騾溷ｺｦ);
+ chip.db逋ｺ螢ｰ譎ょ綾ms = (((double)chip.n逋ｺ螢ｰ譎ょ綾ms) / _db蜀咲函騾溷ｺｦ);
+ chip.n繝弱ｼ繝邨ゆｺ譎ょ綾ms = (int)(((double)chip.n繝弱ｼ繝邨ゆｺ譎ょ綾ms) / _db蜀咲函騾溷ｺｦ);
+ }
+ }
+ #endregion
+ //span = (TimeSpan) ( DateTime.Now - timeBeginLoad );
+ //Trace.TraceInformation( "逋ｺ螢ｰ譎ょ綾險育ｮ: {0}", span.ToString() );
+ //timeBeginLoad = DateTime.Now;
+
+ #region[listlyric繧呈凾髢馴縺ｫ荳ｦ縺ｳ譖ｿ縺医]
+ this.listLyric2 = tmplistlyric;
+ this.listLyric2.Sort((a, b) => a.Time.CompareTo(b.Time));
+ #endregion
+
+ this.nBGMAdjust = 0;
+ this.t蜷閾ｪ蜍募咲函髻ｳ繝√ャ繝励ｮ蜀咲函譎ょ綾繧貞､画峩縺吶ｋ(nBGMAdjust);
+ //span = (TimeSpan) ( DateTime.Now - timeBeginLoad );
+ //Trace.TraceInformation( "蜀咲函譎ょ綾螟画峩: {0}", span.ToString() );
+ //timeBeginLoad = DateTime.Now;
+
+ #region [ 蜿ｯ隕悶メ繝繝玲焚繧ｫ繧ｦ繝ｳ繝 ]
+ for (int n = 0; n < 14; n++)
+ {
+ this.n蜿ｯ隕悶メ繝繝玲焚[n] = 0;
+ }
+ foreach (CChip chip in this.listChip)
+ {
+ int c = chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ;
+ if ((0x11 <= c) && (c <= 0x14))
+ {
+ if (c == 0x11 || c == 0x13)
+ this.n蜿ｯ隕悶メ繝繝玲焚.Taiko_Red++;
+ else if (c == 0x12 || c == 0x14)
+ this.n蜿ｯ隕悶メ繝繝玲焚.Taiko_Blue++;
+ }
+ }
+ #endregion
+ //span = (TimeSpan) ( DateTime.Now - timeBeginLoad );
+ //Trace.TraceInformation( "蜿ｯ隕悶メ繝繝玲焚繧ｫ繧ｦ繝ｳ繝 {0}", span.ToString() );
+ //timeBeginLoad = DateTime.Now;
+ #region [ 繝√ャ繝励ｮ遞ｮ鬘槭ｒ蛻鬘槭＠縲∝ｯｾ蠢懊☆繧九ヵ繝ｩ繧ｰ繧堤ｫ九※繧 ]
+ foreach (CChip chip in this.listChip)
+ {
+ if ((chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x01 && this.listWAV.TryGetValue(chip.n謨ｴ謨ｰ蛟､_蜀驛ｨ逡ｪ蜿ｷ, out CWAV cwav)) && !cwav.list縺薙ｮWAV繧剃ｽｿ逕ｨ縺吶ｋ繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ縺ｮ髮蜷.Contains(chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ))
+ {
+ cwav.list縺薙ｮWAV繧剃ｽｿ逕ｨ縺吶ｋ繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ縺ｮ髮蜷.Add(chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ);
+
+ int c = chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ >> 4;
+ switch (c)
+ {
+ case 0x01:
+ cwav.bIsDrumsSound = true; break;
+ case 0x02:
+ cwav.bIsGuitarSound = true; break;
+ case 0x0A:
+ cwav.bIsBassSound = true; break;
+ case 0x06:
+ case 0x07:
+ case 0x08:
+ case 0x09:
+ cwav.bIsSESound = true; break;
+ case 0x00:
+ if (chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x01)
+ {
+ cwav.bIsBGMSound = true; break;
+ }
+ break;
+ }
+ }
+ }
+ #endregion
+ //span = (TimeSpan) ( DateTime.Now - timeBeginLoad );
+ //Trace.TraceInformation( "ch逡ｪ蜿ｷ髮蜷育｢ｺ隱: {0}", span.ToString() );
+ //timeBeginLoad = DateTime.Now;
+ #region[ seNotes險育ｮ ]
+ if (this.listBRANCH.Count != 0)
+ this.tSetSenotes_branch();
+ else
+ this.tSetSenotes();
+
+ #endregion
+ #region [ bLogDTX隧ｳ邏ｰ繝ｭ繧ｰ蜃ｺ蜉 ]
+ if (TJAPlayer3.ConfigIni.bLogDTX隧ｳ邏ｰ繝ｭ繧ｰ蜃ｺ蜉)
+ {
+ foreach (CWAV cwav in this.listWAV.Values)
+ {
+ Trace.TraceInformation(cwav.ToString());
+ }
+ foreach (CAVI cavi in this.listAVI.Values)
+ {
+ Trace.TraceInformation(cavi.ToString());
+ }
+ foreach (CBPM cbpm3 in this.listBPM.Values)
+ {
+ Trace.TraceInformation(cbpm3.ToString());
+ }
+ foreach (CChip chip in this.listChip)
+ {
+ Trace.TraceInformation(chip.ToString());
+ }
+ }
+ #endregion
+
+ //繧ｽ繝ｼ繝医▲縺ｽ縺
+ //this.listChip.Sort(delegate(CChip pchipA, CChip pchipB) { return pchipA.n逋ｺ螢ｰ譎ょ綾ms - pchipB.n逋ｺ螢ｰ譎ょ綾ms; } );
+ //Random ran1 = new Random();
+ //for (int n = 0; n < this.listChip.Count; n++ )
+ //{
+
+ // if (CDTXMania.ConfigIni.bHispeedRandom)
+ // {
+
+ // int nRan = ran1.Next(5, 40);
+ // this.listChip[n].dbSCROLL = nRan / 10.0;
+ // }
+ //}
+ int n謨ｴ謨ｰ蛟､邂｡逅 = 0;
+ foreach (CChip chip in this.listChip)
+ {
+ if (chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ != 0x54)
+ chip.n謨ｴ謨ｰ蛟､ = n謨ｴ謨ｰ蛟､邂｡逅;
+ n謨ｴ謨ｰ蛟､邂｡逅++;
+ }
+
+ }
+ }
+ }
+ }
+
+ private string t繧ｳ繝｡繝ｳ繝医ｒ蜑企勁縺吶ｋ(string input)
+ {
+ string strOutput = Regex.Replace(input, @" *//.*", ""); //2017.01.28 DD 繧ｳ繝｡繝ｳ繝亥燕縺ｮ繧ｹ繝壹ｼ繧ｹ繧ょ炎髯､縺吶ｋ繧医≧縺ｫ菫ｮ豁｣
+
+ return strOutput;
+ }
+
+ private string[] t繧ｳ繝槭Φ繝芽｡後ｒ蜑企勁縺励◆TJA繧定ｿ斐☆(string[] input)
+ {
+ return this.t繧ｳ繝槭Φ繝芽｡後ｒ蜑企勁縺励◆TJA繧定ｿ斐☆(input, 0);
+ }
+
+ private string[] t繧ｳ繝槭Φ繝芽｡後ｒ蜑企勁縺励◆TJA繧定ｿ斐☆(string[] input, int nMode)
+ {
+ var sb = new StringBuilder();
+
+ // 18/11/11 AioiLight 隴憺擇縺ｫSpace縲√せ繝壹ｼ繧ｹ縲ゝab遲峨′蜈･縺｣縺ｦ縺繧九→縺翫°縺励￥縺ｪ繧九ｮ縺ｧ菫ｮ豁｣縲
+ // 螟壼繧ｳ繝槭Φ繝峨ｂ繧ｹ繝壹ｼ繧ｹ縺梧栢縺九ｌ縺｡繧縺｣縺ｦ縺繧九′縲√さ繝槭Φ繝芽｡後ｒ髯､縺剰ｭ憺擇繧定ｿ斐☆縺ｮ縺ｧ螟ｧ荳亥､ｫ(縺溘ｶ繧)縲
+ for (int i = 0; i < input.Length; i++)
+ {
+ input[i] = input[i].Trim();
+ }
+
+ for (int n = 0; n < input.Length; n++)
+ {
+ if (nMode == 0)
+ {
+ if (!string.IsNullOrEmpty(input[n]) && this.CharConvertNote(input[n].Substring(0, 1)) != -1)
+ {
+ sb.Append(input[n] + "\n");
+ }
+ }
+ else if (nMode == 1)
+ {
+ if (!string.IsNullOrEmpty(input[n]) && (input[n].Substring(0, 1) == "#" || this.CharConvertNote(input[n].Substring(0, 1)) != -1))
+ {
+ if (input[n].StartsWith("BALLOON") || input[n].StartsWith("BPM"))
+ {
+ //Aｽ曦縺ｧ蟋九∪繧句多莉､縺悟炎髯､縺輔ｌ縺ｪ縺荳榊ｷ蜷医ｮ蟇ｾ遲
+ }
+ else
+ {
+ sb.Append(input[n] + "\n");
+ }
+ }
+ }
+ else if (nMode == 2)
+ {
+ if (!string.IsNullOrEmpty(input[n]) && this.CharConvertNote(input[n].Substring(0, 1)) != -1)
+ {
+ if (input[n].StartsWith("BALLOON") || input[n].StartsWith("BPM"))
+ {
+ //Aｽ曦縺ｧ蟋九∪繧句多莉､縺悟炎髯､縺輔ｌ縺ｪ縺荳榊ｷ蜷医ｮ蟇ｾ遲
+ }
+ else
+ {
+ sb.Append(input[n] + "\n");
+ }
+ }
+ else
+ {
+ if (input[n].StartsWith("#BRANCHSTART") || input[n] == "#N" || input[n] == "#E" || input[n] == "#M")
+ {
+ sb.Append(input[n] + "\n");
+ }
+
+ }
+ }
+ }
+
+ string[] strOutput = sb.ToString().Split(this.dlmtEnter, StringSplitOptions.None);
+
+ return strOutput;
+ }
+
+ private string[] t遨ｺ縺ｮstring驟榊励ｒ隧ｰ繧√◆string驟榊励ｒ霑斐☆(string[] input)
+ {
+ var sb = new StringBuilder();
+
+ for (int n = 0; n < input.Length; n++)
+ {
+ if (!string.IsNullOrEmpty(input[n]))
+ {
+ sb.Append(input[n] + "\n");
+ }
+ }
+
+ string[] strOutput = sb.ToString().Split(this.dlmtEnter, StringSplitOptions.None);
+
+ return strOutput;
+ }
+
+ private string StringArrayToString(string[] input)
+ {
+ return this.StringArrayToString(input, "");
+ }
+ private string StringArrayToString(string[] input, string str繝繝ｪ繝溘ち譁蟄)
+ {
+ var sb = new StringBuilder();
+
+ for (int n = 0; n < input.Length; n++)
+ {
+ sb.Append(input[n] + str繝繝ｪ繝溘ち譁蟄);
+ }
+
+ return sb.ToString();
+ }
+
+ ///
+ ///
+ ///
+ ///
+ /// 1蟆冗ｯ蜀縺ｮ譁蟄玲焚
+ private int t1蟆冗ｯ縺ｮ譁蟄玲焚繧偵き繧ｦ繝ｳ繝医☆繧(string InputText)
+ {
+ return InputText.Length - 1;
+ }
+
+ ///
+ ///
+ ///
+ ///
+ /// 1蟆冗ｯ蜀縺ｮ譁蟄玲焚
+ private void t1蟆冗ｯ縺ｮ譁蟄玲焚繧偵き繧ｦ繝ｳ繝医＠縺ｦ繝ｪ繧ｹ繝医↓霑ｽ蜉縺吶ｋ(string InputText)
+ {
+ int nCount = 0;
+
+ if (InputText.StartsWith("#BRANCHSTART"))
+ {
+ this.nLineCountTemp = this.n迴ｾ蝨ｨ縺ｮ蟆冗ｯ謨ｰ;
+ return;
+ }
+ else if (InputText.StartsWith("#N"))
+ {
+ this.nLineCountCourseTemp = ECourse.eNormal;
+ this.n迴ｾ蝨ｨ縺ｮ蟆冗ｯ謨ｰ = this.nLineCountTemp;
+ return;
+ }
+ else if (InputText.StartsWith("#E"))
+ {
+ this.nLineCountCourseTemp = ECourse.eExpert;
+ this.n迴ｾ蝨ｨ縺ｮ蟆冗ｯ謨ｰ = this.nLineCountTemp;
+ return;
+ }
+ else if (InputText.StartsWith("#M"))
+ {
+ this.nLineCountCourseTemp = ECourse.eMaster;
+ this.n迴ｾ蝨ｨ縺ｮ蟆冗ｯ謨ｰ = this.nLineCountTemp;
+ return;
+ }
+
+
+ var line = new CLine();
+ line.n繧ｳ繝ｼ繧ｹ = this.nLineCountCourseTemp;
+ line.n譁蟄玲焚 = InputText.Length - 1;
+ line.n蟆冗ｯ逡ｪ蜿ｷ = this.n迴ｾ蝨ｨ縺ｮ蟆冗ｯ謨ｰ;
+
+ this.listLine.Add(line);
+
+ this.n迴ｾ蝨ｨ縺ｮ蟆冗ｯ謨ｰ++;
+
+ }
+
+ ///
+ /// 0:謾ｹ陦梧枚蟄励ｒ蜑企勁縺励※縲√ョ繝ｪ繝溘ち縺ｨ縺励※繧ｹ繝壹ｼ繧ｹ繧貞･繧後ｋ縲(霑斐ｊ蛟､:string)
+ /// 1:謾ｹ陦梧枚蟄励ｒ蜑企勁縲√＆繧峨↓Split縺励※霑斐☆(霑斐ｊ蛟､:string[n])
+ ///
+ ///
+ ///
+ ///
+ private object str謾ｹ陦梧枚蟄励ｒ蜑企勁縺吶ｋ(string strInput, int nMode)
+ {
+ string str = "";
+ str = strInput.Replace(Environment.NewLine, "\n");
+ str = str.Replace('\t', ' ');
+
+ if (nMode == 0)
+ {
+ str = str.Replace("\n", " ");
+ }
+ else if (nMode == 1)
+ {
+ str = str + "\n";
+
+ string[] strArray;
+ strArray = str.Split(this.dlmtEnter, StringSplitOptions.RemoveEmptyEntries);
+
+ return strArray;
+ }
+
+ return str;
+ }
+
+ ///
+ /// 繧ｳ繝ｼ繧ｹ縺斐→縺ｫ隴憺擇繧貞蜑ｲ縺吶ｋ縲
+ ///
+ ///
+ /// 蜷繧ｳ繝ｼ繧ｹ縺ｮ隴憺擇(string[5])
+ private string[] t繧ｳ繝ｼ繧ｹ縺ｧ隴憺擇繧貞蜑ｲ縺吶ｋ(string strTJA)
+ {
+ string[] strCourseTJA = new string[(int)Difficulty.Total];
+
+ if (strTJA.IndexOf("COURSE", 0) != -1)
+ {
+ //tja蜀縺ｫ縲靴OURSE縲阪′縺ゅｌ縺ｰ縺薙％繧剃ｽｿ縺縲
+ string[] strTemp = strTJA.Split(this.dlmtCOURSE, StringSplitOptions.RemoveEmptyEntries);
+
+ for (int n = 1; n < strTemp.Length; n++)
+ {
+ int nCourse = 0;
+ string nNC = "";
+ while (strTemp[n].Substring(0, 1) != "\n") //2017.01.29 DD COURSE蜊倩ｪ櫁｡ｨ險倥↓蟇ｾ蠢
+ {
+ nNC += strTemp[n].Substring(0, 1);
+ strTemp[n] = strTemp[n].Remove(0, 1);
+ }
+
+ if (this.strConvertCourse(nNC) != -1)
+ {
+ nCourse = this.strConvertCourse(nNC);
+ strCourseTJA[nCourse] = strTemp[n];
+ }
+ else
+ {
+
+ }
+ //strCourseTJA[ ];
+
+ }
+ }
+ else
+ {
+ strCourseTJA[3] = strTJA;
+ }
+
+ return strCourseTJA;
+ }
+
+ private static readonly Regex regexForPrefixingCommaStartingLinesWithZero = new Regex(@"^,", RegexOptions.Multiline | RegexOptions.Compiled);
+ private static readonly Regex regexForStrippingHeadingLines = new Regex(
+ @"^(?!(TITLE|LEVEL|BPM|WAVE|OFFSET|BALLOON|EXAM1|EXAM2|EXAM3|EXAM4|RENREN22|RENREN23|RENREN32|RENREN33|RENREN42|RENREN43|BALLOONNOR|BALLOONEXP|BALLOONMAS|SONGVOL|SEVOL|SCOREINIT|SCOREDIFF|COURSE|STYLE|GAME|LIFE|DEMOSTART|SIDE|SUBTITLE|SCOREMODE|GENRE|MOVIEOFFSET|BGIMAGE|BGMOVIE|HIDDENBRANCH|GAUGEINCR|LYRICFILE|#HBSCROLL|#BMSCROLL)).+\n",
+ RegexOptions.Multiline | RegexOptions.Compiled);
+
+ ///
+ /// 譁ｰ蝙九
+ /// 笳区悴螳溯｣
+ /// _縲靴OURSE縲榊ｮ夂ｾｩ縺檎┌縺隴憺擇縺ｯ譛ｪ蟇ｾ蠢
+ /// 縲竊致er2015082200縺ｧ蟇ｾ蠢懷ｮ御ｺ縲
+ ///
+ ///
+ /// 隴憺擇縺ｮ繝繝ｼ繧ｿ
+ private void t蜈･蜉媽V4(string strInput, int difficulty)
+ {
+ if (!String.IsNullOrEmpty(strInput)) //遨ｺ縺ｪ繧蛾壹＆縺ｪ縺
+ {
+ //StreamWriter stream = null;
+ //bool bLog = true;
+ //try
+ //{
+ // stream = new StreamWriter("noteTest.txt", false);
+ //}
+ //catch (Exception ex)
+ //{
+ // Trace.TraceError( ex.StackTrace );
+ //}
+
+ //2017.01.31 DD 繧ｫ繝ｳ繝槭ｮ縺ｿ縺ｮ陦後ｒ0,縺ｫ鄂ｮ縺肴鋤縺
+ strInput = regexForPrefixingCommaStartingLinesWithZero.Replace(strInput, "0,");
+
+ //2017.02.03 DD 繝倥ャ繝蜀縺ｫ縺ゅｋ蜻ｽ莉､莉･螟悶ｮ譁蟄怜励ｒ蜑企勁
+ var startIndex = strInput.IndexOf("#START");
+ if (startIndex < 0)
+ {
+ Trace.TraceWarning($"#START蜻ｽ莉､縺悟ｰ代↑縺上→繧1縺､縺ｯ蠢隕√〒縺吶 ({str繝輔ぃ繧､繝ｫ蜷阪ｮ邨ｶ蟇ｾ繝代せ})");
+ }
+ string strInputHeader = strInput.Remove(startIndex);
+ strInput = strInput.Remove(0, startIndex);
+ strInputHeader = regexForStrippingHeadingLines.Replace(strInputHeader, "");
+ strInput = strInputHeader + "\n" + strInput;
+
+ //縺ｩ縺縺帑ｽｿ繧上↑縺縺ｮ縺ｧ蜈医↓Split縺励※繧ｳ繝｡繝ｳ繝医ｒ蜑企勁縲
+ var strSplit縺励◆隴憺擇 = (string[])this.str謾ｹ陦梧枚蟄励ｒ蜑企勁縺吶ｋ(strInput, 1);
+ for (int i = 0; strSplit縺励◆隴憺擇.Length > i; i++)
+ {
+ strSplit縺励◆隴憺擇[i] = this.t繧ｳ繝｡繝ｳ繝医ｒ蜑企勁縺吶ｋ(strSplit縺励◆隴憺擇[i]);
+ }
+ //遨ｺ縺ｮstring驟榊励ｒ隧ｰ繧√ｋ
+ strSplit縺励◆隴憺擇 = this.t遨ｺ縺ｮstring驟榊励ｒ隧ｰ繧√◆string驟榊励ｒ霑斐☆(strSplit縺励◆隴憺擇);
+
+ #region[繝倥ャ繝]
+
+ //2015.05.21 kairera0467
+ //繝倥ャ繝縺ｮ隱ｭ縺ｿ霎ｼ縺ｿ縺ｯ隴憺擇蜈ｨ菴薙°繧芽ｩｲ蠖薙☆繧句多莉､繧呈爾縺吶
+ //蟆代＠蜃ｦ逅縺碁≦縺上↑繧句庄閭ｽ諤ｧ縺ｯ縺ゅｋ縺後√％縺薙ｯ豁｣遒ｺ諤ｧ繧帝崎ｦ悶☆繧九
+ //轤ｹ謨ｰ縺ｪ縺ｩ縺ｮ謖螳壹ｯ蠕後°繧牙推繧ｳ繝ｼ繧ｹ縺ｧ陦後≧縺ｮ縺ｧ蝠城｡後ｯ辟｡縺縺繧阪≧縲
+
+ //Split縺励◆繝倥ャ繝縺ｮLength縺ｮ蝗樊焚縺縺代’or縺ｧ蝗槭＠縺ｦ蜷遞ｮ諠蝣ｱ繧定ｪｭ縺ｿ蜿悶▲縺ｦ縺縺上
+ for (int i = 0; strSplit縺励◆隴憺擇.Length > i; i++)
+ {
+ this.t蜈･蜉媽陦瑚ｧ｣譫舌倥ャ繝(strSplit縺励◆隴憺擇[i]);
+ }
+ #endregion
+
+ #region[隴憺擇]
+
+ int n隱ｭ縺ｿ霎ｼ繧繧ｳ繝ｼ繧ｹ = 3;
+ int n隴憺擇謨ｰ = 0; //2017.07.22 kairera0467 tja縺ｫ蜷ｫ縺ｾ繧後ｋ隴憺擇縺ｮ謨ｰ
+
+
+ bool b譁ｰ蜃ｦ逅 = false;
+
+ //縺ｾ縺壹ｯ繧ｳ繝ｼ繧ｹ縺斐→縺ｫ隴憺擇繧貞蜑ｲ縲
+ strSplit縺励◆隴憺擇 = this.t繧ｳ繝ｼ繧ｹ縺ｧ隴憺擇繧貞蜑ｲ縺吶ｋ(this.StringArrayToString(strSplit縺励◆隴憺擇, "\n"));
+ string strTest = "";
+ //蟄伜惠縺吶ｋ縺九ｮ繝輔Λ繧ｰ菴懈舌
+ for (int i = 0; i < strSplit縺励◆隴憺擇.Length; i++)
+ {
+ if (!String.IsNullOrEmpty(strSplit縺励◆隴憺擇[i]))
+ {
+ this.b隴憺擇縺悟ｭ伜惠縺吶ｋ[i] = true;
+ n隴憺擇謨ｰ++;
+ }
+ else
+ this.b隴憺擇縺悟ｭ伜惠縺吶ｋ[i] = false;
+ }
+ #region[ 隱ｭ縺ｿ霎ｼ縺ｾ縺帙ｋ繧ｳ繝ｼ繧ｹ繧呈ｱｺ螳 ]
+ if (this.b隴憺擇縺悟ｭ伜惠縺吶ｋ[difficulty] == false)
+ {
+ n隱ｭ縺ｿ霎ｼ繧繧ｳ繝ｼ繧ｹ = difficulty;
+ n隱ｭ縺ｿ霎ｼ繧繧ｳ繝ｼ繧ｹ++;
+ for (int n = 1; n < (int)Difficulty.Total; n++)
+ {
+ if (this.b隴憺擇縺悟ｭ伜惠縺吶ｋ[n隱ｭ縺ｿ霎ｼ繧繧ｳ繝ｼ繧ｹ] == false)
+ {
+ n隱ｭ縺ｿ霎ｼ繧繧ｳ繝ｼ繧ｹ++;
+ if (n隱ｭ縺ｿ霎ｼ繧繧ｳ繝ｼ繧ｹ > (int)Difficulty.Total - 1)
+ n隱ｭ縺ｿ霎ｼ繧繧ｳ繝ｼ繧ｹ = 0;
+ }
+ else
+ break;
+ }
+ }
+ else
+ n隱ｭ縺ｿ霎ｼ繧繧ｳ繝ｼ繧ｹ = difficulty;
+ #endregion
+
+ //謖螳壹＠縺溘さ繝ｼ繧ｹ縺ｮ隴憺擇縺ｮ蜻ｽ莉､繧呈ｶ亥悉縺吶ｋ縲
+ strSplit縺励◆隴憺擇[n隱ｭ縺ｿ霎ｼ繧繧ｳ繝ｼ繧ｹ] = CDTXStyleExtractor.t繧ｻ繝繧ｷ繝ｧ繝ｳ隴憺擇縺後≠繧(
+ strSplit縺励◆隴憺擇[n隱ｭ縺ｿ霎ｼ繧繧ｳ繝ｼ繧ｹ],
+ TJAPlayer3.ConfigIni.nPlayerCount > 1 ? (this.nPlayerSide + 1) : 0,
+ this.str繝輔ぃ繧､繝ｫ蜷阪ｮ邨ｶ蟇ｾ繝代せ);
+
+ //蜻ｽ莉､繧偵☆縺ｹ縺ｦ豸亥悉縺励◆隴憺擇
+ var str蜻ｽ莉､豸亥悉隴憺擇 = strSplit縺励◆隴憺擇[n隱ｭ縺ｿ霎ｼ繧繧ｳ繝ｼ繧ｹ].Split(this.dlmtEnter, StringSplitOptions.RemoveEmptyEntries);
+ //if( bLog && stream != null )
+ //{
+ // stream.WriteLine( "-------------------------------------------------" );
+ // stream.WriteLine( ">>this.str蜻ｽ莉､豸亥悉隴憺擇(繧ｳ繝槭Φ繝牙炎髯､蜑)" );
+ // for( int i = 0; i < this.str蜻ｽ莉､豸亥悉隴憺擇.Length; i++ )
+ // {
+ // stream.WriteLine( this.str蜻ｽ莉､豸亥悉隴憺擇[ i ] );
+ // }
+ // stream.WriteLine( "-------------------------------------------------" );
+ //}
+ str蜻ｽ莉､豸亥悉隴憺擇 = this.t繧ｳ繝槭Φ繝芽｡後ｒ蜑企勁縺励◆TJA繧定ｿ斐☆(str蜻ｽ莉､豸亥悉隴憺擇, 2);
+
+ //if( bLog && stream != null )
+ //{
+ // stream.WriteLine( "-------------------------------------------------" );
+ // stream.WriteLine( ">>this.str蜻ｽ莉､豸亥悉隴憺擇" );
+ // for( int i = 0; i < this.str蜻ｽ莉､豸亥悉隴憺擇.Length; i++ )
+ // {
+ // stream.WriteLine( this.str蜻ｽ莉､豸亥悉隴憺擇[ i ] );
+ // }
+ // stream.WriteLine( "-------------------------------------------------" );
+ //}
+
+
+ //縺薙％縺ｧ1陦後ｮ譁蟄玲焚繧偵き繧ｦ繝ｳ繝医る榊励↓縺励※霑斐☆縲
+ var strSplit隱ｭ縺ｿ霎ｼ繧繧ｳ繝ｼ繧ｹ = strSplit縺励◆隴憺擇[n隱ｭ縺ｿ霎ｼ繧繧ｳ繝ｼ繧ｹ].Split(this.dlmtEnter, StringSplitOptions.RemoveEmptyEntries);
+ string str = "";
+ try
+ {
+ if (n隴憺擇謨ｰ > 0)
+ {
+ //2017.07.22 kairera0467 隴憺擇縺2縺､莉･荳翫≠繧句ｴ蜷医ｯCOURSE莉･荳九ｮBALLOON蜻ｽ莉､繧剃ｽｿ縺
+ this.listBalloon.Clear();
+ this.listBalloon_Normal.Clear();
+ this.listBalloon_Expert.Clear();
+ this.listBalloon_Master.Clear();
+ this.listBalloon_Normal_謨ｰ蛟､邂｡逅 = 0;
+ this.listBalloon_Expert_謨ｰ蛟､邂｡逅 = 0;
+ this.listBalloon_Master_謨ｰ蛟､邂｡逅 = 0;
+ }
+
+ for (int i = 0; i < strSplit隱ｭ縺ｿ霎ｼ繧繧ｳ繝ｼ繧ｹ.Length; i++)
+ {
+ if (!String.IsNullOrEmpty(strSplit隱ｭ縺ｿ霎ｼ繧繧ｳ繝ｼ繧ｹ[i]))
+ {
+ this.t髮｣譏灘ｺｦ蛻･繝倥ャ繝(strSplit隱ｭ縺ｿ霎ｼ繧繧ｳ繝ｼ繧ｹ[i]);
+ }
+ }
+ for (int i = 0; i < str蜻ｽ莉､豸亥悉隴憺擇.Length; i++)
+ {
+ if (str蜻ｽ莉､豸亥悉隴憺擇[i].IndexOf(',', 0) == -1 && !String.IsNullOrEmpty(str蜻ｽ莉､豸亥悉隴憺擇[i]))
+ {
+ if (str蜻ｽ莉､豸亥悉隴憺擇[i].Substring(0, 1) == "#")
+ {
+ this.t1蟆冗ｯ縺ｮ譁蟄玲焚繧偵き繧ｦ繝ｳ繝医＠縺ｦ繝ｪ繧ｹ繝医↓霑ｽ蜉縺吶ｋ(str + str蜻ｽ莉､豸亥悉隴憺擇[i]);
+ }
+
+ if (this.CharConvertNote(str蜻ｽ莉､豸亥悉隴憺擇[i].Substring(0, 1)) != -1)
+ str += str蜻ｽ莉､豸亥悉隴憺擇[i];
+ }
+ else
+ {
+ this.t1蟆冗ｯ縺ｮ譁蟄玲焚繧偵き繧ｦ繝ｳ繝医＠縺ｦ繝ｪ繧ｹ繝医↓霑ｽ蜉縺吶ｋ(str + str蜻ｽ莉､豸亥悉隴憺擇[i]);
+ str = "";
+ }
+ }
+ }
+ catch (Exception ex)
+ {
+ Trace.TraceError(ex.ToString());
+ Trace.TraceError("萓句､悶′逋ｺ逕溘＠縺ｾ縺励◆縺悟ｦ逅繧堤ｶ咏ｶ壹＠縺ｾ縺吶 (9e401212-0b78-4073-88d0-f7e791f36a91)");
+ }
+
+ //if( bLog && stream != null )
+ //{
+ // stream.WriteLine( "-------------------------------------------------" );
+ // stream.WriteLine( ">>this.str蜻ｽ莉､豸亥悉隴憺擇 (蜻ｽ莉､豸亥悉縺励◆蠕)" );
+ // for( int i = 0; i < this.str蜻ｽ莉､豸亥悉隴憺擇.Length; i++ )
+ // {
+ // stream.WriteLine( this.str蜻ｽ莉､豸亥悉隴憺擇[ i ] );
+ // }
+ // stream.WriteLine( "-------------------------------------------------" );
+ //}
+
+ //隱ｭ縺ｿ霎ｼ縺ｿ驛ｨ蛻譛ｬ菴薙↓貂｡縺呵ｭ憺擇繧剃ｽ懈舌
+ //0:繝倥ャ繝繝ｼ諠蝣ｱ 1:#START莉･髯 縺ｨ縺ｪ繧九ょ区焚縺ｮ螳夂ｾｩ縺ｯ蠕後°繧峨＆繧後ｋ縺溘ａ縲√％縺薙〒縺ｯ逵∫払縲
+ var strSplit縺励◆蠕後ｮ隴憺擇 = strSplit隱ｭ縺ｿ霎ｼ繧繧ｳ繝ｼ繧ｹ; //strSplit縺励◆隴憺擇[ n隱ｭ縺ｿ霎ｼ繧繧ｳ繝ｼ繧ｹ ].Split( this.dlmtEnter, StringSplitOptions.RemoveEmptyEntries );
+ strSplit縺励◆蠕後ｮ隴憺擇 = this.t繧ｳ繝槭Φ繝芽｡後ｒ蜑企勁縺励◆TJA繧定ｿ斐☆(strSplit縺励◆蠕後ｮ隴憺擇, 1);
+ //string str蜻ｽ莉､豸亥悉隴憺擇temp = this.StringArrayToString( this.str蜻ｽ莉､豸亥悉隴憺擇 );
+ //string[] strDelimiter = { "," };
+ //this.str蜻ｽ莉､豸亥悉隴憺擇 = str蜻ｽ莉､豸亥悉隴憺擇temp.Split( strDelimiter, StringSplitOptions.RemoveEmptyEntries );
+
+ //if( bLog && stream != null )
+ //{
+ // stream.WriteLine( "-------------------------------------------------" );
+ // stream.WriteLine( ">>this.str蜻ｽ莉､豸亥悉隴憺擇 (Split縺励◆蠕)" );
+ // for( int i = 0; i < this.str蜻ｽ莉､豸亥悉隴憺擇.Length; i++ )
+ // {
+ // stream.WriteLine( this.str蜻ｽ莉､豸亥悉隴憺擇[ i ] );
+ // }
+ // stream.WriteLine( "-------------------------------------------------" );
+ //}
+
+ this.n迴ｾ蝨ｨ縺ｮ蟆冗ｯ謨ｰ = 1;
+ try
+ {
+ #region[ 譛蛻昴ｮ蜃ｦ逅 ]
+ //1蟆冗ｯ縺ｮ譎る俣繧呈諺蜈･縺励※髢句ｧ区凾髢薙ｒ隱ｿ遽縲
+ this.dbNowTime += ((15000.0 / 120.0 * (4.0 / 4.0)) * 16.0);
+ //this.dbNowBMScollTime += (( this.dbBarLength ) * 16.0 );
+ #endregion
+ //string strWrite = "";
+ for (int i = 0; strSplit縺励◆蠕後ｮ隴憺擇.Length > i; i++)
+ {
+ str = strSplit縺励◆蠕後ｮ隴憺擇[i];
+ //strWrite += str;
+ //if( !str.StartsWith( "#" ) && !string.IsNullOrEmpty( this.strTemp ) )
+ //{
+ // str = this.strTemp + str;
+ //}
+
+ this.t蜈･蜉媽陦瑚ｧ｣譫占ｭ憺擇_V4(str);
+
+ if (!String.IsNullOrEmpty(strSplit隱ｭ縺ｿ霎ｼ繧繧ｳ繝ｼ繧ｹ[i]))
+ this.tDanExamLoad(strSplit隱ｭ縺ｿ霎ｼ繧繧ｳ繝ｼ繧ｹ[i]);
+ }
+ }
+ catch (Exception ex)
+ {
+ Trace.TraceError(ex.ToString());
+ Trace.TraceError("萓句､悶′逋ｺ逕溘＠縺ｾ縺励◆縺悟ｦ逅繧堤ｶ咏ｶ壹＠縺ｾ縺吶 (2da1e880-6b63-4e82-b018-bf18c3568335)");
+ }
+ //if( stream != null )
+ //{
+ // stream.Flush();
+ // stream.Close();
+ //}
+ #endregion
+ }
+ }
+
+ private CChip t逋ｺ螢ｰ菴咲ｽｮ縺九ｉ驕主悉譁ｹ蜷代〒荳逡ｪ霑代￥縺ｫ縺ゅｋ謖螳壹メ繝｣繝ｳ繝阪Ν縺ｮ繝√ャ繝励ｒ霑斐☆(int n逋ｺ螢ｰ譎ょ綾, int n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ)
+ {
+ //驕主悉譁ｹ蜷代∈縺ｮ讀懃ｴ｢
+ for (int i = this.listChip.Count - 1; i >= 0; i--)
+ {
+ if (this.listChip[i].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ)
+ {
+ return this.listChip[i];
+ }
+ }
+
+ return null;
+ }
+
+ //迴ｾ蝨ｨ縲∽ｻ･荳九ｮ繧医≧縺ｪ陦後↓縺ｯ蟇ｾ蠢懊〒縺阪※縺縺ｾ縺帙ｓ縲
+ //_繝代Λ繝｡繝ｼ繧ｿ繧呈戟縺､蜻ｽ莉､縺後≠繧
+ //_陦後ｮ騾比ｸｭ縺ｫ蜻ｽ莉､縺後≠繧
+ private int t譁蟄玲焚隗｣譫(string InputText)
+ {
+ int n譁蟄玲焚 = 0;
+
+ for (int i = 0; i < InputText.Length; i++)
+ {
+ if (this.CharConvertNote(InputText.Substring(i, 1)) != -1)
+ {
+ n譁蟄玲焚++;
+ }
+ }
+
+
+ return n譁蟄玲焚;
+ }
+
+ private static readonly Regex CommandAndArgumentRegex =
+ new Regex(@"^(#[A-Z]+)(?:\s?)(.+?)?$", RegexOptions.Compiled);
+
+ private static readonly Regex BranchStartArgumentRegex =
+ new Regex(@"^([^,\s]+)\s*,\s*([^,\s]+)\s*,\s*([^,\s]+)$", RegexOptions.Compiled);
+
+ private string[] SplitComma(string input)
+ {
+ var result = new List();
+ var workingIndex = 0;
+ for (int i = 0; i < input.Length; i++)
+ {
+ if (input[i].Equals(',')) // 繧ｫ繝ｳ繝槭↓縺ｶ縺｡蠖薙◆縺｣縺
+ {
+ if (i - 1 >= 0)// &&貍皮ｮ怜ｭ舌〒繧ゅ∽ｾ句､悶′襍ｷ縺阪ｋ縺ｮ縺ｧ...
+ {
+ if (input[i - 1].Equals('\\')) // 1譁蟄怜燕縺後ヰ繝繧ｯ繧ｹ繝ｩ繝繧ｷ繝･
+ {
+ input = input.Remove(i - 1, 1);
+ }
+ else
+ {
+ // workingIndex縺九ｉ莉翫ｮ菴咲ｽｮ縺ｾ縺ｧ繧偵Μ繧ｹ繝医↓繝悶メ霎ｼ繧
+ result.Add(input.Substring(workingIndex, i - workingIndex));
+ // workingIndex縺ｫ莉翫ｮ菴咲ｽｮ+1繧剃ｻ｣蜈･
+ workingIndex = i + 1;
+ }
+ }
+ else
+ {
+ // workingIndex縺九ｉ莉翫ｮ菴咲ｽｮ縺ｾ縺ｧ繧偵Μ繧ｹ繝医↓繝悶メ霎ｼ繧
+ result.Add(input.Substring(workingIndex, i - workingIndex));
+ // workingIndex縺ｫ莉翫ｮ菴咲ｽｮ+1繧剃ｻ｣蜈･
+ workingIndex = i + 1;
+ }
+ }
+ if (i + 1 == input.Length) // 譛蠕後↓
+ {
+ result.Add(input.Substring(workingIndex, input.Length - workingIndex));
+ }
+ }
+ return result.ToArray();
+ }
+
+ ///
+ /// 隴憺擇隱ｭ縺ｿ霎ｼ縺ｿ繝｡繧ｽ繝繝鰻4縺ｧ菴ｿ逕ｨ縲
+ ///
+ ///
+ private void t蜻ｽ莉､繧呈諺蜈･縺吶ｋ(string InputText)
+ {
+ string[] SplitComma(string input)
+ {
+ var result = new List();
+ var workingIndex = 0;
+ for (int i = 0; i < input.Length; i++)
+ {
+ if (input[i] == ',') // 繧ｫ繝ｳ繝槭↓縺ｶ縺｡蠖薙◆縺｣縺
+ {
+ if (input[i - 1] == '\\') // 1譁蟄怜燕縺後ヰ繝繧ｯ繧ｹ繝ｩ繝繧ｷ繝･
+ {
+ input = input.Remove(i - 1, 1);
+ }
+ else
+ {
+ // workingIndex縺九ｉ莉翫ｮ菴咲ｽｮ縺ｾ縺ｧ繧偵Μ繧ｹ繝医↓繝悶メ霎ｼ繧
+ result.Add(input.Substring(workingIndex, i - workingIndex));
+ // workingIndex縺ｫ莉翫ｮ菴咲ｽｮ+1繧剃ｻ｣蜈･
+ workingIndex = i + 1;
+ }
+ }
+ if (i + 1 == input.Length) // 譛蠕後↓
+ {
+ result.Add(input.Substring(workingIndex, input.Length - workingIndex));
+ }
+ }
+ return result.ToArray();
+ }
+
+
+ var match = CommandAndArgumentRegex.Match(InputText);
+ if (!match.Success)
+ {
+ return;
+ }
+
+ var command = match.Groups[1].Value;
+ var argumentMatchGroup = match.Groups[2];
+ var argument = argumentMatchGroup.Success ? argumentMatchGroup.Value : null;
+
+ while (true)
+ {//蜻ｽ莉､縺ｮ譛蠕後↓,縺梧ｮ九▲縺ｦ縺励∪縺｣縺ｦ縺繧九→縺阪ｮ蟇ｾ蠢
+ if (argument != null && argument[argument.Length - 1] == ',')
+ argument = argument.Substring(0, argument.Length - 1);
+ else
+ break;
+ }
+
+ char[] chDelimiter = new char[] { ' ' };
+ string[] strArray = null;
+
+ if (command == "#START")
+ {
+ //#START縺ｨ蜷梧凾縺ｫ魑ｴ繧峨☆縺ｮ縺ｯ縺ｩ縺縺九→諤昴≧縺代←縺励ｃ繝ｼ縺ｪ縺励□縺ｪ縲
+ AddMusicPreTimeMs(); // 髻ｳ貅舌ｒ魑ｴ繧峨☆蜑阪↓驕蟒ｶ縲
+ var chip = new CChip();
+
+ chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ = 0x01;
+ chip.n逋ｺ螢ｰ菴咲ｽｮ = 384;
+ chip.n逋ｺ螢ｰ譎ょ綾ms = (int)this.dbNowTime;
+ chip.fNow_Measure_m = this.fNow_Measure_m;
+ chip.fNow_Measure_s = this.fNow_Measure_s;
+ chip.fBMSCROLLTime = this.dbNowBMScollTime;
+ chip.n謨ｴ謨ｰ蛟､ = 0x01;
+ chip.n謨ｴ謨ｰ蛟､_蜀驛ｨ逡ｪ蜿ｷ = 1;
+
+ // 繝√ャ繝励ｒ驟咲ｽｮ縲
+ this.listChip.Add(chip);
+
+ var chip1 = new CChip();
+ chip1.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ = 0x54;
+ //chip1.n逋ｺ螢ｰ菴咲ｽｮ = 384;
+ //chip1.n逋ｺ螢ｰ譎ょ綾ms = (int)this.dbNowTime;
+ if (this.nMOVIEOFFSET == 0)
+ chip1.n逋ｺ螢ｰ譎ょ綾ms = (int)this.dbNowTime;
+ else
+ chip1.n逋ｺ螢ｰ譎ょ綾ms = (int)this.nMOVIEOFFSET;
+ chip1.dbBPM = this.dbNowBPM;
+ chip1.fNow_Measure_m = this.fNow_Measure_m;
+ chip1.fNow_Measure_s = this.fNow_Measure_s;
+ chip1.dbSCROLL = this.dbNowScroll;
+ chip1.n謨ｴ謨ｰ蛟､ = 0x01;
+ chip1.n謨ｴ謨ｰ蛟､_蜀驛ｨ逡ｪ蜿ｷ = 1;
+ chip1.eAVI遞ｮ蛻･ = EAVI遞ｮ蛻･.AVI;
+
+ // 繝√ャ繝励ｒ驟咲ｽｮ縲
+
+ this.listChip.Add(chip1);
+ }
+ else if (command == "#END")
+ {
+ //縺溘ａ縺励↓蜑ｲ繧願ｾｼ繧縲
+ var chip = new CChip();
+
+ chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ = 0xFF;
+ chip.n逋ｺ螢ｰ菴咲ｽｮ = ((this.n迴ｾ蝨ｨ縺ｮ蟆冗ｯ謨ｰ + 2) * 384);
+ //chip.n逋ｺ螢ｰ譎ょ綾ms = (int)( this.dbNowTime + ((15000.0 / this.dbNowBPM * ( 4.0 / 4.0 )) * 16.0) * 2 );
+ chip.n逋ｺ螢ｰ譎ょ綾ms = (int)(this.dbNowTime + 1000); //2016.07.16 kairera0467 邨ゆｺ譎ゅ°繧1遘貞ｾ後↓險ｭ鄂ｮ縺吶ｋ繧医≧螟画峩縲
+ chip.fNow_Measure_m = this.fNow_Measure_m;
+ chip.fNow_Measure_s = this.fNow_Measure_s;
+ chip.n謨ｴ謨ｰ蛟､ = 0xFF;
+ chip.n謨ｴ謨ｰ蛟､_蜀驛ｨ逡ｪ蜿ｷ = 1;
+ // 繝√ャ繝励ｒ驟咲ｽｮ縲
+
+ if(n蜿らｧ荳ｭ縺ｮ髮｣譏灘ｺｦ == (int)Difficulty.Dan)
+ {
+ for (int i = listChip.Count - 1; i >= 0; i--)
+ {
+ if (listChip[i].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ >= 0x11 && listChip[i].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ <= 0x18)
+ {
+ if (DanSongs.Number != 0)
+ {
+ Array.Resize(ref this.pDan_LastChip, this.pDan_LastChip.Length + 1);
+ this.pDan_LastChip[DanSongs.Number - 1] = listChip[i];
+ break;
+ }
+ }
+ }
+ }
+
+ this.listChip.Add(chip);
+ }
+
+ else if (command == "#BPMCHANGE")
+ {
+ double dbBPM = Convert.ToDouble(argument);
+ this.dbNowBPM = dbBPM;
+
+ this.listBPM.Add(this.n蜀驛ｨ逡ｪ蜿ｷBPM1to - 1, new CBPM() { n蜀驛ｨ逡ｪ蜿ｷ = this.n蜀驛ｨ逡ｪ蜿ｷBPM1to - 1, n陦ｨ險倅ｸ翫ｮ逡ｪ蜿ｷ = 0, dbBPM蛟､ = dbBPM, bpm_change_time = this.dbNowTime, bpm_change_bmscroll_time = this.dbNowBMScollTime, bpm_change_course = this.n迴ｾ蝨ｨ縺ｮ繧ｳ繝ｼ繧ｹ });
+
+
+ //繝√ャ繝苓ｿｽ蜉縺励※蜑ｲ繧願ｾｼ繧薙〒縺ｿ繧九
+ var chip = new CChip();
+
+ chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ = 0x08;
+ chip.n逋ｺ螢ｰ菴咲ｽｮ = ((this.n迴ｾ蝨ｨ縺ｮ蟆冗ｯ謨ｰ) * 384);
+ chip.n逋ｺ螢ｰ譎ょ綾ms = (int)this.dbNowTime;
+ chip.fNow_Measure_m = this.fNow_Measure_m;
+ chip.fNow_Measure_s = this.fNow_Measure_s;
+ chip.fBMSCROLLTime = (float)this.dbNowBMScollTime;
+ chip.dbBPM = dbBPM;
+ chip.n謨ｴ謨ｰ蛟､_蜀驛ｨ逡ｪ蜿ｷ = this.n蜀驛ｨ逡ｪ蜿ｷBPM1to - 1;
+
+ // 繝√ャ繝励ｒ驟咲ｽｮ縲
+
+ this.listChip.Add(chip);
+
+ var chip1 = new CChip();
+ chip1.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ = 0x9C;
+ chip1.n逋ｺ螢ｰ菴咲ｽｮ = ((this.n迴ｾ蝨ｨ縺ｮ蟆冗ｯ謨ｰ) * 384);
+ chip1.n逋ｺ螢ｰ譎ょ綾ms = (int)this.dbNowTime;
+ chip.fNow_Measure_m = this.fNow_Measure_m;
+ chip.fNow_Measure_s = this.fNow_Measure_s;
+ chip1.fBMSCROLLTime = (float)this.dbNowBMScollTime;
+ chip1.dbBPM = dbBPM;
+ chip1.dbSCROLL = this.dbNowScroll;
+ chip1.n謨ｴ謨ｰ蛟､_蜀驛ｨ逡ｪ蜿ｷ = this.n蜀驛ｨ逡ｪ蜿ｷBPM1to - 1;
+
+ // 繝√ャ繝励ｒ驟咲ｽｮ縲
+
+ this.listChip.Add(chip1);
+
+ this.n蜀驛ｨ逡ｪ蜿ｷBPM1to++;
+ }
+ else if (command == "#SCROLL")
+ {
+ //2016.08.13 kairera0467 隍邏謨ｰ繧ｹ繧ｯ繝ｭ繝ｼ繝ｫ繧ゅ←縺阪ｮ繝繧ｹ繝
+ if (argument.IndexOf('i') != -1)
+ {
+ //i縺悟･縺｣縺ｦ縺縺溷ｴ蜷医∬､邏謨ｰ繧ｹ繧ｯ繝ｭ繝ｼ繝ｫ縺ｨ縺ｿ縺ｪ縺吶
+
+ double[] dbComplexNum = new double[2];
+ this.tParsedComplexNumber(argument, ref dbComplexNum);
+
+ this.dbNowScroll = dbComplexNum[0];
+ this.dbNowScrollY = dbComplexNum[1];
+
+ this.listSCROLL.Add(this.n蜀驛ｨ逡ｪ蜿ｷSCROLL1to, new CSCROLL() { n蜀驛ｨ逡ｪ蜿ｷ = this.n蜀驛ｨ逡ｪ蜿ｷSCROLL1to, n陦ｨ險倅ｸ翫ｮ逡ｪ蜿ｷ = 0, dbSCROLL蛟､ = dbComplexNum[0], dbSCROLL蛟､Y = dbComplexNum[1] });
+
+ switch (this.n迴ｾ蝨ｨ縺ｮ繧ｳ繝ｼ繧ｹ)
+ {
+ case ECourse.eNormal:
+ this.dbNowSCROLL_Normal[0] = dbComplexNum[0];
+ this.dbNowSCROLL_Normal[1] = dbComplexNum[1];
+ break;
+ case ECourse.eExpert:
+ this.dbNowSCROLL_Expert[0] = dbComplexNum[0];
+ this.dbNowSCROLL_Expert[1] = dbComplexNum[1];
+ break;
+ case ECourse.eMaster:
+ this.dbNowSCROLL_Master[0] = dbComplexNum[0];
+ this.dbNowSCROLL_Master[1] = dbComplexNum[1];
+ break;
+ default:
+ this.dbNowSCROLL_Normal[0] = dbComplexNum[0];
+ this.dbNowSCROLL_Normal[1] = dbComplexNum[1];
+ break;
+ }
+
+ //繝√ャ繝苓ｿｽ蜉縺励※蜑ｲ繧願ｾｼ繧薙〒縺ｿ繧九
+ var chip = new CChip();
+
+ chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ = 0x9D;
+ chip.n逋ｺ螢ｰ菴咲ｽｮ = ((this.n迴ｾ蝨ｨ縺ｮ蟆冗ｯ謨ｰ) * 384) - 1;
+ chip.n逋ｺ螢ｰ譎ょ綾ms = (int)this.dbNowTime;
+ chip.fNow_Measure_m = this.fNow_Measure_m;
+ chip.fNow_Measure_s = this.fNow_Measure_s;
+ chip.n謨ｴ謨ｰ蛟､_蜀驛ｨ逡ｪ蜿ｷ = this.n蜀驛ｨ逡ｪ蜿ｷSCROLL1to;
+ chip.dbSCROLL = dbComplexNum[0];
+ chip.dbSCROLL_Y = dbComplexNum[1];
+ chip.n繧ｳ繝ｼ繧ｹ = this.n迴ｾ蝨ｨ縺ｮ繧ｳ繝ｼ繧ｹ;
+
+ // 繝√ャ繝励ｒ驟咲ｽｮ縲
+
+ this.listChip.Add(chip);
+ }
+ else
+ {
+ double dbSCROLL = Convert.ToDouble(argument);
+ this.dbNowScroll = dbSCROLL;
+ this.dbNowScrollY = 0.0;
+
+ this.listSCROLL.Add(this.n蜀驛ｨ逡ｪ蜿ｷSCROLL1to, new CSCROLL() { n蜀驛ｨ逡ｪ蜿ｷ = this.n蜀驛ｨ逡ｪ蜿ｷSCROLL1to, n陦ｨ險倅ｸ翫ｮ逡ｪ蜿ｷ = 0, dbSCROLL蛟､ = dbSCROLL, dbSCROLL蛟､Y = 0.0 });
+
+ switch (this.n迴ｾ蝨ｨ縺ｮ繧ｳ繝ｼ繧ｹ)
+ {
+ case ECourse.eNormal:
+ this.dbNowSCROLL_Normal[0] = dbSCROLL;
+ break;
+ case ECourse.eExpert:
+ this.dbNowSCROLL_Expert[0] = dbSCROLL;
+ break;
+ case ECourse.eMaster:
+ this.dbNowSCROLL_Master[0] = dbSCROLL;
+ break;
+ }
+
+ //繝√ャ繝苓ｿｽ蜉縺励※蜑ｲ繧願ｾｼ繧薙〒縺ｿ繧九
+ var chip = new CChip();
+
+ chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ = 0x9D;
+ chip.n逋ｺ螢ｰ菴咲ｽｮ = ((this.n迴ｾ蝨ｨ縺ｮ蟆冗ｯ謨ｰ) * 384) - 1;
+ chip.n逋ｺ螢ｰ譎ょ綾ms = (int)this.dbNowTime;
+ chip.fNow_Measure_m = this.fNow_Measure_m;
+ chip.fNow_Measure_s = this.fNow_Measure_s;
+ chip.n謨ｴ謨ｰ蛟､_蜀驛ｨ逡ｪ蜿ｷ = this.n蜀驛ｨ逡ｪ蜿ｷSCROLL1to;
+ chip.dbSCROLL = dbSCROLL;
+ chip.dbSCROLL_Y = 0.0;
+ chip.n繧ｳ繝ｼ繧ｹ = this.n迴ｾ蝨ｨ縺ｮ繧ｳ繝ｼ繧ｹ;
+
+ // 繝√ャ繝励ｒ驟咲ｽｮ縲
+
+ this.listChip.Add(chip);
+ }
+
+
+
+
+ this.n蜀驛ｨ逡ｪ蜿ｷSCROLL1to++;
+ }
+ else if (command == "#MEASURE")
+ {
+ strArray = argument.Split(new char[] { '/' });
+ WarnSplitLength("#MEASURE subsplit", strArray, 2);
+
+ double[] dbLength = new double[2];
+ dbLength[0] = Convert.ToDouble(strArray[0]);
+ dbLength[1] = Convert.ToDouble(strArray[1]);
+
+ double db蟆冗ｯ髟ｷ蛟咲紫 = dbLength[0] / dbLength[1];
+ this.dbBarLength = db蟆冗ｯ髟ｷ蛟咲紫;
+ this.fNow_Measure_m = (float)dbLength[1];
+ this.fNow_Measure_s = (float)dbLength[0];
+
+ var chip = new CChip();
+
+ chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ = 0x02;
+ chip.n逋ｺ螢ｰ菴咲ｽｮ = ((this.n迴ｾ蝨ｨ縺ｮ蟆冗ｯ謨ｰ) * 384);
+ chip.n逋ｺ螢ｰ譎ょ綾ms = (int)this.dbNowTime;
+ chip.fNow_Measure_m = this.fNow_Measure_m;
+ chip.fNow_Measure_s = this.fNow_Measure_s;
+ chip.dbSCROLL = this.dbNowScroll;
+ chip.db螳滓焚蛟､ = db蟆冗ｯ髟ｷ蛟咲紫;
+ chip.n謨ｴ謨ｰ蛟､_蜀驛ｨ逡ｪ蜿ｷ = 1;
+ // 繝√ャ繝励ｒ驟咲ｽｮ縲
+
+ this.listChip.Add(chip);
+
+ //lbMaster.Items.Add( ";諡榊ｭ仙､画峩 " + strArray[0] + "/" + strArray[1] );
+ }
+ else if (command == "#DELAY")
+ {
+ double nDELAY = (Convert.ToDouble(argument) * 1000.0);
+
+
+ this.listDELAY.Add(this.n蜀驛ｨ逡ｪ蜿ｷDELAY1to, new CDELAY() { n蜀驛ｨ逡ｪ蜿ｷ = this.n蜀驛ｨ逡ｪ蜿ｷDELAY1to, n陦ｨ險倅ｸ翫ｮ逡ｪ蜿ｷ = 0, nDELAY蛟､ = (int)nDELAY, delay_bmscroll_time = this.dbLastBMScrollTime, delay_bpm = this.dbNowBPM, delay_course = this.n迴ｾ蝨ｨ縺ｮ繧ｳ繝ｼ繧ｹ, delay_time = this.dbLastTime });
+
+
+ //繝√ャ繝苓ｿｽ蜉縺励※蜑ｲ繧願ｾｼ繧薙〒縺ｿ繧九
+ var chip = new CChip();
+
+ chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ = 0xDC;
+ chip.n逋ｺ螢ｰ菴咲ｽｮ = ((this.n迴ｾ蝨ｨ縺ｮ蟆冗ｯ謨ｰ) * 384);
+ chip.db逋ｺ螢ｰ譎ょ綾ms = this.dbNowTime;
+ chip.fNow_Measure_m = this.fNow_Measure_m;
+ chip.fNow_Measure_s = this.fNow_Measure_s;
+ chip.n繧ｳ繝ｼ繧ｹ = this.n迴ｾ蝨ｨ縺ｮ繧ｳ繝ｼ繧ｹ;
+ chip.n謨ｴ謨ｰ蛟､_蜀驛ｨ逡ｪ蜿ｷ = this.n蜀驛ｨ逡ｪ蜿ｷDELAY1to;
+ chip.fBMSCROLLTime = this.dbNowBMScollTime;
+ // 繝√ャ繝励ｒ驟咲ｽｮ縲
+
+ this.dbNowTime += nDELAY;
+ this.dbNowBMScollTime += nDELAY * this.dbNowBPM / 15000;
+
+ this.listChip.Add(chip);
+ this.n蜀驛ｨ逡ｪ蜿ｷDELAY1to++;
+ }
+
+ else if (command == "#GOGOSTART")
+ {
+ var chip = new CChip();
+
+ chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ = 0x9E;
+ chip.n逋ｺ螢ｰ菴咲ｽｮ = ((this.n迴ｾ蝨ｨ縺ｮ蟆冗ｯ謨ｰ) * 384);
+ chip.dbBPM = this.dbNowBPM;
+ chip.n逋ｺ螢ｰ譎ょ綾ms = (int)this.dbNowTime;
+ chip.fNow_Measure_m = this.fNow_Measure_m;
+ chip.fNow_Measure_s = this.fNow_Measure_s;
+ chip.n謨ｴ謨ｰ蛟､_蜀驛ｨ逡ｪ蜿ｷ = 1;
+ this.bGOGOTIME = true;
+
+ // 繝√ャ繝励ｒ驟咲ｽｮ縲
+ this.listChip.Add(chip);
+ }
+ else if (command == "#GOGOEND")
+ {
+ var chip = new CChip();
+
+ chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ = 0x9F;
+ chip.n逋ｺ螢ｰ菴咲ｽｮ = ((this.n迴ｾ蝨ｨ縺ｮ蟆冗ｯ謨ｰ) * 384);
+ chip.n逋ｺ螢ｰ譎ょ綾ms = (int)this.dbNowTime;
+ chip.fNow_Measure_m = this.fNow_Measure_m;
+ chip.fNow_Measure_s = this.fNow_Measure_s;
+ chip.dbBPM = this.dbNowBPM;
+ chip.n謨ｴ謨ｰ蛟､_蜀驛ｨ逡ｪ蜿ｷ = 1;
+ this.bGOGOTIME = false;
+
+ // 繝√ャ繝励ｒ驟咲ｽｮ縲
+ this.listChip.Add(chip);
+ }
+ else if (command == "#SECTION")
+ {
+ //蛻蟯:譚｡莉ｶ繝ｪ繧ｻ繝繝
+ var chip = new CChip();
+
+ chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ = 0xDD;
+ chip.n逋ｺ螢ｰ菴咲ｽｮ = ((this.n迴ｾ蝨ｨ縺ｮ蟆冗ｯ謨ｰ - 1) * 384);
+ chip.n逋ｺ螢ｰ譎ょ綾ms = (int)this.dbNowTime;
+ chip.fNow_Measure_m = this.fNow_Measure_m;
+ chip.fNow_Measure_s = this.fNow_Measure_s;
+ chip.n謨ｴ謨ｰ蛟､_蜀驛ｨ逡ｪ蜿ｷ = 1;
+ chip.db逋ｺ螢ｰ譎ょ綾ms = this.dbNowTime;
+ // 繝√ャ繝励ｒ驟咲ｽｮ縲
+ this.listChip.Add(chip);
+ }
+ else if (command == "#BRANCHSTART")
+ {
+ #region [ 隴憺擇蛻蟯舌ｮ繝代ｼ繧ｹ譁ｹ豕輔ｒ菴懊ｊ逶ｴ縺 ]
+ this.b繝√ャ繝励′縺ゅｋ.Branch = true;
+ this.b譛蛻昴ｮ蛻蟯舌〒縺ゅｋ = false;
+ this.b蛻蟯舌ｒ荳蝗槭〒繧る幕蟋九＠縺 = true;
+
+ //蛻蟯:蛻蟯舌せ繧ｿ繝ｼ繝
+ E蛻蟯千ｨｮ鬘 e譚｡莉ｶ;
+
+ //譚｡莉ｶ謨ｰ蛟､縲
+ double[] nNum = new double[2];
+
+ //蜷榊燕縺ｨ譚｡莉ｶA縺ｮ髢薙↓,縺檎┌縺縺ｨ豁｣蟶ｸ縺ｫ蜍穂ｽ懊＠縺ｪ縺上↑繧.2020.04.23.akasoko26
+ #region [ 蜷榊燕縺ｨ譚｡莉ｶA縺ｮ髢薙↓,縺檎┌縺縺ｨ豁｣蟶ｸ縺ｫ蜍穂ｽ懊＠縺ｪ縺上↑繧 ]
+ //遨ｺ逋ｽ繧貞炎髯､縺吶ｋ縲
+ argument = Regex.Replace(argument, @"\s", "");
+ //2譁蟄礼岼縺,縺区焚蛟､縺九ｒ繝√ぉ繝繧ｯ
+ var IsNumber = bIsNumber(argument[1]);
+ //IsNumber == true 縺ｧ縺ゅ▲縺溘ｉ,縺檎┌縺縺ｨ縺縺縺薙→縺ｪ縺ｮ縺ｧ,繧2譁蟄礼岼縺ｫ縺ｶ縺｡霎ｼ繧繝ｻ繝ｻ繝ｻ
+ if (IsNumber)
+ argument = argument.Insert(1, ",");
+ #endregion
+
+ var branchStartArgumentMatch = BranchStartArgumentRegex.Match(argument);
+ nNum[0] = Convert.ToDouble(branchStartArgumentMatch.Groups[2].Value);
+ nNum[1] = Convert.ToDouble(branchStartArgumentMatch.Groups[3].Value);
+
+ switch (branchStartArgumentMatch.Groups[1].Value)
+ {
+ case "p":
+ e譚｡莉ｶ = E蛻蟯千ｨｮ鬘.e邊ｾ蠎ｦ蛻蟯;
+ break;
+ case "r":
+ e譚｡莉ｶ = E蛻蟯千ｨｮ鬘.e騾｣謇灘蟯;
+ break;
+ case "s":
+ e譚｡莉ｶ = E蛻蟯千ｨｮ鬘.e繧ｹ繧ｳ繧｢蛻蟯;
+ break;
+ case "d":
+ e譚｡莉ｶ = E蛻蟯千ｨｮ鬘.e螟ｧ髻ｳ隨ｦ縺ｮ縺ｿ邊ｾ蠎ｦ蛻蟯;
+ break;
+ default:
+ e譚｡莉ｶ = E蛻蟯千ｨｮ鬘.e邊ｾ蠎ｦ蛻蟯;
+ break;
+ }
+
+ #region [ 蛻蟯宣幕蟋区凾縺ｮ繝√ャ繝玲ュ蝣ｱ繧定ｨ倬鹸 ]
+ //迴ｾ蝨ｨ縺ｮ繝√ャ繝玲ュ蝣ｱ繧定ｨ倬鹸縺吶ｋ蠢隕√′縺ゅｋ縲
+ this.t迴ｾ蝨ｨ縺ｮ繝√ャ繝玲ュ蝣ｱ繧定ｨ倬鹸縺吶ｋ(true);
+ #endregion
+
+ #region [ 荳蟆冗ｯ蜑阪ｮ蛻蟯宣幕蟋気hip ]
+ //16蛻蜑阪↓謌ｻ縺呵ｨ育ｮ励↑繧薙°蠖薙※縺ｫ縺励■繧縺繧√ｈ縲ゅ(by Akasoko)
+ var c蟆冗ｯ蜑阪ｮ蟆冗ｯ邱壽ュ蝣ｱ = c荳蟆冗ｯ蜑阪ｮ蟆冗ｯ邱壽ュ蝣ｱ繧定ｿ斐☆(listChip, e譚｡莉ｶ);
+ CChip c蟆冗ｯ蜑阪ｮ騾｣謇馴幕蟋倶ｽ咲ｽｮ = null;
+
+ var chip = new CChip();
+
+ if (e譚｡莉ｶ == E蛻蟯千ｨｮ鬘.e騾｣謇灘蟯)
+ {
+ /*
+ c蟆冗ｯ蜑阪ｮ騾｣謇馴幕蟋倶ｽ咲ｽｮ = c荳蟆冗ｯ蜑阪ｮ蟆冗ｯ邱壽ュ蝣ｱ繧定ｿ斐☆(listChip, e譚｡莉ｶ, true);
+ //騾｣謇灘蟯舌ｮ菴咲ｽｮ繧貞咲樟
+ //縺薙ｮ險育ｮ怜ｼ上ｯ縺ゅ※縺ｫ縺ｪ繧峨↑縺縺ｨ諤昴≧縺後√∪縺ゅ←縺縺励ｈ縺繧ゅ↑縺繧薙〒縺薙ｌ縺ｧ
+ //縺ｪ繧九∋縺城｣謇薙ｮ繧ｱ繝縺ｮ驛ｨ蛻縺ｫ
+ var f騾｣謇薙ｮ髟ｷ縺輔ｮ蜊雁 = (c蟆冗ｯ蜑阪ｮ蟆冗ｯ邱壽ュ蝣ｱ.n逋ｺ螢ｰ譎ょ綾ms - c蟆冗ｯ蜑阪ｮ騾｣謇馴幕蟋倶ｽ咲ｽｮ.n逋ｺ螢ｰ譎ょ綾ms) / 2.0f;
+ */
+
+ chip.n逋ｺ螢ｰ譎ょ綾ms = c蟆冗ｯ蜑阪ｮ蟆冗ｯ邱壽ュ蝣ｱ.n逋ｺ螢ｰ譎ょ綾ms;
+ }
+ else chip.n逋ｺ螢ｰ譎ょ綾ms = c蟆冗ｯ蜑阪ｮ蟆冗ｯ邱壽ュ蝣ｱ.n逋ｺ螢ｰ譎ょ綾ms;
+
+ chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ = 0xDE;
+ chip.fNow_Measure_m = c蟆冗ｯ蜑阪ｮ蟆冗ｯ邱壽ュ蝣ｱ.fNow_Measure_m;
+ chip.fNow_Measure_s = c蟆冗ｯ蜑阪ｮ蟆冗ｯ邱壽ュ蝣ｱ.fNow_Measure_s;
+
+ //繝弱ｼ繝 * 0.5蛻蠕後ｍ縺ｫ縺励※縲√ヮ繝ｼ繝縺梧ｮ九ｉ縺ｪ縺繧医≧縺ｫ縺吶ｋ
+ chip.n蛻蟯先凾蛻ｻms = this.dbNowTime - ((15000.0 / this.dbNowBPM * (this.fNow_Measure_s / this.fNow_Measure_m)) * 0.5);
+ chip.e蛻蟯舌ｮ遞ｮ鬘 = e譚｡莉ｶ;
+ chip.n譚｡莉ｶ謨ｰ蛟､A = nNum[0];// list縺ｫ霑ｽ蜉縺励※縺縺溘′莉墓ｧ倥ｒ螟画峩縲
+ chip.n譚｡莉ｶ謨ｰ蛟､B = nNum[1];// ""
+ chip.dbSCROLL = c蟆冗ｯ蜑阪ｮ蟆冗ｯ邱壽ュ蝣ｱ.dbSCROLL;
+ chip.dbBPM = c蟆冗ｯ蜑阪ｮ蟆冗ｯ邱壽ュ蝣ｱ.dbBPM;
+ this.listChip.Add(chip);
+ #endregion
+
+ for (int i = 0; i < 3; i++)
+ IsBranchBarDraw[i] = true;//3繧ｳ繝ｼ繧ｹ蛻縺ｮ鮟濶ｲ蟆剰ｪｬ邱夊｡ｨ遉ｺ繼ｫ繝ｩ繝
+
+ IsEndedBranching = false;
+ #endregion
+ }
+ else if (command == "#N" || command == "#E" || command == "#M")//縺薙ｌCourse繧貞ｨ驛ｨ髮繧√※縺ゅ→縺九ｉ蛻蟯舌＆縺帙ｌ縺ｰ縺縺莉ｶ
+ {
+ //髢句ｧ区凾縺ｮ諠蝣ｱ縺ｫ繧ｻ繝繝
+ t迴ｾ蝨ｨ縺ｮ繝√ャ繝玲ュ蝣ｱ繧定ｨ倬鹸縺吶ｋ(false);
+
+ if (command == "#N")
+ this.n迴ｾ蝨ｨ縺ｮ繧ｳ繝ｼ繧ｹ = ECourse.eNormal;//蛻蟯:譎ｮ騾夊ｭ憺擇
+ else if (command == "#E")
+ this.n迴ｾ蝨ｨ縺ｮ繧ｳ繝ｼ繧ｹ = ECourse.eExpert;//蛻蟯:邇莠ｺ隴憺擇
+ else if (command == "#M")
+ this.n迴ｾ蝨ｨ縺ｮ繧ｳ繝ｼ繧ｹ = ECourse.eMaster;//蛻蟯:驕比ｺｺ隴憺擇
+ }
+ else if (command == "#LEVELHOLD")
+ {
+ var chip = new CChip();
+ chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ = 0xE1;
+ chip.n逋ｺ螢ｰ菴咲ｽｮ = ((this.n迴ｾ蝨ｨ縺ｮ蟆冗ｯ謨ｰ) * 384) - 1;
+ chip.n逋ｺ螢ｰ譎ょ綾ms = (int)this.dbNowTime;
+ chip.fNow_Measure_m = this.fNow_Measure_m;
+ chip.fNow_Measure_s = this.fNow_Measure_s;
+ chip.n謨ｴ謨ｰ蛟､_蜀驛ｨ逡ｪ蜿ｷ = 1;
+
+ this.listChip.Add(chip);
+ }
+ else if (command == "#BRANCHEND")
+ {
+ var GoBranch = new CChip();
+
+ //End逕ｨ繝√Ε繝ｳ繝阪Ν繧脱mpty縺九ｉ蠑輔▲蠑ｵ縺｣縺ｦ縺阪◆縲
+ GoBranch.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ = 0x52;
+ GoBranch.n逋ｺ螢ｰ菴咲ｽｮ = ((this.n迴ｾ蝨ｨ縺ｮ蟆冗ｯ謨ｰ) * 384) - 1;
+ GoBranch.n逋ｺ螢ｰ譎ょ綾ms = (int)this.dbNowTime;
+ GoBranch.fNow_Measure_m = this.fNow_Measure_m;
+ GoBranch.fNow_Measure_s = this.fNow_Measure_s;
+ GoBranch.dbSCROLL = this.dbNowScroll;
+ GoBranch.dbBPM = this.dbNowBPM;
+ GoBranch.n謨ｴ謨ｰ蛟､_蜀驛ｨ逡ｪ蜿ｷ = 1;
+
+ this.listChip.Add(GoBranch);
+
+ //End譎ゅ↓繧るｻ濶ｲ縺蟆冗ｯ邱壹≠縺｣縺溘∋ｼ
+ for (int i = 0; i < 3; i++)
+ IsBranchBarDraw[i] = true;//3繧ｳ繝ｼ繧ｹ蛻縺ｮ鮟濶ｲ蟆剰ｪｬ邱夊｡ｨ遉ｺ繼ｫ繝ｩ繝
+
+ IsEndedBranching = true;
+ }
+ else if (command == "#BARLINEOFF")
+ {
+ var chip = new CChip();
+
+ chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ = 0xE0;
+ chip.n逋ｺ螢ｰ菴咲ｽｮ = ((this.n迴ｾ蝨ｨ縺ｮ蟆冗ｯ謨ｰ) * 384) - 1;
+ chip.n逋ｺ螢ｰ譎ょ綾ms = (int)this.dbNowTime + 1;
+ chip.n謨ｴ謨ｰ蛟､_蜀驛ｨ逡ｪ蜿ｷ = 1;
+ chip.n繧ｳ繝ｼ繧ｹ = this.n迴ｾ蝨ｨ縺ｮ繧ｳ繝ｼ繧ｹ;
+ this.bBARLINECUE[0] = 1;
+
+ this.listChip.Add(chip);
+ }
+ else if (command == "#BARLINEON")
+ {
+ var chip = new CChip();
+
+ chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ = 0xE0;
+ chip.n逋ｺ螢ｰ菴咲ｽｮ = ((this.n迴ｾ蝨ｨ縺ｮ蟆冗ｯ謨ｰ) * 384) - 1;
+ chip.n逋ｺ螢ｰ譎ょ綾ms = (int)this.dbNowTime + 1;
+ chip.fNow_Measure_m = this.fNow_Measure_m;
+ chip.fNow_Measure_s = this.fNow_Measure_s;
+ chip.n謨ｴ謨ｰ蛟､_蜀驛ｨ逡ｪ蜿ｷ = 2;
+ chip.n繧ｳ繝ｼ繧ｹ = this.n迴ｾ蝨ｨ縺ｮ繧ｳ繝ｼ繧ｹ;
+ this.bBARLINECUE[0] = 0;
+
+ this.listChip.Add(chip);
+ }
+ else if (command == "#LYRIC")
+ {
+ if (TJAPlayer3.r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ.e繧ｹ繝繝ｼ繧ｸID == CStage.E繧ｹ繝繝ｼ繧ｸ.譖ｲ隱ｭ縺ｿ霎ｼ縺ｿ)//襍ｷ蜍墓凾縺ｫ驥阪◆縺上↑縺｣縺ｦ縺励∪縺蝠城｡後ｮ菫ｮ豁｣逕ｨ
+ this.listLyric.Add(this.pf豁瑚ｩ槭ヵ繧ｩ繝ｳ繝.DrawPrivateFont(argument, TJAPlayer3.Skin.Game_Lyric_ForeColor, TJAPlayer3.Skin.Game_Lyric_BackColor));
+
+ var chip = new CChip();
+
+ chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ = 0xF1;
+ chip.n逋ｺ螢ｰ譎ょ綾ms = (int)this.dbNowTime;
+ chip.fNow_Measure_m = this.fNow_Measure_m;
+ chip.fNow_Measure_s = this.fNow_Measure_s;
+ chip.n謨ｴ謨ｰ蛟､_蜀驛ｨ逡ｪ蜿ｷ = 0;
+ chip.n繧ｳ繝ｼ繧ｹ = this.n迴ｾ蝨ｨ縺ｮ繧ｳ繝ｼ繧ｹ;
+
+ // 繝√ャ繝励ｒ驟咲ｽｮ縲
+
+ this.listChip.Add(chip);
+ this.bLyrics = true;
+ }
+ else if (command == "#DIRECTION")
+ {
+ double dbSCROLL = Convert.ToDouble(argument);
+ this.n繧ｹ繧ｯ繝ｭ繝ｼ繝ｫ譁ｹ蜷 = (int)dbSCROLL;
+
+ //繝√ャ繝苓ｿｽ蜉縺励※蜑ｲ繧願ｾｼ繧薙〒縺ｿ繧九
+ var chip = new CChip();
+
+ chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ = 0xF2;
+ chip.n逋ｺ螢ｰ菴咲ｽｮ = ((this.n迴ｾ蝨ｨ縺ｮ蟆冗ｯ謨ｰ) * 384) - 1;
+ chip.n逋ｺ螢ｰ譎ょ綾ms = (int)this.dbNowTime;
+ chip.fNow_Measure_m = this.fNow_Measure_m;
+ chip.fNow_Measure_s = this.fNow_Measure_s;
+ chip.n謨ｴ謨ｰ蛟､_蜀驛ｨ逡ｪ蜿ｷ = 0;
+ chip.n繧ｹ繧ｯ繝ｭ繝ｼ繝ｫ譁ｹ蜷 = (int)dbSCROLL;
+ chip.n繧ｳ繝ｼ繧ｹ = this.n迴ｾ蝨ｨ縺ｮ繧ｳ繝ｼ繧ｹ;
+
+ // 繝√ャ繝励ｒ驟咲ｽｮ縲
+
+ this.listChip.Add(chip);
+ }
+ else if (command == "#SUDDEN")
+ {
+ strArray = argument.Split(chDelimiter);
+ WarnSplitLength("#SUDDEN", strArray, 2);
+ double db蜃ｺ迴ｾ譎ょ綾 = Convert.ToDouble(strArray[0]);
+ double db遘ｻ蜍募ｾ讖滓凾蛻ｻ = Convert.ToDouble(strArray[1]);
+ this.db蜃ｺ迴ｾ譎ょ綾 = db蜃ｺ迴ｾ譎ょ綾;
+ this.db遘ｻ蜍募ｾ讖滓凾蛻ｻ = db遘ｻ蜍募ｾ讖滓凾蛻ｻ;
+
+ //繝√ャ繝苓ｿｽ蜉縺励※蜑ｲ繧願ｾｼ繧薙〒縺ｿ繧九
+ var chip = new CChip();
+
+ chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ = 0xF3;
+ chip.n逋ｺ螢ｰ菴咲ｽｮ = ((this.n迴ｾ蝨ｨ縺ｮ蟆冗ｯ謨ｰ) * 384) - 1;
+ chip.n逋ｺ螢ｰ譎ょ綾ms = (int)this.dbNowTime;
+ chip.fNow_Measure_m = this.fNow_Measure_m;
+ chip.fNow_Measure_s = this.fNow_Measure_s;
+ chip.n謨ｴ謨ｰ蛟､_蜀驛ｨ逡ｪ蜿ｷ = 0;
+ chip.n繝弱ｼ繝蜃ｺ迴ｾ譎ょ綾ms = (int)this.db蜃ｺ迴ｾ譎ょ綾;
+ chip.n繝弱ｼ繝遘ｻ蜍暮幕蟋区凾蛻ｻms = (int)this.db遘ｻ蜍募ｾ讖滓凾蛻ｻ;
+ chip.n繧ｳ繝ｼ繧ｹ = this.n迴ｾ蝨ｨ縺ｮ繧ｳ繝ｼ繧ｹ;
+
+ // 繝√ャ繝励ｒ驟咲ｽｮ縲
+
+ this.listChip.Add(chip);
+ }
+ else if (command == "#JPOSSCROLL")
+ {
+ strArray = argument.Split(chDelimiter);
+ WarnSplitLength("#JPOSSCROLL", strArray, 3);
+ double db遘ｻ蜍墓凾蛻ｻ = Convert.ToDouble(strArray[0]);
+ int n遘ｻ蜍頻x = Convert.ToInt32(strArray[1]);
+ int n遘ｻ蜍墓婿蜷 = Convert.ToInt32(strArray[2]);
+
+ //繝√ャ繝苓ｿｽ蜉縺励※蜑ｲ繧願ｾｼ繧薙〒縺ｿ繧九
+ var chip = new CChip();
+
+ chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ = 0xE2;
+ chip.n逋ｺ螢ｰ菴咲ｽｮ = ((this.n迴ｾ蝨ｨ縺ｮ蟆冗ｯ謨ｰ) * 384) - 1;
+ chip.n逋ｺ螢ｰ譎ょ綾ms = (int)this.dbNowTime;
+ chip.fNow_Measure_m = this.fNow_Measure_m;
+ chip.fNow_Measure_s = this.fNow_Measure_s;
+ chip.n謨ｴ謨ｰ蛟､_蜀驛ｨ逡ｪ蜿ｷ = 0;
+ chip.n繧ｳ繝ｼ繧ｹ = this.n迴ｾ蝨ｨ縺ｮ繧ｳ繝ｼ繧ｹ;
+
+ // 繝√ャ繝励ｒ驟咲ｽｮ縲
+
+ this.listJPOSSCROLL.Add(this.n蜀驛ｨ逡ｪ蜿ｷJSCROLL1to, new CJPOSSCROLL() { n蜀驛ｨ逡ｪ蜿ｷ = this.n蜀驛ｨ逡ｪ蜿ｷJSCROLL1to, n陦ｨ險倅ｸ翫ｮ逡ｪ蜿ｷ = 0, db遘ｻ蜍墓凾髢 = db遘ｻ蜍墓凾蛻ｻ, n遘ｻ蜍戊ｷ晞屬px = n遘ｻ蜍頻x, n遘ｻ蜍墓婿蜷 = n遘ｻ蜍墓婿蜷 });
+ this.listChip.Add(chip);
+ this.n蜀驛ｨ逡ｪ蜿ｷJSCROLL1to++;
+ }
+ else if (command == "#SENOTECHANGE")
+ {
+ FixSENote = int.Parse(argument);
+ IsEnabledFixSENote = true;
+ }
+ else if (command == "#NEXTSONG")
+ {
+ var delayTime = 6200.0; // 6.2遘偵ョ繧｣繝ｬ繧､
+ //繝√ャ繝苓ｿｽ蜉縺励※蜑ｲ繧願ｾｼ繧薙〒縺ｿ繧九
+ var chip = new CChip();
+
+ chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ = 0x9B;
+ chip.n逋ｺ螢ｰ菴咲ｽｮ = ((this.n迴ｾ蝨ｨ縺ｮ蟆冗ｯ謨ｰ) * 384) - 1;
+ chip.n逋ｺ螢ｰ譎ょ綾ms = (int)this.dbNowTime;
+ chip.fNow_Measure_m = this.fNow_Measure_m;
+ chip.fNow_Measure_s = this.fNow_Measure_s;
+ this.dbNowTime += delayTime;
+ this.dbNowBMScollTime += delayTime * this.dbNowBPM / 15000;
+ chip.n謨ｴ謨ｰ蛟､_蜀驛ｨ逡ｪ蜿ｷ = 0;
+ chip.n繧ｳ繝ｼ繧ｹ = this.n迴ｾ蝨ｨ縺ｮ繧ｳ繝ｼ繧ｹ;
+
+ // 繝√ャ繝励ｒ驟咲ｽｮ縲
+ this.listChip.Add(chip);
+
+ AddMusicPreTimeMs(); // 谿ｵ菴阪ｮ蟷輔′髢九＞縺ｦ縺九ｉ縺ｮ驕蟒ｶ縲
+
+ strArray = SplitComma(argument); // \,繧偵お繧ｹ繧ｱ繝ｼ繝怜ｦ逅縺吶ｋ繝｡繧ｽ繝繝峨□縺槭▲
+
+ for (int i = listChip.Count - 1; i >= 0; i--)
+ {
+ if (listChip[i].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ >= 0x11 && listChip[i].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ <= 0x18)
+ {
+ if(DanSongs.Number != 0)
+ {
+ Array.Resize(ref this.pDan_LastChip, this.pDan_LastChip.Length + 1);
+ this.pDan_LastChip[DanSongs.Number - 1] = listChip[i];
+ break;
+ }
+ }
+ }
+
+ WarnSplitLength("#NEXTSONG", strArray, 8);
+ var dansongs = new DanSongs();
+ dansongs.Title = strArray[0];
+ dansongs.SubTitle = strArray[1];
+ dansongs.Genre = strArray[2];
+ dansongs.FileName = strArray[3];
+ dansongs.ScoreInit = int.Parse(strArray[4]);
+ dansongs.ScoreDiff = int.Parse(strArray[5]);
+
+ if (strArray.Length >= 7 && strArray[6] != "" && strArray[6] != null)
+ dansongs.Level = int.Parse(strArray[6]);
+ else if (strArray.Length < 7)
+ dansongs.Level = 10;
+
+ if (strArray.Length >= 8 && strArray[7] != "" && strArray[7] != null)
+ dansongs.Difficulty = strConvertCourse(strArray[7]);
+ else if (strArray.Length < 8)
+ dansongs.Difficulty = 3;
+
+ if (strArray.Length == 9 && strArray[8] != "" && strArray[8] != null)
+ dansongs.bTitleShow = bool.Parse(strArray[8]);
+ else if (strArray.Length < 9)
+ dansongs.bTitleShow = false;
+
+ dansongs.Wave = new CWAV
+ {
+ n蜀驛ｨ逡ｪ蜿ｷ = this.n蜀驛ｨ逡ｪ蜿ｷWAV1to,
+ n陦ｨ險倅ｸ翫ｮ逡ｪ蜿ｷ = this.n蜀驛ｨ逡ｪ蜿ｷWAV1to,
+ n繝√ャ繝励し繧､繧ｺ = this.n辟｡髯千ｮ｡逅SIZE[this.n蜀驛ｨ逡ｪ蜿ｷWAV1to],
+ n菴咲ｽｮ = this.n辟｡髯千ｮ｡逅PAN[this.n蜀驛ｨ逡ｪ蜿ｷWAV1to],
+ SongVol = this.SongVol,
+ SongLoudnessMetadata = this.SongLoudnessMetadata,
+ str繝輔ぃ繧､繝ｫ蜷 = CDTXCompanionFileFinder.FindFileName(this.str繝輔か繝ｫ繝蜷, str繝輔ぃ繧､繝ｫ蜷, dansongs.FileName),
+ str繧ｳ繝｡繝ｳ繝域枚 = "TJA BGM"
+ };
+ dansongs.Wave.SongLoudnessMetadata = LoudnessMetadataScanner.LoadForAudioPath(dansongs.Wave.str繝輔ぃ繧､繝ｫ蜷);
+ List_DanSongs.Add(dansongs);
+ this.listWAV.Add(this.n蜀驛ｨ逡ｪ蜿ｷWAV1to, dansongs.Wave);
+ this.n蜀驛ｨ逡ｪ蜿ｷWAV1to++;
+
+ var nextSongnextSongChip = new CChip();
+
+ nextSongnextSongChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ = 0x01;
+ nextSongnextSongChip.n逋ｺ螢ｰ菴咲ｽｮ = 384;
+ nextSongnextSongChip.n逋ｺ螢ｰ譎ょ綾ms = (int)this.dbNowTime;
+ nextSongnextSongChip.fNow_Measure_m = this.fNow_Measure_m;
+ nextSongnextSongChip.fNow_Measure_s = this.fNow_Measure_s;
+ nextSongnextSongChip.n謨ｴ謨ｰ蛟､ = 0x01;
+ nextSongnextSongChip.n謨ｴ謨ｰ蛟､_蜀驛ｨ逡ｪ蜿ｷ = 1 + List_DanSongs.Count;
+
+ this.listWAV[1].str繝輔ぃ繧､繝ｫ蜷 = "";
+
+ // 繝√ャ繝励ｒ驟咲ｽｮ縲
+ this.listChip.Add(nextSongnextSongChip);
+
+ }
+ }
+ void t迴ｾ蝨ｨ縺ｮ繝√ャ繝玲ュ蝣ｱ繧定ｨ倬鹸縺吶ｋ(bool bInPut)
+ {
+ //2020.04.21 縺薙≧縺ｪ縺｣縺ｦ縺励∪縺｣縺溘ｮ縺ｯ莉墓婿縺後↑縺縺ｪ縲ゅ
+ if (bInPut)
+ {
+ #region [ 險倬鹸縺吶ｋ ]
+ cBranchStart.dbTime = this.dbNowTime;
+ cBranchStart.dbSCROLL = this.dbNowScroll;
+ cBranchStart.dbSCROLLY = this.dbNowScrollY;
+ cBranchStart.dbBMScollTime = this.dbNowBMScollTime;
+ cBranchStart.dbBPM = this.dbNowBPM;
+ cBranchStart.fMeasure_s = this.fNow_Measure_s;
+ cBranchStart.fMeasure_m = this.fNow_Measure_m;
+ cBranchStart.nMeasureCount = this.n迴ｾ蝨ｨ縺ｮ蟆冗ｯ謨ｰ;
+ cBranchStart.db遘ｻ蜍募ｾ讖滓凾蛻ｻ = this.db遘ｻ蜍募ｾ讖滓凾蛻ｻ;
+ cBranchStart.db蜀咲函騾溷ｺｦ = this.db蜀咲函騾溷ｺｦ;
+ cBranchStart.db蜃ｺ迴ｾ譎ょ綾 = this.db蜃ｺ迴ｾ譎ょ綾;
+ #endregion
+ }
+ else
+ {
+ #region [ 險倬鹸縺励◆諠蝣ｱ繧誰ow~縺ｫ驕ｩ蠢 ]
+ this.dbNowTime = cBranchStart.dbTime;
+ this.dbNowScroll = cBranchStart.dbSCROLL;
+ this.dbNowScrollY = cBranchStart.dbSCROLLY;
+ this.dbNowBMScollTime = cBranchStart.dbBMScollTime;
+ this.dbNowBPM = cBranchStart.dbBPM;
+ this.fNow_Measure_s = cBranchStart.fMeasure_s;
+ this.fNow_Measure_m = cBranchStart.fMeasure_m;
+ this.n迴ｾ蝨ｨ縺ｮ蟆冗ｯ謨ｰ = cBranchStart.nMeasureCount;
+ this.db遘ｻ蜍募ｾ讖滓凾蛻ｻ = cBranchStart.db遘ｻ蜍募ｾ讖滓凾蛻ｻ;
+ this.db蜀咲函騾溷ｺｦ = cBranchStart.db蜀咲函騾溷ｺｦ;
+ this.db蜃ｺ迴ｾ譎ょ綾 = cBranchStart.db蜃ｺ迴ｾ譎ょ綾;
+ #endregion
+ }
+ }
+
+ ///
+ /// 荳蟆冗ｯ蜑阪ｮ蟆冗ｯ邱壽ュ蝣ｱ繧定ｿ斐☆Method 2020.04.21.akasoko26
+ ///
+ ///
+ ///
+ private CChip c荳蟆冗ｯ蜑阪ｮ蟆冗ｯ邱壽ュ蝣ｱ繧定ｿ斐☆(List listChips, E蛻蟯千ｨｮ鬘 e蛻蟯千ｨｮ鬘, bool b蛻蟯仙燕縺ｮ騾｣謇馴幕蟋 = false)
+ {
+ //2020.04.20 c荳蟆冗ｯ蜑阪ｮ蟆冗ｯ邱壽ュ蝣ｱ繧定ｿ斐☆Method繧定ｿｽ蜉
+ //騾｣謇灘蟯先凾縺ｯ迴ｾ蝨ｨ縺ｮ蟆冗ｯ莉･髯阪ｮ騾｣謇薙ｮ邨ゅｏ繧企Κ蛻縺ｮ譎ょ綾繧貞叙蠕励☆繧
+
+ int? nReturnChip = null;
+
+ //--縺励※蜿門ｾ励＠縺ｪ縺縺ｨ縺繧√ｈｽ槭ム繝｡繝繝｡汳
+ for (int i = listChips.Count - 1; i >= 0; i--)
+ {
+ if (b蛻蟯仙燕縺ｮ騾｣謇馴幕蟋)
+ {
+ if (listChips[i].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x15 || listChips[i].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x16)
+ {
+ if (nReturnChip == null)
+ nReturnChip = i;
+
+ //ReturnChip縺系ull縺ｧ縺ゅ▲縺溘ｉ驕ｩ蠢
+ }
+ }
+ else
+ {
+ var Flag = e蛻蟯千ｨｮ鬘 == E蛻蟯千ｨｮ鬘.e騾｣謇灘蟯 ? 0x18 : 0x50;
+
+ if (listChips[i].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == Flag)
+ {
+ if (nReturnChip == null)
+ nReturnChip = i;
+ //ReturnChip縺系ull縺ｧ縺ゅ▲縺溘ｉ驕ｩ蠢
+ }
+ }
+ }
+
+ //繧ゅ＠縲］ReturnChip縺系ull縺縺｣縺溘ｉlistChip縺ｮCount - 1縺ｫ繧ｻ繝繝医☆繧九
+ return listChips[nReturnChip == null ? listChips.Count - 1 : (int)nReturnChip];
+ }
+
+ private void WarnSplitLength(string name, string[] strArray, int minimumLength)
+ {
+ if (strArray.Length < minimumLength)
+ {
+ Trace.TraceWarning(
+ $"蜻ｽ莉､ {name} 縺ｮ繝代Λ繝｡繝ｼ繧ｿ縺瑚ｶｳ繧翫∪縺帙ｓ縲ょｰ代↑縺上→繧 {minimumLength} 縺､縺ｮ繝代Λ繝｡繝ｼ繧ｿ縺悟ｿ隕√〒縺吶 (迴ｾ蝨ｨ縺ｮ繝代Λ繝｡繝ｼ繧ｿ謨ｰ: {strArray.Length}). ({str繝輔ぃ繧､繝ｫ蜷阪ｮ邨ｶ蟇ｾ繝代せ})");
+ }
+ }
+
+ private void t蜈･蜉媽陦瑚ｧ｣譫占ｭ憺擇_V4(string InputText)
+ {
+ if (!String.IsNullOrEmpty(InputText))
+ {
+ int n譁蟄玲焚 = 16;
+
+ //迴ｾ蝨ｨ縺ｮ繧ｳ繝ｼ繧ｹ縲∝ｰ冗ｯ縺ｫ蠖薙※縺ｯ縺ｾ繧九ｂ縺ｮ繧偵Μ繧ｹ繝医°繧画爾縺励※譁蟄玲焚繧定ｿ斐☆縲
+ for (int i = 0; i < this.listLine.Count; i++)
+ {
+ if (this.listLine[i].n蟆冗ｯ逡ｪ蜿ｷ == this.n迴ｾ蝨ｨ縺ｮ蟆冗ｯ謨ｰ && this.listLine[i].n繧ｳ繝ｼ繧ｹ == this.n迴ｾ蝨ｨ縺ｮ繧ｳ繝ｼ繧ｹ)
+ {
+ n譁蟄玲焚 = this.listLine[i].n譁蟄玲焚;
+ }
+
+ }
+
+ if (InputText.StartsWith("#"))
+ {
+ this.t蜻ｽ莉､繧呈諺蜈･縺吶ｋ(InputText);
+ return;
+ }
+ else
+ {
+ if (this.b蟆冗ｯ邱壹ｒ謖ｿ蜈･縺励※縺繧 == false)
+ {
+ // 蟆冗ｯ邱壹↓繧ゅｄ縺｣縺ｦ縺ゅ£縺ｪ縺縺ｨ
+ // IsEndedBranching縺掲alse縺ｧ1蝗
+ // true縺ｧ3蝗槭□繧3蝗
+ for (int i = 0; i < (IsEndedBranching == true ? 3 : 1); i++)
+ {
+ CChip chip = new CChip();
+ chip.n逋ｺ螢ｰ菴咲ｽｮ = ((this.n迴ｾ蝨ｨ縺ｮ蟆冗ｯ謨ｰ) * 384);
+ chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ = 0x50;
+ chip.n逋ｺ螢ｰ譎ょ綾ms = (int)this.dbNowTime;
+ chip.n謨ｴ謨ｰ蛟､ = this.n迴ｾ蝨ｨ縺ｮ蟆冗ｯ謨ｰ;
+ chip.n譁蟄玲焚 = n譁蟄玲焚;
+ chip.n謨ｴ謨ｰ蛟､_蜀驛ｨ逡ｪ蜿ｷ = this.n迴ｾ蝨ｨ縺ｮ蟆冗ｯ謨ｰ;
+ chip.dbBPM = this.dbNowBPM;
+ chip.fNow_Measure_m = this.fNow_Measure_m;
+ chip.fNow_Measure_s = this.fNow_Measure_s;
+ chip.IsEndedBranching = IsEndedBranching;
+ chip.dbSCROLL = this.dbNowScroll;
+ chip.dbSCROLL_Y = this.dbNowScrollY;
+ chip.fBMSCROLLTime = (float)this.dbNowBMScollTime;
+
+ if (IsEndedBranching)
+ chip.n繧ｳ繝ｼ繧ｹ = (ECourse)i;
+ else
+ chip.n繧ｳ繝ｼ繧ｹ = n迴ｾ蝨ｨ縺ｮ繧ｳ繝ｼ繧ｹ;
+
+ if (this.bBARLINECUE[0] == 1)
+ {
+ chip.b蜿ｯ隕 = false;
+ }
+ #region [ 菴懊ｊ逶ｴ縺 ]
+ if (IsEndedBranching)
+ {
+ if (this.IsBranchBarDraw[i])
+ chip.bBranch = true;
+ }
+ else
+ {
+ if (this.IsBranchBarDraw[(int)n迴ｾ蝨ｨ縺ｮ繧ｳ繝ｼ繧ｹ])
+ chip.bBranch = true;
+ }
+ #endregion
+
+ this.listChip.Add(chip);
+
+ #region [ 菴懊ｊ逶ｴ縺 ]
+ if (IsEndedBranching)
+ this.IsBranchBarDraw[i] = false;
+ else this.IsBranchBarDraw[(int)n迴ｾ蝨ｨ縺ｮ繧ｳ繝ｼ繧ｹ] = false;
+ #endregion
+ }
+
+
+ this.dbLastTime = this.dbNowTime;
+ this.b蟆冗ｯ邱壹ｒ謖ｿ蜈･縺励※縺繧 = true;
+
+ #region[ 諡咲ｷ壹メ繝繝励ユ繧ｹ繝 ]
+ //1諡阪ｮ譎る俣繧定ｨ育ｮ
+ double db1諡 = (60.0 / this.dbNowBPM) / 4.0;
+ //for繝ｫ繝ｼ繝(諡肴焚)
+ for (int measure = 1; measure < this.fNow_Measure_s; measure++)
+ {
+ CChip hakusen = new CChip();
+ hakusen.n逋ｺ螢ｰ菴咲ｽｮ = ((this.n迴ｾ蝨ｨ縺ｮ蟆冗ｯ謨ｰ) * 384);
+ hakusen.n逋ｺ螢ｰ譎ょ綾ms = (int)(this.dbNowTime + (((db1諡 * 4.0)) * measure) * 1000.0);
+ hakusen.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ = 0x51;
+ //hakusen.n逋ｺ螢ｰ譎ょ綾ms = (int)this.dbNowTime;
+ hakusen.fBMSCROLLTime = this.dbNowBMScollTime;
+ hakusen.n謨ｴ謨ｰ蛟､_蜀驛ｨ逡ｪ蜿ｷ = this.n迴ｾ蝨ｨ縺ｮ蟆冗ｯ謨ｰ;
+ hakusen.n謨ｴ謨ｰ蛟､ = 0;
+ hakusen.dbBPM = this.dbNowBPM;
+ hakusen.dbSCROLL = this.dbNowScroll;
+ hakusen.fNow_Measure_m = this.fNow_Measure_m;
+ hakusen.fNow_Measure_s = this.fNow_Measure_s;
+ hakusen.dbSCROLL_Y = this.dbNowScrollY;
+ hakusen.n繧ｳ繝ｼ繧ｹ = n迴ｾ蝨ｨ縺ｮ繧ｳ繝ｼ繧ｹ;
+
+ this.listChip.Add(hakusen);
+ //--蜈ｨ縺ｦ縺ｮ諡咲ｷ壹ｮ譎る俣繧貞ｺ蜉帙☆繧--
+ //Trace.WriteLine( string.Format( "|| {0,3:##0} Time:{1} Beat:{2}", this.n迴ｾ蝨ｨ縺ｮ蟆冗ｯ謨ｰ, hakusen.n逋ｺ螢ｰ譎ょ綾ms, measure ) );
+ //--------------------------------
+ }
+
+ #endregion
+
+ }
+
+ for (int n = 0; n < InputText.Length; n++)
+ {
+ if (InputText.Substring(n, 1) == ",")
+ {
+ this.n迴ｾ蝨ｨ縺ｮ蟆冗ｯ謨ｰ++;
+ this.b蟆冗ｯ邱壹ｒ謖ｿ蜈･縺励※縺繧 = false;
+ return;
+ }
+
+ if (InputText.Substring(0, 1) == "F")
+ {
+ bool bTest = true;
+ }
+
+
+ int nObjectNum = this.CharConvertNote(InputText.Substring(n, 1));
+
+ if (nObjectNum != 0)
+ {
+ if ((nObjectNum >= 5 && nObjectNum <= 7) || nObjectNum == 9)
+ {
+ if (nNowRoll != 0)
+ {
+ this.dbNowTime += (15000.0 / this.dbNowBPM * (this.fNow_Measure_s / this.fNow_Measure_m) * (16.0 / n譁蟄玲焚));
+ this.dbNowBMScollTime += (double)((this.dbBarLength) * (16.0 / n譁蟄玲焚));
+ continue;
+ }
+ else
+ {
+ this.nNowRollCount = listChip.Count;
+ nNowRoll = nObjectNum;
+ }
+ }
+
+ // IsEndedBranching縺掲alse縺ｧ1蝗
+ // true縺ｧ3蝗槭□繧3蝗
+ for (int i = 0; i < (IsEndedBranching == true ? 3 : 1); i++)
+ {
+ var chip = new CChip();
+ chip.IsMissed = false;
+ chip.bHit = false;
+ chip.b蜿ｯ隕 = true;
+ chip.bShow = true;
+ chip.bShowRoll = true;
+ chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ = 0x10 + nObjectNum;
+ //chip.n逋ｺ螢ｰ菴咲ｽｮ = (this.n迴ｾ蝨ｨ縺ｮ蟆冗ｯ謨ｰ * 384) + ((384 * n) / n譁蟄玲焚);
+ chip.n逋ｺ螢ｰ菴咲ｽｮ = (int)((this.n迴ｾ蝨ｨ縺ｮ蟆冗ｯ謨ｰ * 384.0) + ((384.0 * n) / n譁蟄玲焚));
+ chip.db逋ｺ螢ｰ菴咲ｽｮ = this.dbNowTime;
+ chip.n逋ｺ螢ｰ譎ょ綾ms = (int)this.dbNowTime;
+ //chip.fBMSCROLLTime = (float)(( this.dbBarLength ) * (16.0f / this.n蜷蟆冗ｯ縺ｮ譁蟄玲焚[this.n迴ｾ蝨ｨ縺ｮ蟆冗ｯ謨ｰ]));
+ chip.fBMSCROLLTime = (float)this.dbNowBMScollTime;
+ chip.n謨ｴ謨ｰ蛟､ = nObjectNum;
+ chip.n謨ｴ謨ｰ蛟､_蜀驛ｨ逡ｪ蜿ｷ = 1;
+ chip.IsEndedBranching = IsEndedBranching;
+ chip.fNow_Measure_m = this.fNow_Measure_m;
+ chip.fNow_Measure_s = this.fNow_Measure_s;
+ chip.dbBPM = this.dbNowBPM;
+ chip.dbSCROLL = this.dbNowScroll;
+ chip.dbSCROLL_Y = this.dbNowScrollY;
+ chip.n繧ｹ繧ｯ繝ｭ繝ｼ繝ｫ譁ｹ蜷 = this.n繧ｹ繧ｯ繝ｭ繝ｼ繝ｫ譁ｹ蜷;
+
+ if (IsEndedBranching)
+ chip.n繧ｳ繝ｼ繧ｹ = (ECourse)i;
+ else
+ chip.n繧ｳ繝ｼ繧ｹ = n迴ｾ蝨ｨ縺ｮ繧ｳ繝ｼ繧ｹ;
+
+ chip.n蛻蟯仙屓謨ｰ = this.n蜀驛ｨ逡ｪ蜿ｷBRANCH1to;
+ chip.e讌ｽ蝎ｨ繝代ｼ繝 = E讌ｽ蝎ｨ繝代ｼ繝.TAIKO;
+ chip.n繝弱ｼ繝蜃ｺ迴ｾ譎ょ綾ms = (int)(this.db蜃ｺ迴ｾ譎ょ綾 * 1000.0);
+ chip.n繝弱ｼ繝遘ｻ蜍暮幕蟋区凾蛻ｻms = (int)(this.db遘ｻ蜍募ｾ讖滓凾蛻ｻ * 1000.0);
+ chip.nPlayerSide = this.nPlayerSide;
+ chip.bGOGOTIME = this.bGOGOTIME;
+
+ if (nObjectNum == 7 || nObjectNum == 9)
+ {
+ //this.n迴ｾ蝨ｨ縺ｮ繧ｳ繝ｼ繧ｹ繧痴witch縺ｧ蛻蟯舌＠縺ｦ縺縺溘◆繧鬚ｨ闊ｹ縺ｮ蛟､縺後≧縺ｾ縺丞牡繧雁ｽ薙※繧峨ｌ縺ｦ縺縺ｪ縺 2020.04.21 akasoko26
+
+ switch (chip.n繧ｳ繝ｼ繧ｹ)
+ {
+ case ECourse.eNormal:
+ if (this.listBalloon_Normal.Count == 0)
+ {
+ chip.nBalloon = 5;
+ break;
+ }
+
+ if (this.listBalloon_Normal.Count > this.listBalloon_Normal_謨ｰ蛟､邂｡逅)
+ {
+ chip.nBalloon = this.listBalloon_Normal[this.listBalloon_Normal_謨ｰ蛟､邂｡逅];
+ this.listBalloon_Normal_謨ｰ蛟､邂｡逅++;
+ break;
+ }
+ //else if( this.listBalloon.Count != 0 )
+ //{
+ // chip.nBalloon = this.listBalloon[ this.listBalloon_Normal_謨ｰ蛟､邂｡逅 ];
+ // this.listBalloon_Normal_謨ｰ蛟､邂｡逅++;
+ // break;
+ //}
+ break;
+ case ECourse.eExpert:
+ if (this.listBalloon_Expert.Count == 0)
+ {
+ chip.nBalloon = 5;
+ break;
+ }
+
+ if (this.listBalloon_Expert.Count > this.listBalloon_Expert_謨ｰ蛟､邂｡逅)
+ {
+ chip.nBalloon = this.listBalloon_Expert[this.listBalloon_Expert_謨ｰ蛟､邂｡逅];
+ this.listBalloon_Expert_謨ｰ蛟､邂｡逅++;
+ break;
+ }
+ //else if( this.listBalloon.Count != 0 )
+ //{
+ // chip.nBalloon = this.listBalloon[ this.listBalloon_Normal_謨ｰ蛟､邂｡逅 ];
+ // this.listBalloon_Normal_謨ｰ蛟､邂｡逅++;
+ // break;
+ //}
+ break;
+ case ECourse.eMaster:
+ if (this.listBalloon_Master.Count == 0)
+ {
+ chip.nBalloon = 5;
+ break;
+ }
+
+ if (this.listBalloon_Master.Count > this.listBalloon_Master_謨ｰ蛟､邂｡逅)
+ {
+ chip.nBalloon = this.listBalloon_Master[this.listBalloon_Master_謨ｰ蛟､邂｡逅];
+ this.listBalloon_Master_謨ｰ蛟､邂｡逅++;
+ break;
+ }
+ //else if( this.listBalloon.Count != 0 )
+ //{
+ // chip.nBalloon = this.listBalloon[ this.listBalloon_Normal_謨ｰ蛟､邂｡逅 ];
+ // this.listBalloon_Normal_謨ｰ蛟､邂｡逅++;
+ // break;
+ //}
+ break;
+ }
+ }
+ if (nObjectNum == 8)
+ {
+ chip.n繝弱ｼ繝邨ゆｺ菴咲ｽｮ = (this.n迴ｾ蝨ｨ縺ｮ蟆冗ｯ謨ｰ * 384) + ((384 * n) / n譁蟄玲焚);
+ chip.n繝弱ｼ繝邨ゆｺ譎ょ綾ms = (int)this.dbNowTime;
+ chip.fBMSCROLLTime_end = (float)this.dbNowBMScollTime;
+
+ chip.n繝弱ｼ繝蜃ｺ迴ｾ譎ょ綾ms = listChip[nNowRollCount].n繝弱ｼ繝蜃ｺ迴ｾ譎ょ綾ms;
+ chip.n繝弱ｼ繝遘ｻ蜍暮幕蟋区凾蛻ｻms = listChip[nNowRollCount].n繝弱ｼ繝遘ｻ蜍暮幕蟋区凾蛻ｻms;
+
+ chip.n騾｣謇馴浹隨ｦState = nNowRoll;
+ listChip[nNowRollCount].n繝弱ｼ繝邨ゆｺ菴咲ｽｮ = (this.n迴ｾ蝨ｨ縺ｮ蟆冗ｯ謨ｰ * 384) + ((384 * n) / n譁蟄玲焚);
+ listChip[nNowRollCount].n繝弱ｼ繝邨ゆｺ譎ょ綾ms = (int)this.dbNowTime;
+ listChip[nNowRollCount].fBMSCROLLTime_end = (int)this.dbNowBMScollTime;
+ //listChip[ nNowRollCount ].dbBPM = this.dbNowBPM;
+ //listChip[ nNowRollCount ].dbSCROLL = this.dbNowSCROLL;
+ nNowRoll = 0;
+ //continue;
+ }
+
+ if (IsEnabledFixSENote)
+ {
+ chip.IsFixedSENote = true;
+ chip.nSenote = FixSENote - 1;
+ }
+
+ #region[ 蝗ｺ螳壹＆繧後ｋ遞ｮ鬘槭ｮsenotes縺ｯ縺薙％縺ｧ險ｭ螳壹＠縺ｦ縺翫￥縲 ]
+ switch (nObjectNum)
+ {
+ case 3:
+ chip.nSenote = 5;
+ break;
+ case 4:
+ chip.nSenote = 6;
+ break;
+ case 5:
+ chip.nSenote = 7;
+ break;
+ case 6:
+ chip.nSenote = 0xA;
+ break;
+ case 7:
+ chip.nSenote = 0xB;
+ break;
+ case 8:
+ chip.nSenote = 0xC;
+ break;
+ case 9:
+ chip.nSenote = 0xD;
+ break;
+ case 10:
+ chip.nSenote = 0xE;
+ break;
+ case 11:
+ chip.nSenote = 0xF;
+ break;
+ }
+ #endregion
+
+ if (nObjectNum < 5)
+ {
+ #region [ 菴懊ｊ逶ｴ縺 ]
+ //隴憺擇蛻蟯舌′縺ｪ縺隴憺擇縺ｧ繧ょ､縺ｯ蜉邂励＆繧後※縺励∪縺縺後＠繧縺ゅ↑縺
+ //蛻蟯舌ｒ髢句ｧ九＠縺ｪ縺髢薙ｯ蜈ｱ騾夊ｭ憺擇縺ｨ縺励※縺ｿ縺ｪ縺吶
+ if (IsEndedBranching)
+ this.n繝弱ｼ繝謨ｰ_Branch[i]++;
+ else this.n繝弱ｼ繝謨ｰ_Branch[(int)chip.n繧ｳ繝ｼ繧ｹ]++;
+
+ if (!IsEndedBranching && !this.b蛻蟯舌ｒ荳蝗槭〒繧る幕蟋九＠縺)
+ {
+ //IsEndedBranching==false = forloop縺瑚｡後ｏ繧後※縺縺ｪ縺縺ｨ縺阪ｮ縺ｿ
+ for (int l = 0; l < 3; l++)
+ this.n繝弱ｼ繝謨ｰ_Branch[l]++;
+ }
+
+
+ if(this.n蜿らｧ荳ｭ縺ｮ髮｣譏灘ｺｦ == (int)Difficulty.Dan)
+ this.nDan_NotesCount[DanSongs.Number - 1]++;
+
+ this.n繝弱ｼ繝謨ｰ[3]++;
+ #endregion
+ }
+ else if (nObjectNum == 7)
+ {
+ //鬚ｨ闊ｹ縺ｯ縺薙ｮ縺ｾ縺ｾ縺ｧ繧よｩ溯ｽ縺励※縺繧九ｮ縺ｧ菴輔ｂ縺励↑縺.
+
+ if (this.b譛蛻昴ｮ蛻蟯舌〒縺ゅｋ == false)
+ this.n鬚ｨ闊ｹ謨ｰ[(int)this.n迴ｾ蝨ｨ縺ｮ繧ｳ繝ｼ繧ｹ]++;
+ else
+ this.n鬚ｨ闊ｹ謨ｰ[3]++;
+ }
+
+ Array.Resize(ref nDan_NotesCount, nDan_NotesCount.Length + 1);
+ this.listChip.Add(chip);
+
+ if(IsEndedBranching)
+ this.listChip_Branch[i].Add(chip);
+ else
+ this.listChip_Branch[(int)chip.n繧ｳ繝ｼ繧ｹ].Add(chip);
+ }
+ }
+
+ if (IsEnabledFixSENote) IsEnabledFixSENote = false;
+
+ this.dbLastTime = this.dbNowTime;
+ this.dbLastBMScrollTime = this.dbNowBMScollTime;
+ this.dbNowTime += (15000.0 / this.dbNowBPM * (this.fNow_Measure_s / this.fNow_Measure_m) * (16.0 / n譁蟄玲焚));
+ this.dbNowBMScollTime += (((this.fNow_Measure_s / this.fNow_Measure_m)) * (16.0 / (double)n譁蟄玲焚));
+ }
+ }
+ }
+ }
+
+ ///
+ /// 髮｣譏灘ｺｦ縺斐→縺ｫ繧医▲縺ｦ螟峨ｏ繧九倥ャ繝蛟､繧定ｪｭ縺ｿ霎ｼ繧縲
+ /// (BALLOON縺ｪ縺ｩ縲)
+ ///
+ ///
+ private void t髮｣譏灘ｺｦ蛻･繝倥ャ繝(string InputText)
+ {
+ if (TJAPlayer3.actEnumSongs.b豢ｻ諤ｧ蛹悶＠縺ｦ縺ｪ縺)
+ {
+ if (InputText.Equals("#HBSCROLL") && TJAPlayer3.ConfigIni.b繧ｹ繧ｯ繝ｭ繝ｼ繝ｫ繝｢繝ｼ繝峨ｒ荳頑嶌縺 == false)
+ {
+ TJAPlayer3.ConfigIni.eScrollMode = EScrollMode.HBSCROLL;
+ }
+ if (InputText.Equals("#BMSCROLL") && TJAPlayer3.ConfigIni.b繧ｹ繧ｯ繝ｭ繝ｼ繝ｫ繝｢繝ｼ繝峨ｒ荳頑嶌縺 == false)
+ {
+ TJAPlayer3.ConfigIni.eScrollMode = EScrollMode.BMSCROLL;
+ }
+ }
+
+ string[] strArray = InputText.Split(new char[] { ':' });
+ string strCommandName = "";
+ string strCommandParam = "";
+
+ if (strArray.Length == 2)
+ {
+ strCommandName = strArray[0].Trim();
+ strCommandParam = strArray[1].Trim();
+ }
+
+ void ParseOptionalInt16(Action setValue)
+ {
+ this.ParseOptionalInt16(strCommandName, strCommandParam, setValue);
+ }
+
+ if (strCommandName.Equals("BALLOON") || strCommandName.Equals("BALLOONNOR"))
+ {
+ ParseBalloon(strCommandParam, this.listBalloon_Normal);
+ }
+ else if (strCommandName.Equals("BALLOONEXP"))
+ {
+ ParseBalloon(strCommandParam, this.listBalloon_Expert);
+ //tbBALLOON.Text = strCommandParam;
+ }
+ else if (strCommandName.Equals("BALLOONMAS"))
+ {
+ ParseBalloon(strCommandParam, this.listBalloon_Master);
+ //tbBALLOON.Text = strCommandParam;
+ }
+ else if (strCommandName.Equals("SCOREMODE"))
+ {
+ ParseOptionalInt16(value => this.nScoreModeTmp = value);
+ }
+ else if (strCommandName.Equals("SCOREINIT"))
+ {
+ if (!string.IsNullOrEmpty(strCommandParam))
+ {
+ string[] scoreinit = strCommandParam.Split(',');
+
+ this.ParseOptionalInt16("SCOREINIT first value", scoreinit[0], value =>
+ {
+ this.nScoreInit[0, this.n蜿らｧ荳ｭ縺ｮ髮｣譏灘ｺｦ] = value;
+ this.b驟咲せ縺梧欠螳壹＆繧後※縺繧擬0, this.n蜿らｧ荳ｭ縺ｮ髮｣譏灘ｺｦ] = true;
+ });
+
+ if (scoreinit.Length == 2)
+ {
+ this.ParseOptionalInt16("SCOREINIT second value", scoreinit[1], value =>
+ {
+ this.nScoreInit[1, this.n蜿らｧ荳ｭ縺ｮ髮｣譏灘ｺｦ] = value;
+ this.b驟咲せ縺梧欠螳壹＆繧後※縺繧擬2, this.n蜿らｧ荳ｭ縺ｮ髮｣譏灘ｺｦ] = true;
+ });
+ }
+ }
+ }
+ else if (strCommandName.Equals("SCOREDIFF"))
+ {
+ ParseOptionalInt16(value =>
+ {
+ this.nScoreDiff[this.n蜿らｧ荳ｭ縺ｮ髮｣譏灘ｺｦ] = value;
+ this.b驟咲せ縺梧欠螳壹＆繧後※縺繧擬1, this.n蜿らｧ荳ｭ縺ｮ髮｣譏灘ｺｦ] = true;
+ });
+ }
+
+ //if( this.nScoreModeTmp == 99 ) //2017.01.28 DD SCOREMODE繧貞･蜉帙＠縺ｦ縺縺ｪ縺蝣ｴ蜷医ｮ縺ｿConfig縺ｧ險ｭ螳壹＠縺溘Δ繝ｼ繝峨↓縺吶ｋ
+ //{
+ // this.nScoreModeTmp = CDTXMania.ConfigIni.nScoreMode;
+ //}
+ //if( CDTXMania.ConfigIni.nScoreMode == 3 && !this.b驟咲せ縺梧欠螳壹＆繧後※縺繧擬 2, this.n蜿らｧ荳ｭ縺ｮ髮｣譏灘ｺｦ ] ){ //2017.06.04 kairera0467
+ // this.nScoreModeTmp = 3;
+ //}
+
+
+
+ else if (strCommandName.Equals("SCOREMODE"))
+ {
+ if (!string.IsNullOrEmpty(strCommandParam))
+ {
+ this.nScoreModeTmp = Convert.ToInt16(strCommandParam);
+ }
+ }
+ else if (strCommandName.Equals("SCOREINIT"))
+ {
+ if (!string.IsNullOrEmpty(strCommandParam))
+ {
+ string[] scoreinit = strCommandParam.Split(',');
+
+ this.nScoreInit[0, this.n蜿らｧ荳ｭ縺ｮ髮｣譏灘ｺｦ] = Convert.ToInt16(scoreinit[0]);
+ this.b驟咲せ縺梧欠螳壹＆繧後※縺繧擬0, this.n蜿らｧ荳ｭ縺ｮ髮｣譏灘ｺｦ] = true;
+ if (scoreinit.Length == 2)
+ {
+ this.nScoreInit[1, this.n蜿らｧ荳ｭ縺ｮ髮｣譏灘ｺｦ] = Convert.ToInt16(scoreinit[1]);
+ this.b驟咲せ縺梧欠螳壹＆繧後※縺繧擬2, this.n蜿らｧ荳ｭ縺ｮ髮｣譏灘ｺｦ] = true;
+ }
+ }
+ }
+ else if (strCommandName.Equals("SCOREDIFF"))
+ {
+ if (!string.IsNullOrEmpty(strCommandParam))
+ {
+ this.nScoreDiff[this.n蜿らｧ荳ｭ縺ｮ髮｣譏灘ｺｦ] = Convert.ToInt16(strCommandParam);
+ this.b驟咲せ縺梧欠螳壹＆繧後※縺繧擬1, this.n蜿らｧ荳ｭ縺ｮ髮｣譏灘ｺｦ] = true;
+ }
+ }
+ if (this.nScoreModeTmp == 99) //2017.01.28 DD SCOREMODE繧貞･蜉帙＠縺ｦ縺縺ｪ縺蝣ｴ蜷医ｮ縺ｿConfig縺ｧ險ｭ螳壹＠縺溘Δ繝ｼ繝峨↓縺吶ｋ
+ {
+ this.nScoreModeTmp = TJAPlayer3.ConfigIni.nScoreMode;
+ }
+ if (TJAPlayer3.ConfigIni.nScoreMode == 3 && !this.b驟咲せ縺梧欠螳壹＆繧後※縺繧擬2, this.n蜿らｧ荳ｭ縺ｮ髮｣譏灘ｺｦ])
+ { //2017.06.04 kairera0467
+ this.nScoreModeTmp = 3;
+ }
+ }
+
+ private void tDanExamLoad(string input)
+ {
+ string[] strArray = input.Split(new char[] { ':' });
+ string strCommandName = "";
+ string strCommandParam = "";
+
+ if (strArray.Length == 2)
+ {
+ strCommandName = strArray[0].Trim();
+ strCommandParam = strArray[1].Trim();
+ }
+
+ if (strCommandName.Equals("EXAM1") || strCommandName.Equals("EXAM2") || strCommandName.Equals("EXAM3") || strCommandName.Equals("EXAM4"))
+ {
+ if (!string.IsNullOrEmpty(strCommandParam))
+ {
+ Exam.Type examType;
+ int[] examValue;
+ Exam.Range examRange;
+ var splitExam = strCommandParam.Split(',');
+ switch (splitExam[0])
+ {
+ case "g":
+ examType = Exam.Type.Gauge;
+ break;
+ case "jp":
+ examType = Exam.Type.JudgePerfect;
+ break;
+ case "jg":
+ examType = Exam.Type.JudgeGood;
+ break;
+ case "jb":
+ examType = Exam.Type.JudgeBad;
+ break;
+ case "s":
+ examType = Exam.Type.Score;
+ break;
+ case "r":
+ examType = Exam.Type.Roll;
+ break;
+ case "h":
+ examType = Exam.Type.Hit;
+ break;
+ case "c":
+ examType = Exam.Type.Combo;
+ break;
+ default:
+ examType = Exam.Type.Gauge;
+ break;
+ }
+ try
+ {
+ examValue = new int[] { int.Parse(splitExam[1]), int.Parse(splitExam[2]) };
+ }
+ catch (Exception)
+ {
+ examValue = new int[] { 100, 100 };
+ }
+ switch (splitExam[3])
+ {
+ case "m":
+ examRange = Exam.Range.More;
+ break;
+ case "l":
+ examRange = Exam.Range.Less;
+ break;
+ default:
+ examRange = Exam.Range.More;
+ break;
+ }
+
+ if(Dan_C[int.Parse(strCommandName.Substring(4)) - 1] == null)
+ Dan_C[int.Parse(strCommandName.Substring(4)) - 1] = new Dan_C(examType, examValue, examRange);
+
+ List_DanSongs[DanSongs.Number - 1].Dan_C[int.Parse(strCommandName.Substring(4)) - 1] = new Dan_C(examType, examValue, examRange);
+ }
+ }
+ }
+
+ private void ParseOptionalInt16(string name, string unparsedValue, Action setValue)
+ {
+ if (string.IsNullOrEmpty(unparsedValue))
+ {
+ return;
+ }
+
+ if (short.TryParse(unparsedValue, out var value))
+ {
+ setValue(value);
+ }
+ else
+ {
+ Trace.TraceWarning($"蜻ｽ莉､蜷: {name} 縺ｮ繝代Λ繝｡繝ｼ繧ｿ縺ｮ蛟､縺梧ｭ｣縺励￥縺ｪ縺縺薙→繧呈､懃衍縺励∪縺励◆縲ょ､: {unparsedValue} ({str繝輔ぃ繧､繝ｫ蜷阪ｮ邨ｶ蟇ｾ繝代せ})");
+ }
+ }
+
+
+ private void ParseBalloon(string strCommandParam, List listBalloon)
+ {
+ string[] strParam = strCommandParam.Split(',');
+ for (int n = 0; n < strParam.Length; n++)
+ {
+ int n謇捺焚;
+ try
+ {
+ if (strParam[n] == null || strParam[n] == "")
+ break;
+
+ n謇捺焚 = Convert.ToInt32(strParam[n]);
+ }
+ catch (Exception ex)
+ {
+ Trace.TraceError($"縺翫ｄ?繧ｨ繝ｩ繝ｼ縺悟ｺ縺溘ｈ縺縺ｧ縺吶ゅ♀蜈讒倥 ({str繝輔ぃ繧､繝ｫ蜷阪ｮ邨ｶ蟇ｾ繝代せ})");
+ Trace.TraceError(ex.ToString());
+ Trace.TraceError("萓句､悶′逋ｺ逕溘＠縺ｾ縺励◆縺悟ｦ逅繧堤ｶ咏ｶ壹＠縺ｾ縺吶 (95327158-4e83-4fa9-b5e9-ad3c3d4c2a22)");
+ break;
+ }
+
+ listBalloon.Add(n謇捺焚);
+ }
+ }
+ private void t蜈･蜉媽陦瑚ｧ｣譫舌倥ャ繝(string InputText)
+ {
+ //繧縺ｹ繝ｼ縲ょ磯ｭ縺ｫ繧ｳ繝｡繝ｳ繝郁｡後≠縺｣縺溘ｉ繧縺ｰ縺繧繧薙
+ string[] strArray = InputText.Split(new char[] { ':' });
+ string strCommandName = "";
+ string strCommandParam = "";
+
+ if (InputText.StartsWith("#BRANCHSTART"))
+ {
+ //2015.08.18 kairera0467
+ //譛ｬ譚･縺ｯ繝倥ャ繝蜻ｽ莉､縺ｧ縺ｯ縺ゅｊ縺ｾ縺帙ｓ縺後髮｣譏灘ｺｦ縺斐→縺ｫ驕輔≧鬆逶ｮ縺ｪ縺ｮ縺ｧ縺薙％縺ｧ隱ｭ縺ｿ霎ｼ縺ｾ縺帙∪縺吶
+ //Length縺ｮ繝√ぉ繝繧ｯ繧偵＆繧後ｋ蜑阪↓縺ｫif譁繧貞･繧後※縺縺ｾ縺吶
+ this.bHasBranch[this.n蜿らｧ荳ｭ縺ｮ髮｣譏灘ｺｦ] = true;
+ }
+
+ //縺ｾ縺壹ｯ縲:縲阪〒Split縺励※蜑ｲ繧雁ｽ薙※繧九
+ if (strArray.Length == 2)
+ {
+ strCommandName = strArray[0].Trim();
+ strCommandParam = strArray[1].Trim();
+ }
+ else if (strArray.Length > 2)
+ {
+ //strArray縺2縺倥ｃ縺ｪ縺蝣ｴ蜷医√倥ャ繝縺ｮSplit繧帝壹＠縺ｦ縺縺ｪ縺蜿ｯ閭ｽ諤ｧ縺後≠繧九
+ //縺薙ｮ蜃ｦ逅閾ｪ菴薙ｯ縲荊蜈･蜉帙阪ｒ謾ｹ騾縺励◆繧ゅｮ縲４TART縺ｧSplit縺励※縺縺ｪ縺遲峨∽ｸ驛ｨ縺ｮ蜃ｦ逅縺檎焚縺ｪ繧九
+
+ #region[繝倥ャ繝]
+ InputText = InputText.Replace(Environment.NewLine, "\n"); //謾ｹ陦梧枚蟄励ｒ蛻･縺ｮ譁蟄怜励↓蟾ｮ縺玲崛縺医
+ InputText = InputText.Replace('\t', ' '); //菴輔ｮ譁蟄励°遏･繧峨↑縺縺代←繧ｹ繝壹ｼ繧ｹ縺ｫ蟾ｮ縺玲崛縺医
+ InputText = InputText + "\n";
+
+ string[] strDelimiter2 = { "\n" };
+ strArray = InputText.Split(strDelimiter2, StringSplitOptions.RemoveEmptyEntries);
+
+
+ strArray = strArray[0].Split(new char[] { ':' });
+ WarnSplitLength("Header Name & Value", strArray, 2);
+
+ strCommandName = strArray[0].Trim();
+ strCommandParam = strArray[1].Trim();
+
+ #endregion
+ //lblMessage.Text = "縺翫ｄ?strArray縺ｮLength縺2縺倥ｃ縺ｪ縺繧医≧縺ｧ縺吶ｭ縲ゅ♀蜈讒倥";
+ }
+
+ void ParseOptionalInt16(Action setValue)
+ {
+ this.ParseOptionalInt16(strCommandName, strCommandParam, setValue);
+ }
+
+ //繝代Λ繝｡繝ｼ繧ｿ繧貞蛻･縲√◎縺薙°繧牙牡繧雁ｽ薙※縺ｦ縺縺阪∪縺吶
+ if (strCommandName.Equals("TITLE"))
+ {
+ //this.TITLE = strCommandParam;
+ var subTitle = "";
+ for (int i = 0; i < strArray.Length; i++)
+ {
+ subTitle += strArray[i];
+ }
+ this.TITLE = subTitle.Substring(5);
+ //tbTitle.Text = strCommandParam;
+ }
+ if (strCommandName.Equals("SUBTITLE"))
+ {
+ if (strCommandParam.StartsWith("--"))
+ {
+ //this.SUBTITLE = strCommandParam.Remove( 0, 2 );
+ var subTitle = "";
+ for (int i = 0; i < strArray.Length; i++)
+ {
+ subTitle += strArray[i];
+ }
+ this.SUBTITLE = subTitle.Substring(10);
+ }
+ else if (strCommandParam.StartsWith("++"))
+ {
+ // //this.TITLE += strCommandParam.Remove( 0, 2 ); //縺薙ｮ縺ｾ縺ｾ縺縺ｨ驕ｸ譖ｲ逕ｻ髱｢縺ｮ陦ｨ遉ｺ縺後≧縺ｾ縺上＞縺九↑縺縲
+ //this.SUBTITLE = strCommandParam.Remove( 0, 2 );
+ var subTitle = "";
+ for (int i = 0; i < strArray.Length; i++)
+ {
+ subTitle += strArray[i];
+ }
+ this.SUBTITLE = subTitle.Substring(10);
+ }
+ }
+ else if (strCommandName.Equals("LEVEL"))
+ {
+ var level = (int)Convert.ToDouble(strCommandParam);
+ this.LEVEL.Drums = level;
+ this.LEVEL.Taiko = level;
+ this.LEVELtaiko[this.n蜿らｧ荳ｭ縺ｮ髮｣譏灘ｺｦ] = level;
+ }
+ else if (strCommandName.Equals("BPM"))
+ {
+ if (strCommandParam.IndexOf(",") != -1)
+ strCommandParam = strCommandParam.Replace(',', '.');
+
+ double dbBPM = Convert.ToDouble(strCommandParam);
+ this.BPM = dbBPM;
+ this.BASEBPM = dbBPM;
+ this.dbNowBPM = dbBPM;
+
+ this.listBPM.Add(this.n蜀驛ｨ逡ｪ蜿ｷBPM1to - 1, new CBPM() { n蜀驛ｨ逡ｪ蜿ｷ = this.n蜀驛ｨ逡ｪ蜿ｷBPM1to - 1, n陦ｨ險倅ｸ翫ｮ逡ｪ蜿ｷ = this.n蜀驛ｨ逡ｪ蜿ｷBPM1to - 1, dbBPM蛟､ = dbBPM, });
+ this.n蜀驛ｨ逡ｪ蜿ｷBPM1to++;
+
+
+ //繝√ャ繝苓ｿｽ蜉縺励※蜑ｲ繧願ｾｼ繧薙〒縺ｿ繧九
+ var chip = new CChip();
+
+ chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ = 0x03;
+ chip.n逋ｺ螢ｰ菴咲ｽｮ = ((this.n迴ｾ蝨ｨ縺ｮ蟆冗ｯ謨ｰ - 1) * 384);
+ chip.n謨ｴ謨ｰ蛟､ = 0x00;
+ chip.n謨ｴ謨ｰ蛟､_蜀驛ｨ逡ｪ蜿ｷ = 1;
+
+ this.listChip.Add(chip);
+ //tbBPM.Text = strCommandParam;
+ }
+ else if (strCommandName.Equals("WAVE"))
+ {
+ if (strBGM_PATH != null)
+ {
+ Trace.TraceWarning($"{nameof(CDTX)} is ignoring an extra WAVE header in {this.str繝輔ぃ繧､繝ｫ蜷阪ｮ邨ｶ蟇ｾ繝代せ}");
+ }
+ else
+ {
+ this.strBGM_PATH = CDTXCompanionFileFinder.FindFileName(this.str繝輔か繝ｫ繝蜷, str繝輔ぃ繧､繝ｫ蜷, strCommandParam);
+ //tbWave.Text = strCommandParam;
+ if (this.listWAV != null)
+ {
+ // 2018-08-27 twopointzero - DO attempt to load (or queue scanning) loudness metadata here.
+ // TJAP3 is either launching, enumerating songs, or is about to
+ // begin playing a song. If metadata is available, we want it now.
+ // If is not yet available then we wish to queue scanning.
+ var absoluteBgmPath = Path.Combine(this.str繝輔か繝ｫ繝蜷, this.strBGM_PATH);
+ this.SongLoudnessMetadata = LoudnessMetadataScanner.LoadForAudioPath(absoluteBgmPath);
+
+ var wav = new CWAV()
+ {
+ n蜀驛ｨ逡ｪ蜿ｷ = this.n蜀驛ｨ逡ｪ蜿ｷWAV1to,
+ n陦ｨ險倅ｸ翫ｮ逡ｪ蜿ｷ = 1,
+ n繝√ャ繝励し繧､繧ｺ = this.n辟｡髯千ｮ｡逅SIZE[this.n蜀驛ｨ逡ｪ蜿ｷWAV1to],
+ n菴咲ｽｮ = this.n辟｡髯千ｮ｡逅PAN[this.n蜀驛ｨ逡ｪ蜿ｷWAV1to],
+ SongVol = this.SongVol,
+ SongLoudnessMetadata = this.SongLoudnessMetadata,
+ str繝輔ぃ繧､繝ｫ蜷 = this.strBGM_PATH,
+ str繧ｳ繝｡繝ｳ繝域枚 = "TJA BGM",
+ };
+
+ this.listWAV.Add(this.n蜀驛ｨ逡ｪ蜿ｷWAV1to, wav);
+ this.n蜀驛ｨ逡ｪ蜿ｷWAV1to++;
+ }
+ }
+ }
+ else if (strCommandName.Equals("OFFSET") && !string.IsNullOrEmpty(strCommandParam))
+ {
+ this.nOFFSET = (int)(Convert.ToDouble(strCommandParam) * 1000);
+ this.bOFFSET縺ｮ蛟､縺後槭う繝翫せ縺ｧ縺ゅｋ = this.nOFFSET < 0 ? true : false;
+
+ this.listBPM[0].bpm_change_bmscroll_time = -2000 * this.dbNowBPM / 15000;
+ if (this.bOFFSET縺ｮ蛟､縺後槭う繝翫せ縺ｧ縺ゅｋ == true)
+ this.nOFFSET = this.nOFFSET * -1; //OFFSET縺ｯ遘偵ｒ蜉邂励☆繧九ｮ縺ｧ縲∝ｿ縺壽ｭ｣縺ｮ謨ｰ縺ｫ縺吶ｋ縺薙→縲
+ //tbOFFSET.Text = strCommandParam;
+ }
+ else if (strCommandName.Equals("MOVIEOFFSET"))
+ {
+ this.nMOVIEOFFSET = (int)(Convert.ToDouble(strCommandParam) * 1000);
+ this.bMOVIEOFFSET縺ｮ蛟､縺後槭う繝翫せ縺ｧ縺ゅｋ = this.nMOVIEOFFSET < 0 ? true : false;
+
+ if (this.bMOVIEOFFSET縺ｮ蛟､縺後槭う繝翫せ縺ｧ縺ゅｋ == true)
+ this.nMOVIEOFFSET = this.nMOVIEOFFSET * -1; //OFFSET縺ｯ遘偵ｒ蜉邂励☆繧九ｮ縺ｧ縲∝ｿ縺壽ｭ｣縺ｮ謨ｰ縺ｫ縺吶ｋ縺薙→縲
+ //tbOFFSET.Text = strCommandParam;
+ }
+ #region[遘ｻ蜍補剃ｸ榊ｷ蜷医′襍ｷ縺薙ｋ縺ｮ縺ｧ縺薙％繧ゆｸ蠢懷ｾｩ豢ｻ縺輔○縺ｦ縺翫￥]
+ else if (strCommandName.Equals("BALLOON") || strCommandName.Equals("BALLOONNOR"))
+ {
+ ParseBalloon(strCommandParam, this.listBalloon_Normal);
+ }
+ else if (strCommandName.Equals("BALLOONEXP"))
+ {
+ ParseBalloon(strCommandParam, this.listBalloon_Expert);
+ //tbBALLOON.Text = strCommandParam;
+ }
+ else if (strCommandName.Equals("BALLOONMAS"))
+ {
+ ParseBalloon(strCommandParam, this.listBalloon_Master);
+ //tbBALLOON.Text = strCommandParam;
+ }
+ else if (strCommandName.Equals("SCOREMODE"))
+ {
+ ParseOptionalInt16(value => this.nScoreModeTmp = value);
+ }
+ else if (strCommandName.Equals("SCOREINIT"))
+ {
+ if (!string.IsNullOrEmpty(strCommandParam))
+ {
+ string[] scoreinit = strCommandParam.Split(',');
+
+ this.ParseOptionalInt16("SCOREINIT first value", scoreinit[0], value =>
+ {
+ this.nScoreInit[0, this.n蜿らｧ荳ｭ縺ｮ髮｣譏灘ｺｦ] = value;
+ });
+
+ if (scoreinit.Length == 2)
+ {
+ this.ParseOptionalInt16("SCOREINIT second value", scoreinit[1], value =>
+ {
+ this.nScoreInit[1, this.n蜿らｧ荳ｭ縺ｮ髮｣譏灘ｺｦ] = value;
+ });
+ }
+ }
+ }
+ else if (strCommandName.Equals("GAUGEINCR"))
+ {
+ if (!string.IsNullOrEmpty(strCommandParam))
+ {
+ switch (strCommandParam.ToLower())
+ {
+ case "normal":
+ GaugeIncreaseMode = GaugeIncreaseMode.Normal;
+ break;
+ case "floor":
+ GaugeIncreaseMode = GaugeIncreaseMode.Floor;
+ break;
+ case "round":
+ GaugeIncreaseMode = GaugeIncreaseMode.Round;
+ break;
+ case "ceiling":
+ GaugeIncreaseMode = GaugeIncreaseMode.Ceiling;
+ break;
+ case "notfix":
+ GaugeIncreaseMode = GaugeIncreaseMode.NotFix;
+ break;
+ default:
+ GaugeIncreaseMode = GaugeIncreaseMode.Normal;
+ break;
+ }
+ }
+ }
+ else if (strCommandName.Equals("SCOREDIFF"))
+ {
+ ParseOptionalInt16(value => this.nScoreDiff[this.n蜿らｧ荳ｭ縺ｮ髮｣譏灘ｺｦ] = value);
+ }
+ #endregion
+ else if (strCommandName.Equals("SONGVOL") && !string.IsNullOrEmpty(strCommandParam))
+ {
+ this.SongVol = Convert.ToInt32(strCommandParam).Clamp(CSound.MinimumSongVol, CSound.MaximumSongVol);
+
+ foreach (var kvp in this.listWAV)
+ {
+ kvp.Value.SongVol = this.SongVol;
+ }
+ }
+ else if (strCommandName.Equals("SEVOL"))
+ {
+ //tbSeVol.Text = strCommandParam;
+ }
+ else if (strCommandName.Equals("COURSE"))
+ {
+ if (!string.IsNullOrEmpty(strCommandParam))
+ {
+ //this.n蜿らｧ荳ｭ縺ｮ髮｣譏灘ｺｦ = Convert.ToInt16( strCommandParam );
+ this.n蜿らｧ荳ｭ縺ｮ髮｣譏灘ｺｦ = this.strConvertCourse(strCommandParam);
+ }
+ }
+
+ else if (strCommandName.Equals("HEADSCROLL"))
+ {
+ //譁ｰ螳夂ｾｩ:蛻晄悄繧ｹ繧ｯ繝ｭ繝ｼ繝ｫ騾溷ｺｦ險ｭ螳(縺ｨ縺縺繧医ｊ縺薙ｮ繧ｷ繧ｹ繝繝縺ｫ蜷医ｏ縺帙ｋ縺ｫ縺ｯ蠢鬆医)
+ //縺ｩ縺縺励※繧ゆｸ逡ｪ譛蛻昴↓1蟆冗ｯ謖ｿ蜈･縺輔ｌ繧九°繧峨√％縺縺吶ｋ縺励°縺ｪ縺九▲縺溘ｓ縺___
+
+ this.dbScrollSpeed = Convert.ToDouble(strCommandParam);
+
+ this.listSCROLL.Add(this.n蜀驛ｨ逡ｪ蜿ｷSCROLL1to, new CSCROLL() { n蜀驛ｨ逡ｪ蜿ｷ = this.n蜀驛ｨ逡ｪ蜿ｷSCROLL1to, n陦ｨ險倅ｸ翫ｮ逡ｪ蜿ｷ = 0, dbSCROLL蛟､ = this.dbScrollSpeed, });
+
+
+ //繝√ャ繝苓ｿｽ蜉縺励※蜑ｲ繧願ｾｼ繧薙〒縺ｿ繧九
+ var chip = new CChip();
+
+ chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ = 0x9D;
+ chip.n逋ｺ螢ｰ菴咲ｽｮ = ((this.n迴ｾ蝨ｨ縺ｮ蟆冗ｯ謨ｰ - 2) * 384);
+ chip.n謨ｴ謨ｰ蛟､ = 0x00;
+ chip.n謨ｴ謨ｰ蛟､_蜀驛ｨ逡ｪ蜿ｷ = this.n蜀驛ｨ逡ｪ蜿ｷSCROLL1to;
+ chip.dbSCROLL = this.dbScrollSpeed;
+
+ // 繝√ャ繝励ｒ驟咲ｽｮ縲
+
+ this.listChip.Add(chip);
+ this.n蜀驛ｨ逡ｪ蜿ｷSCROLL1to++;
+
+ //this.nScoreDiff = Convert.ToInt16( strCommandParam );
+ //tbScoreDiff.Text = strCommandParam;
+ }
+ else if (strCommandName.Equals("GENRE"))
+ {
+ //2015.03.28 kairera0467
+ //繧ｸ繝｣繝ｳ繝ｫ縺ｮ螳夂ｾｩ縲DTX縺九ｉ蜈･蜉帙ｂ縺ｧ縺阪ｋ縺後》ja縺九ｉ繧ょ･蜉帙〒縺阪ｋ繧医≧縺ｫ縺吶ｋ縲
+ //譌･譛ｬ隱槫錐縺縺ｨ驕ｸ譖ｲ逕ｻ髱｢縺ｧ繝舌げ縺悟ｺ繧九ｮ縺ｧ縲√◎縺薙ｂ縺ｩ縺縺ｫ縺九＠縺ｦ縺縺丈ｺ亥ｮ壹
+
+ if (!string.IsNullOrEmpty(strCommandParam))
+ {
+ this.GENRE = strCommandParam;
+ }
+ }
+ else if (strCommandName.Equals("DEMOSTART"))
+ {
+ //2015.04.10 kairera0467
+
+ if (!string.IsNullOrEmpty(strCommandParam))
+ {
+ int nOFFSETms;
+ try
+ {
+ nOFFSETms = (int)(Convert.ToDouble(strCommandParam) * 1000.0);
+ }
+ catch
+ {
+ nOFFSETms = 0;
+ }
+
+
+ this.n繝繝｢BGM繧ｪ繝輔そ繝繝 = nOFFSETms;
+ }
+ }
+ else if (strCommandName.Equals("BGMOVIE"))
+ {
+ //2016.02.02 kairera0467
+ //閭梧勹蜍慕判縺ｮ螳夂ｾｩ縲DTX縺九ｉ蜈･蜉帙ｂ縺ｧ縺阪ｋ縺後》ja縺九ｉ繧ょ･蜉帙〒縺阪ｋ繧医≧縺ｫ縺吶ｋ縲
+
+ if (!string.IsNullOrEmpty(strCommandParam))
+ {
+ this.strBGVIDEO_PATH =
+ CDTXCompanionFileFinder.FindFileName(this.str繝輔か繝ｫ繝蜷, str繝輔ぃ繧､繝ｫ蜷, strCommandParam);
+ }
+
+ var avi = new CAVI()
+ {
+ n逡ｪ蜿ｷ = 1,
+ str繝輔ぃ繧､繝ｫ蜷 = this.strBGVIDEO_PATH,
+ str繧ｳ繝｡繝ｳ繝域枚 = "BGMOVIE蜻ｽ莉､",
+ };
+
+ if (this.listAVI.ContainsKey(1)) // 譌｢縺ｫ繝ｪ繧ｹ繝井ｸｭ縺ｫ蟄伜惠縺励※縺繧九↑繧牙炎髯､縲ょｾ後ｮ繧ゅｮ縺梧怏蜉ｹ縲
+ this.listAVI.Remove(1);
+
+ this.listAVI.Add(1, avi);
+
+ var ds = new CDirectShow()
+ {
+ n逡ｪ蜿ｷ = 1,
+ str繝輔ぃ繧､繝ｫ蜷 = this.strBGVIDEO_PATH,
+ str繧ｳ繝｡繝ｳ繝域枚 = "BGMOVIE蜻ｽ莉､",
+ };
+
+ if (this.listDS.ContainsKey(1)) // 譌｢縺ｫ繝ｪ繧ｹ繝井ｸｭ縺ｫ蟄伜惠縺励※縺繧九↑繧牙炎髯､縲ょｾ後ｮ繧ゅｮ縺梧怏蜉ｹ縲
+ this.listDS.Remove(1);
+
+ this.listDS.Add(1, ds);
+ }
+ else if (strCommandName.Equals("BGIMAGE"))
+ {
+ //2016.02.02 kairera0467
+ if (!string.IsNullOrEmpty(strCommandParam))
+ {
+ this.strBGIMAGE_PATH = strCommandParam;
+ }
+ }
+ else if (strCommandName.Equals("HIDDENBRANCH"))
+ {
+ //2016.04.01 kairera0467 繝代Λ繝｡繝ｼ繧ｿ繝ｼ縺ｯ
+ if (!string.IsNullOrEmpty(strCommandParam))
+ {
+ this.bHIDDENBRANCH = true;
+ }
+ }
+ else if (strCommandName.Equals("LYRICFILE"))
+ {
+ if (!string.IsNullOrEmpty(strCommandParam))
+ {
+ string[] strFiles = SplitComma(strCommandParam);
+ string[] strFilePath = new string[strFiles.Length];
+ for (int index = 0; index < strFiles.Length; index++)
+ {
+ strFilePath[index] = this.str繝輔か繝ｫ繝蜷 + strFiles[index];
+ if (File.Exists(strFilePath[index]))
+ {
+ try
+ {
+ if (TJAPlayer3.r迴ｾ蝨ｨ縺ｮ繧ｹ繝繝ｼ繧ｸ.e繧ｹ繝繝ｼ繧ｸID == CStage.E繧ｹ繝繝ｼ繧ｸ.譖ｲ隱ｭ縺ｿ霎ｼ縺ｿ)//襍ｷ蜍墓凾縺ｫ驥阪◆縺上↑縺｣縺ｦ縺励∪縺蝠城｡後ｮ菫ｮ豁｣逕ｨ
+ this.LyricFileParser(strFilePath[index], index);
+ this.bLyrics = true;
+ }
+ catch
+ {
+ Console.WriteLine("lrc繝輔ぃ繧､繝ｫNo.{0}縺ｮ隱ｭ縺ｿ霎ｼ縺ｿ縺ｫ螟ｱ謨励＠縺ｾ縺励◆縺後", index);
+ Console.WriteLine("蜃ｦ逅繧堤ｶ夊｡後＠縺ｾ縺吶");
+ }
+ }
+ }
+ }
+ }
+ if (this.nScoreModeTmp == 99)
+ {
+ //2017.01.28 DD
+ this.nScoreModeTmp = TJAPlayer3.ConfigIni.nScoreMode;
+ }
+ }
+ ///
+ /// 謖螳壹＠縺滓枚蟄励′謨ｰ蛟､縺九ｒ霑斐☆繝｡繧ｽ繝繝
+ ///
+ ///
+ ///
+ public bool bIsNumber(char Char)
+ {
+ if ((Char >= '0') && (Char <= '9'))
+ return true;
+ else
+ return false;
+ }
+
+ ///
+ /// string蝙九°繧永nt蝙九↓螟画鋤縺吶ｋ縲
+ /// TJAP2縺九ｉ謖√▲縺ｦ縺阪◆縲
+ ///
+ private int CharConvertNote(string str)
+ {
+ switch (str)
+ {
+ case "0":
+ return 0;
+ case "1":
+ return 1;
+ case "2":
+ return 2;
+ case "3":
+ return 3;
+ case "4":
+ return 4;
+ case "5":
+ return 5;
+ case "6":
+ return 6;
+ case "7":
+ return 7;
+ case "8":
+ return 8;
+ case "9":
+ return 7; //2017.01.30 DD 闃矩｣謇薙ｒ鬚ｨ闊ｹ騾｣謇捺桶縺縺ｫ
+ case "A": //2017.08.22 kairera0467 謇九▽縺ｪ縺
+ return 10;
+ case "B":
+ return 11;
+ case "F":
+ return 15;
+ default:
+ return -1;
+ }
+ }
+
+ private int strConvertCourse(string str)
+ {
+ //2016.08.24 kairera0467
+ //豁｣隕剰｡ｨ迴ｾ繧剃ｽｿ縺｣縺ｦ縺繧九◆繧√‘asy縺ｧ繧EASY縺ｧ繧０K縲
+
+ // 蟆乗枚蟄怜､ｧ譁蟄怜玄蛻･縺励↑縺豁｣隕剰｡ｨ迴ｾ縺ｧ莉ｮ蟇ｾ蠢懊 (AioiLight)
+ // 逶ｸ螟峨ｏ繧峨★蜴溷ｧ狗噪縺ｪ繧繧頑婿縺縺後∵ｭ｣蟶ｸ縺ｫ蜍穂ｽ懊＠縺溘
+ string[] Matchptn = new string[7] { "easy", "normal", "hard", "oni", "edit", "tower", "dan" };
+ for (int i = 0; i < Matchptn.Length; i++)
+ {
+ if (Regex.IsMatch(str, Matchptn[i], RegexOptions.IgnoreCase))
+ {
+ return i;
+ }
+ }
+
+ switch (str)
+ {
+ case "0":
+ return 0;
+ case "1":
+ return 1;
+ case "2":
+ return 2;
+ case "3":
+ return 3;
+ case "4":
+ return 4;
+ case "5":
+ return 5;
+ case "6":
+ return 6;
+ default:
+ return 3;
+ }
+ }
+
+ ///
+ /// Lyric繝輔ぃ繧､繝ｫ縺ｮ繝代ｼ繧ｹ繧ゅ←縺
+ /// 閾ｪ蜉帙〒菴懊▲縺溘ｮ縺ｧ縲√≧縺ｾ縺上ヱ繝ｼ繧ｹ縺励※縺上ｌ縺ｪ縺縺九ｂ
+ ///
+ /// lrc繝輔ぃ繧､繝ｫ縺ｮ繝代せ
+ private void LyricFileParser(string strFilePath, int ordnumber)//lrc繝輔ぃ繧､繝ｫ縺ｮ繝代ｼ繧ｹ逕ｨ
+ {
+ string str = CJudgeTextEncoding.ReadTextFile(strFilePath);
+ var strSplit蠕 = str.Split(this.dlmtEnter, StringSplitOptions.RemoveEmptyEntries);
+ Regex timeRegex = new Regex(@"^(\[)(\d{2})(:)(\d{2})([:.])(\d{2})(\])", RegexOptions.Multiline | RegexOptions.Compiled);
+ Regex timeRegexO = new Regex(@"^(\[)(\d{2})(:)(\d{2})(\])", RegexOptions.Multiline | RegexOptions.Compiled);
+ List list;
+ for (int i = 0; i < strSplit蠕.Length; i++)
+ {
+ list = new List();
+ if (!String.IsNullOrEmpty(strSplit蠕啓i]))
+ {
+ if (strSplit蠕啓i].StartsWith("["))
+ {
+ Match timestring = timeRegex.Match(strSplit蠕啓i]), timestringO = timeRegexO.Match(strSplit蠕啓i]);
+ while (timestringO.Success || timestring.Success)
+ {
+ long time;
+ if (timestring.Success)
+ {
+ time = Int32.Parse(timestring.Groups[2].Value) * 60000 + Int32.Parse(timestring.Groups[4].Value) * 1000 + Int32.Parse(timestring.Groups[6].Value) * 10;
+ strSplit蠕啓i] = strSplit蠕啓i].Remove(0, 10);
+ }
+ else if (timestringO.Success)
+ {
+ time = Int32.Parse(timestringO.Groups[2].Value) * 60000 + Int32.Parse(timestringO.Groups[4].Value) * 1000;
+ strSplit蠕啓i] = strSplit蠕啓i].Remove(0, 7);
+ }
+ else
+ break;
+ list.Add(time);
+ timestring = timeRegex.Match(strSplit蠕啓i]);
+ timestringO = timeRegexO.Match(strSplit蠕啓i]);
+ }
+ strSplit蠕啓i] = strSplit蠕啓i].Replace("\r", "").Replace("\n", "");
+
+ for (int listindex = 0; listindex < list.Count; listindex++)
+ {
+ STLYRIC stlrc;
+ stlrc.Text = strSplit蠕啓i];
+ stlrc.TextTex = this.pf豁瑚ｩ槭ヵ繧ｩ繝ｳ繝.DrawPrivateFont(strSplit蠕啓i], TJAPlayer3.Skin.Game_Lyric_ForeColor, TJAPlayer3.Skin.Game_Lyric_BackColor);
+ stlrc.Time = list[listindex];
+ stlrc.index = ordnumber;
+ this.listLyric2.Add(stlrc);
+ }
+ }
+ }
+ }
+ }
+
+
+ ///
+ /// 隍邏謨ｰ縺ｮ繝代ｼ繧ｹ繧ゅ←縺
+ ///
+ private void tParsedComplexNumber(string strScroll, ref double[] dbScroll)
+ {
+ bool bFirst = true; //譛蛻昴ｮ謨ｰ蛟､縺
+ bool bUse = false; //謨ｰ蛟､謇ｱ縺荳ｭ
+ string[] arScroll = new string[2];
+ char[] c = strScroll.ToCharArray();
+ //1.0-1.0i
+ for (int i = 0; i < strScroll.Length; i++)
+ {
+ if (bFirst)
+ arScroll[0] += c[i];
+ else
+ arScroll[1] += c[i];
+
+ //谺｡縺ｮ譁蟄励′'i'縺ｪ繧芽┳蜃ｺ縲
+ if (c[i + 1] == 'i')
+ break;
+ else if (c[i + 1] == '-' || c[i + 1] == '+')
+ bFirst = false;
+
+ }
+
+ dbScroll[0] = Convert.ToDouble(arScroll[0]);
+ dbScroll[1] = Convert.ToDouble(arScroll[1]);
+ return;
+ }
+
+ private void tSetSenotes()
+ {
+ #region[ list菴懈 ]
+ //縺ｲ縺ｨ縺ｾ縺壹メ繝繝励□縺代ｮ繝ｪ繧ｹ繝医ｒ菴懈舌＠縺ｦ縺翫￥縲
+ List list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝;
+ list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝 = new List();
+ int nCount = 0;
+ int dkdkCount = 0;
+
+ foreach (CChip chip in this.listChip)
+ {
+ if (chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ >= 0x11 && chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ < 0x18)
+ {
+ list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝.Add(chip);
+ }
+ }
+ #endregion
+
+ //譎る俣蛻､螳壹ｯ縲√梧ｬ｡縺ｮ繝√ャ繝励ｮ逋ｺ螢ｰ譎ょ綾縲阪°繧峨檎樟蝨ｨ(驕主悉)縺ｮ繝√ャ繝励ｮ逋ｺ螢ｰ譎ょ綾縲阪〒蠑輔￥蠢隕√′縺ゅｋ縲
+ //騾縺ｫ縺励※縺励∪縺縺ｨ險育ｮ励′縺ｨ縺ｦ縺､繧ゅ↑縺縺薙→縺ｫ縺ｪ繧九ｮ縺ｧ豕ｨ諢上
+
+ try
+ {
+ //this.tSenotes_Core( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝 );
+ this.tSenotes_Core_V2(list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝, true);
+ }
+ catch (Exception ex)
+ {
+ Trace.TraceError(ex.ToString());
+ Trace.TraceError("萓句､悶′逋ｺ逕溘＠縺ｾ縺励◆縺悟ｦ逅繧堤ｶ咏ｶ壹＠縺ｾ縺吶 (b67473e4-1930-44f1-b320-4ead5786e74c)");
+ }
+
+
+ #region[邨ｱ蜷亥燕]
+ //foreach( CChip pChip in list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝 )
+ //{
+ // int dbUnitTime = ( int )( ( ( 60.0 / this.dbNowBPM ) / 4.0 ) * 1000.0 );
+ // int nUnit4 = dbUnitTime * 4;
+ // int nUnit8 = dbUnitTime * 2;
+ // int nUnit16 = dbUnitTime;
+
+ // if( nCount == 0 )
+ // {
+ // nCount++;
+ // continue;
+ // }
+
+ // double db1蛟句燕縺ｮ逋ｺ逕滓凾蛻ｻms = list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[nCount - 1].n逋ｺ螢ｰ譎ょ綾ms * 1;
+
+ // if( nCount == 1 )
+ // {
+ // //nCount - 1縺ｯ荳逡ｪ譛蛻昴ｮ繝弱ｼ繝縺ｫ縺ｪ繧九
+
+ // if( pChip.n逋ｺ螢ｰ譎ょ綾ms - list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 1 ].n逋ｺ螢ｰ譎ょ綾ms >= nUnit4 )
+ // {
+ // if( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 1 ].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93 )
+ // list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 1 ].nSenote = 0;
+ // else if( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 1 ].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94 )
+ // list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 1 ].nSenote = 3;
+
+ // if( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount + 1 ].n逋ｺ螢ｰ譎ょ綾ms - pChip.n逋ｺ螢ｰ譎ょ綾ms < nUnit4 )
+ // {
+ // if( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount + 1 ].n逋ｺ螢ｰ譎ょ綾ms - pChip.n逋ｺ螢ｰ譎ょ綾ms < nUnit8 )
+ // {
+ // //16蛻縺ｪ繧峨後ラ縲
+ // pChip.nSenote = 1;
+ // }
+ // else
+ // {
+ // if( dkdkCount == 0 )
+ // {
+ // pChip.nSenote = 1;
+ // dkdkCount++;
+ // }
+ // else if( dkdkCount == 1 )
+ // {
+ // pChip.nSenote = 2;
+ // dkdkCount = 0;
+ // }
+
+ // }
+ // }
+ // else
+ // {
+ // //谺｡繧4蛻縺ｪ繧峨後ラ繝ｳ縲阪°縲後き繝縲
+ // if( pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93 )
+ // {
+ // pChip.nSenote = 0;
+ // }
+ // else if( pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94 )
+ // {
+ // pChip.nSenote = 3;
+ // }
+ // }
+ // }
+ // else if( pChip.n逋ｺ螢ｰ譎ょ綾ms - list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 1 ].n逋ｺ螢ｰ譎ょ綾ms <= nUnit4 && pChip.n逋ｺ螢ｰ譎ょ綾ms - list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 1 ].n逋ｺ螢ｰ譎ょ綾ms >= nUnit8 )
+ // {
+ // if( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 1 ].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93 )
+ // list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 1 ].nSenote = 1;
+ // else if( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 1 ].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94 )
+ // list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 1 ].nSenote = 4;
+
+ // if( pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93 )
+ // {
+ // pChip.nSenote = 1;
+ // }
+ // else if( pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94 )
+ // {
+ // pChip.nSenote = 4;
+ // }
+ // }
+ // else if( pChip.n逋ｺ螢ｰ譎ょ綾ms - list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 1 ].n逋ｺ螢ｰ譎ょ綾ms < nUnit8 )
+ // {
+ // if( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 1 ].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93 )
+ // list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 1 ].nSenote = 1;
+ // else if( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 1 ].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94 )
+ // list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 1 ].nSenote = 4;
+
+ // if( pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93 )
+ // {
+ // pChip.nSenote = 1;
+ // }
+ // else if( pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94 )
+ // {
+ // pChip.nSenote = 4;
+ // }
+ // }
+
+ // nCount++;
+ // continue;
+ // }
+
+ // double db2蛟句燕縺ｮ逋ｺ螢ｰ譎ょ綾ms = list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 2 ].n逋ｺ螢ｰ譎ょ綾ms * 1;
+
+ // #region[譁ｰ縺励＞繧縺､]
+ // if( nCount + 1 >= list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝.Count )
+ // break;
+
+ // if( pChip.n逋ｺ螢ｰ譎ょ綾ms - list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 1 ].n逋ｺ螢ｰ譎ょ綾ms >= nUnit4 )
+ // {
+ // if( pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93 )
+ // {
+ // pChip.nSenote = 0;
+ // }
+ // else if( pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94 )
+ // {
+ // pChip.nSenote = 3;
+ // }
+
+ // if( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount + 1 ].n逋ｺ螢ｰ譎ょ綾ms - pChip.n逋ｺ螢ｰ譎ょ綾ms <= nUnit4 )
+ // {
+ // if( pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93 )
+ // pChip.nSenote = 1;
+ // else if( pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94 )
+ // pChip.nSenote = 4;
+ // }
+ // }
+ // else if( pChip.n逋ｺ螢ｰ譎ょ綾ms - list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 1 ].n逋ｺ螢ｰ譎ょ綾ms < nUnit4 && pChip.n逋ｺ螢ｰ譎ょ綾ms - list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 1 ].n逋ｺ螢ｰ譎ょ綾ms >= nUnit8 )
+ // {
+ // if( pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93 )
+ // {
+ // pChip.nSenote = 1;
+ // }
+ // else if( pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94 )
+ // {
+ // pChip.nSenote = 4;
+ // }
+
+ // if( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount + 1 ].n逋ｺ螢ｰ譎ょ綾ms - pChip.n逋ｺ螢ｰ譎ょ綾ms <= nUnit4 )
+ // {
+ // if( pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93 )
+ // pChip.nSenote = 0;
+ // else if( pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94 )
+ // pChip.nSenote = 3;
+
+ // if( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount + 2 ].n逋ｺ螢ｰ譎ょ綾ms - list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount + 1 ].n逋ｺ螢ｰ譎ょ綾ms >= nUnit8 )
+ // {
+ // if( pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93 )
+ // pChip.nSenote = 1;
+ // else if( pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94 )
+ // pChip.nSenote = 4;
+ // }
+ // else if( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount + 2 ].n逋ｺ螢ｰ譎ょ綾ms - list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount + 1 ].n逋ｺ螢ｰ譎ょ綾ms < nUnit8 )
+ // {
+ // if( pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93 )
+ // pChip.nSenote = 1;
+ // else if( pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94 )
+ // pChip.nSenote = 4;
+ // }
+
+ // }
+ // else
+ // {
+ // if( pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93 )
+ // pChip.nSenote = 0;
+ // else if( pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94 )
+ // pChip.nSenote = 3;
+ // }
+ // }
+ // else if( pChip.n逋ｺ螢ｰ譎ょ綾ms - list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 1 ].n逋ｺ螢ｰ譎ょ綾ms < nUnit8 ) //8蛻莉･荳
+ // {
+ // if( pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93 )
+ // {
+ // pChip.nSenote = 1;
+ // }
+ // else if( pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94 )
+ // {
+ // pChip.nSenote = 4;
+ // }
+
+ // //蠕後ｍ縺4蛻
+ // try
+ // {
+ // if( nCount + 1 >= list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝.Count )
+ // break;
+
+ // if( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount + 1 ].n逋ｺ螢ｰ譎ょ綾ms - pChip.n逋ｺ螢ｰ譎ょ綾ms >= nUnit8 ) //蛻蟯舌′縺ゅｋ縺ｨ縺薙％縺後ヰ繧ｰ繧九▲縺ｽ縺?(Index繧ｨ繝ｩ繝ｼ)
+ // {
+ // if( pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93 )
+ // {
+ // pChip.nSenote = 0;
+ // }
+ // else if( pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94 )
+ // {
+ // pChip.nSenote = 3;
+ // }
+ // }
+ // }
+ // catch( Exception ex )
+ // {
+
+ // }
+
+
+ // }
+ // #endregion
+
+ // #region[蜿､縺繧縺､]
+ // ////2縺､蜑阪→1縺､蜑阪ｮ繝√ャ繝励ｮSenote繧呈ｱｺ繧√※縺縺上
+ // ////騾｣謇薙∝､ｧ髻ｳ隨ｦ縺ｪ縺ｩ縺ｯ繝√ャ繝鈴咲ｽｮ縺ｮ髫帙↓豎ｺ繧√∪縺吶
+ // //if (( db1蛟句燕縺ｮ逋ｺ逕滓凾蛻ｻms - db2蛟句燕縺ｮ逋ｺ螢ｰ譎ょ綾ms ) >= nUnit4)
+ // //{
+ // // //2縺､蜑阪ｮ髻ｳ隨ｦ縺ｨ1縺､蜑阪ｮ髻ｳ隨ｦ縺ｮ髢薙′4蛻莉･荳翫〒縺九▽縲√◎縺ｮ髻ｳ隨ｦ縺後ラ繝ｳ縺ｪ繧2縺､蜑阪ｮSenote縺ｯ縲後ラ繝ｳ縲阪〒遒ｺ螳壹
+ // // //蜷梧凾縺ｫdkdk繧偵Μ繧ｻ繝繝
+ // // dkdkCount = false;
+ // // if( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[nCount - 2].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93 )
+ // // list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[nCount - 2].nSenote = 0;
+ // // else if( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[nCount - 2].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94 )
+ // // list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[nCount - 2].nSenote = 3;
+
+ // // if( ( pChip.n逋ｺ螢ｰ譎ょ綾ms - db1蛟句燕縺ｮ逋ｺ逕滓凾蛻ｻms ) >= nUnit4 )
+ // // {
+ // // //1縺､蜑阪ｮ髻ｳ隨ｦ縺ｨ迴ｾ蝨ｨ縺ｮ髻ｳ隨ｦ縺ｮ髢薙′4蛻莉･荳翫°縺､縲√◎縺ｮ髻ｳ隨ｦ縺後ラ繝ｳ縺ｪ繧1縺､蜑阪ｮ髻ｳ隨ｦ縺ｯ縲後ラ繝ｳ縲阪〒遒ｺ螳壹
+ // // if( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[nCount - 1].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93 )
+ // // list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[nCount - 1].nSenote = 0;
+ // // else if( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[nCount - 1].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94 )
+ // // list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[nCount - 1].nSenote = 3;
+ // // }
+ // // else if( ( pChip.n逋ｺ螢ｰ譎ょ綾ms - db1蛟句燕縺ｮ逋ｺ逕滓凾蛻ｻms ) <= nUnit4 )
+ // // {
+ // // //4蛻
+ // // if( ( pChip.n逋ｺ螢ｰ譎ょ綾ms - db1蛟句燕縺ｮ逋ｺ逕滓凾蛻ｻms ) >= nUnit8 )
+ // // {
+ // // dkdkCount = false;
+ // // //1縺､蜑阪ｮ髻ｳ隨ｦ縺ｨ迴ｾ蝨ｨ縺ｮ髻ｳ隨ｦ縺ｮ髢薙′8蛻莉･蜀縺ｧ16蛻莉･荳翫〒縺九▽縲√◎縺ｮ髻ｳ隨ｦ縺瑚ｵ､縺ｪ繧1縺､蜑阪ｮ髻ｳ隨ｦ縺ｯ縲後ラ縲阪〒遒ｺ螳壹
+ // // if( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 1 ].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94 )
+ // // list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 1 ].nSenote = 2;
+ // // else if( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 1 ].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94 )
+ // // list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 1 ].nSenote = 4;
+ // // }
+ // // else if( ( db1蛟句燕縺ｮ逋ｺ逕滓凾蛻ｻms - db2蛟句燕縺ｮ逋ｺ螢ｰ譎ょ綾ms ) <= nUnit8 )
+ // // {
+ // // dkdkCount = false;
+ // // if( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 2 ].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93 )
+ // // {
+ // // list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 2 ].nSenote = 1;
+
+ // // //繝峨さ繝峨Φ
+ // // if( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 1 ].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93 )
+ // // {
+ // // if( pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93 )
+ // // pChip.nSenote = dkdkCount ? 2 : 1;
+ // // if( dkdkCount == false )
+ // // dkdkCount = true;
+ // // else
+ // // dkdkCount = false;
+ // // }
+ // // }
+ // // else if( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 2 ].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94 )
+ // // list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 2 ].nSenote = 4;
+ // // }
+
+ // // }
+ // //}
+ // //else if ( ( db1蛟句燕縺ｮ逋ｺ逕滓凾蛻ｻms - db2蛟句燕縺ｮ逋ｺ螢ｰ譎ょ綾ms ) <= nUnit4 && ( db1蛟句燕縺ｮ逋ｺ逕滓凾蛻ｻms - db2蛟句燕縺ｮ逋ｺ螢ｰ譎ょ綾ms ) >= nUnit8)
+ // //{
+ // // //2縺､蜑阪ｮ髻ｳ隨ｦ縺ｨ1縺､蜑阪ｮ髻ｳ隨ｦ縺ｮ髢薙′8蛻莉･荳翫〒縺九▽縲16蛻莉･蜀
+
+ // // if( ( db1蛟句燕縺ｮ逋ｺ逕滓凾蛻ｻms - db2蛟句燕縺ｮ逋ｺ螢ｰ譎ょ綾ms ) >= nUnit8 && ( db1蛟句燕縺ｮ逋ｺ逕滓凾蛻ｻms - db2蛟句燕縺ｮ逋ｺ螢ｰ譎ょ綾ms ) > nUnit16 )
+ // // {
+ // // //2縺､蜑阪ｮ髻ｳ隨ｦ縺ｨ1縺､蜑阪ｮ髻ｳ隨ｦ縺ｮ髢薙′8蛻莉･荳翫〒縺九▽縲16蛻莉･蜀縺ｪ繧峨後ラ縲
+ // // if( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 2 ].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93 )
+ // // {
+ // // list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 2 ].nSenote = 1;
+ // // }
+ // // else if( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 2 ].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94 )
+ // // {
+ // // list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 2 ].nSenote = 4;
+ // // }
+ // // }
+ // // else if( ( db1蛟句燕縺ｮ逋ｺ逕滓凾蛻ｻms - db2蛟句燕縺ｮ逋ｺ螢ｰ譎ょ綾ms ) < nUnit8 )
+ // // {
+ // // //2縺､蜑阪ｮ髻ｳ隨ｦ縺ｨ1縺､蜑阪ｮ髻ｳ隨ｦ縺ｮ髢薙′16蛻莉･蜀縺ｪ繧峨後ラ縲阪〒遒ｺ螳
+ // // if( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 2 ].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93 )
+ // // {
+ // // list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 2 ].nSenote = 1;
+ // // }
+ // // else if( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 2 ].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94 )
+ // // list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 2 ].nSenote = 4;
+ // // }
+
+ // // if( ( pChip.n逋ｺ螢ｰ譎ょ綾ms - db1蛟句燕縺ｮ逋ｺ逕滓凾蛻ｻms ) >= nUnit16 )
+ // // {
+ // // if( ( pChip.n逋ｺ螢ｰ譎ょ綾ms - db1蛟句燕縺ｮ逋ｺ逕滓凾蛻ｻms ) >= nUnit8 )
+ // // {
+ // // if( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 2 ].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93 )
+ // // {
+ // // list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 1 ].nSenote = 0;
+ // // }
+ // // else if( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 2 ].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94 )
+ // // list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 1 ].nSenote = 3;
+ // // }
+ // // }
+ // //}
+ // //else if ( ( db1蛟句燕縺ｮ逋ｺ逕滓凾蛻ｻms - db2蛟句燕縺ｮ逋ｺ螢ｰ譎ょ綾ms ) >= nUnit16 && ( db1蛟句燕縺ｮ逋ｺ逕滓凾蛻ｻms - db2蛟句燕縺ｮ逋ｺ螢ｰ譎ょ綾ms ) <= nUnit8 )
+ // //{
+ // // //2縺､蜑阪ｮ髻ｳ隨ｦ縺ｨ1縺､蜑阪ｮ髻ｳ隨ｦ縺ｮ髢薙′16蛻莉･荳
+ // // if( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 2 ].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93 )
+ // // {
+ // // list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 2 ].nSenote = 1;
+ // // }
+ // // else if( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 2 ].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94 )
+ // // list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 2 ].nSenote = 4;
+
+ // // if( ( pChip.n逋ｺ螢ｰ譎ょ綾ms - db1蛟句燕縺ｮ逋ｺ逕滓凾蛻ｻms ) >= nUnit8 )
+ // // {
+ // // if( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 2 ].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93 )
+ // // {
+ // // list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 1 ].nSenote = 0;
+ // // }
+ // // else if( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 2 ].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94 )
+ // // list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 1 ].nSenote = 3;
+ // // }
+
+
+ // //}
+ // #endregion
+
+ // nCount++;
+ //}
+ #endregion
+
+
+ }
+
+ ///
+ /// 隴憺擇蛻蟯舌′縺ゅｋ蝣ｴ蜷医ｯ縺薙■繧峨ｒ菴ｿ縺
+ ///
+ private void tSetSenotes_branch()
+ {
+ #region[ list菴懈 ]
+ //縺ｲ縺ｨ縺ｾ縺壹メ繝繝励□縺代ｮ繝ｪ繧ｹ繝医ｒ菴懈舌＠縺ｦ縺翫￥縲
+ List list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝;
+ List list譎ｮ騾夊ｭ憺擇縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝;
+ List list邇莠ｺ隴憺擇縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝;
+ List list驕比ｺｺ隴憺擇縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝;
+ list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝 = new List();
+ list譎ｮ騾夊ｭ憺擇縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝 = new List();
+ list邇莠ｺ隴憺擇縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝 = new List();
+ list驕比ｺｺ隴憺擇縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝 = new List();
+ int nCount = 0;
+ int dkdkCount = 0;
+
+ foreach (CChip chip in this.listChip)
+ {
+ if (chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ >= 0x11 && chip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ < 0x18)
+ {
+ list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝.Add(chip);
+
+ switch (chip.n繧ｳ繝ｼ繧ｹ)
+ {
+ case ECourse.eNormal:
+ list譎ｮ騾夊ｭ憺擇縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝.Add(chip);
+ break;
+ case ECourse.eExpert:
+ list邇莠ｺ隴憺擇縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝.Add(chip);
+ break;
+ case ECourse.eMaster:
+ list驕比ｺｺ隴憺擇縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝.Add(chip);
+ break;
+ }
+ }
+ }
+ #endregion
+
+ //for縺ｧ蜃ｦ逅縲
+ for (int n = 0; n < 3; n++)
+ {
+ switch (n)
+ {
+ case 0:
+ list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝 = list譎ｮ騾夊ｭ憺擇縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝;
+ break;
+ case 1:
+ list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝 = list邇莠ｺ隴憺擇縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝;
+ break;
+ case 2:
+ list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝 = list驕比ｺｺ隴憺擇縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝;
+ break;
+ }
+
+ //this.tSenotes_Core( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝 );
+ this.tSenotes_Core_V2(list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝, true);
+ }
+
+ }
+
+ ///
+ /// 繧ｳ繧｢驛ｨ蛻縲りｭ憺擇蛻蟯先凾縺ｮ蜃ｦ逅螳溯｣縺ｫ縺ゅ◆縺｣縺ｦ蛻髮｢縲
+ ///
+ private void tSenotes_Core(List list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝)
+ {
+ int nCount = 0;
+ int dkdkCount = 0;
+
+ foreach (CChip pChip in list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝)
+ {
+ int dbUnitTime = (int)(((60.0 / pChip.dbBPM) / 4.0) * 1000.0);
+ int nUnit4 = dbUnitTime * 4;
+ int nUnit6 = dbUnitTime * 3;
+ int nUnit8 = dbUnitTime * 2;
+ int nUnit16 = dbUnitTime;
+
+ float fUnitTime = (((60.0f / (float)pChip.dbBPM) / 4.0f) * 1000.0f);
+ //float fUnitTime = (float)Math.Round( ( ( ( 60.0f / (float)pChip.dbBPM ) / 4.0f ) * 1000.0f ), 0 );
+ float fUnit4 = fUnitTime * 4.0f;
+ float fUnit8 = fUnitTime * 2.0f;
+ float fUnit16 = fUnitTime;
+
+ if (pChip.dbBPM < 120)
+ {
+ nUnit4 = (dbUnitTime * 4) / 2;
+ nUnit8 = (dbUnitTime * 2) / 2;
+ nUnit16 = dbUnitTime / 2;
+
+ fUnit4 = fUnitTime * 4.0f;
+ fUnit8 = fUnitTime * 2.0f;
+ fUnit16 = fUnitTime;
+ }
+
+ if (nCount == 0)
+ {
+ nCount++;
+ continue;
+ }
+
+ double db1蛟句燕縺ｮ逋ｺ逕滓凾蛻ｻms = list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[nCount - 1].n逋ｺ螢ｰ譎ょ綾ms * 1;
+
+ #region[ float ]
+ /*
+ if( nCount == 1 )
+ {
+ //nCount - 1縺ｯ荳逡ｪ譛蛻昴ｮ繝弱ｼ繝縺ｫ縺ｪ繧九
+
+ if( pChip.f逋ｺ螢ｰ譎ょ綾ms - list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 1 ].f逋ｺ螢ｰ譎ょ綾ms >= fUnit4 )
+ {
+ //2逡ｪ逶ｮ縺ｮ繝弱ｼ繝縺ｨ1逡ｪ逶ｮ縺ｮ繝弱ｼ繝縺ｮ髢馴囈縺4蛻縺九◎繧御ｻ･荳
+ if( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 1 ].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93 )
+ list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 1 ].nSenote = 0;
+ else if( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 1 ].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94 )
+ list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 1 ].nSenote = 3;
+
+ if( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount + 1 ].f逋ｺ螢ｰ譎ょ綾ms - pChip.f逋ｺ螢ｰ譎ょ綾ms < fUnit4 )
+ {
+ if( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount + 1 ].f逋ｺ螢ｰ譎ょ綾ms - pChip.f逋ｺ螢ｰ譎ょ綾ms < fUnit8 )
+ {
+ //16蛻縺ｪ繧峨後ラ縲
+ if( pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93 )
+ pChip.nSenote = 1;
+ }
+ else
+ {
+ if (pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ != 0x93)
+ break;
+
+ if( dkdkCount == 0 )
+ {
+ pChip.nSenote = 1;
+ dkdkCount++;
+ }
+ else if( dkdkCount == 1 )
+ {
+ pChip.nSenote = 2;
+ dkdkCount = 0;
+ }
+
+ }
+ }
+ else
+ {
+ //谺｡繧4蛻縺ｪ繧峨後ラ繝ｳ縲阪°縲後き繝縲
+ if( pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93 )
+ {
+ pChip.nSenote = 0;
+ }
+ else if( pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94 )
+ {
+ pChip.nSenote = 3;
+ }
+ }
+ }
+ else if( pChip.f逋ｺ螢ｰ譎ょ綾ms - list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 1 ].f逋ｺ螢ｰ譎ょ綾ms < fUnit4 && pChip.f逋ｺ螢ｰ譎ょ綾ms - list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 1 ].f逋ｺ螢ｰ譎ょ綾ms > fUnit16 )
+ {
+ //2逡ｪ逶ｮ縺ｮ繝√ャ繝励→1逡ｪ逶ｮ縺ｮ繝√ャ繝励ｮ髢馴囈縺4蛻莉･荳九〒縺九▽16蛻莉･荳
+ if( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 1 ].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93 )
+ list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 1 ].nSenote = 1;
+ else if( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 1 ].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94 )
+ list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 1 ].nSenote = 4;
+
+
+
+ if( pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93 )
+ {
+ pChip.nSenote = 1;
+ }
+ else if( pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94 )
+ {
+ pChip.nSenote = 4;
+ }
+ //
+ //if (list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[nCount - 1].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93)
+ // list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[nCount - 1].nSenote = 0;
+ //else if (list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[nCount - 1].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94)
+ // list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[nCount - 1].nSenote = 3;
+
+ if (list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount + 1 ].f逋ｺ螢ｰ譎ょ綾ms - pChip.f逋ｺ螢ｰ譎ょ綾ms >= fUnit4)
+ {
+ //3逡ｪ逶ｮ縺ｮ繝√ャ繝励→2逡ｪ逶ｮ縺ｮ繝√ャ繝励ｮ髢馴囈縺4蛻莉･荳
+ if( pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93 )
+ {
+ pChip.nSenote = 0;
+ }
+ else if( pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94 )
+ {
+ pChip.nSenote = 3;
+ }
+ }
+ }
+ else if( pChip.f逋ｺ螢ｰ譎ょ綾ms - list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 1 ].f逋ｺ螢ｰ譎ょ綾ms <= fUnit16 )
+ {
+ //2逡ｪ逶ｮ縺ｮ繝√ャ繝励→1逡ｪ逶ｮ縺ｮ繝√ャ繝励ｮ髢馴囈縺16蛻縺九◎繧御ｻ･荳
+ if( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 1 ].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93 )
+ list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 1 ].nSenote = 1;
+ else if( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 1 ].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94 )
+ list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 1 ].nSenote = 4;
+
+ if (pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93)
+ {
+ pChip.nSenote = 1;
+ }
+ else if (pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94)
+ {
+ pChip.nSenote = 4;
+ }
+
+ //1逡ｪ逶ｮ縺ｮ繝√ャ繝励′0x93
+ if( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 1 ].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93 )
+ {
+ //3逡ｪ逶ｮ縺ｮ繝√ャ繝励→2逡ｪ逶ｮ縺ｮ繝√ャ繝励ｮ髢馴囈縺16蛻
+ if( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount + 1 ].f逋ｺ螢ｰ譎ょ綾ms - pChip.f逋ｺ螢ｰ譎ょ綾ms == fUnit16 )
+ {
+ if( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount + 1 ].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93 )
+ {
+ pChip.nSenote = 2;
+ }
+ }
+ }
+
+
+ }
+
+ nCount++;
+ continue;
+ }
+
+ double db2蛟句燕縺ｮ逋ｺ螢ｰ譎ょ綾ms = list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 2 ].n逋ｺ螢ｰ譎ょ綾ms * 1;
+
+ #region[譁ｰ縺励＞繧縺､]
+ if( pChip.f逋ｺ螢ｰ譎ょ綾ms - list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 1 ].f逋ｺ螢ｰ譎ょ綾ms >= fUnit4 )
+ {
+ //迴ｾ蝨ｨ縺ｮ繝√ャ繝励→1縺､蜑阪ｮ繝√ャ繝励ｮ髢馴囈縺4蛻莉･荳
+ dkdkCount = 0;
+ if( pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93 )
+ {
+ pChip.nSenote = 0;
+ //break;
+ }
+ else if( pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94 )
+ {
+ pChip.nSenote = 3;
+ }
+
+ if( nCount + 1 >= list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝.Count )
+ break;
+
+ //谺｡縺ｮ繝√ャ繝励→迴ｾ蝨ｨ縺ｮ繝√ャ繝励ｮ髢薙′4蛻莉･荳
+ if( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount + 1 ].f逋ｺ螢ｰ譎ょ綾ms - pChip.f逋ｺ螢ｰ譎ょ綾ms < fUnit4 )
+ {
+ if( pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93 )
+ pChip.nSenote = 1;
+ else if( pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94 )
+ pChip.nSenote = 4;
+ }
+ }
+ else if( pChip.f逋ｺ螢ｰ譎ょ綾ms - list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 1 ].f逋ｺ螢ｰ譎ょ綾ms < fUnit4 && pChip.f逋ｺ螢ｰ譎ょ綾ms - list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 1 ].f逋ｺ螢ｰ譎ょ綾ms > fUnit16 )
+ {
+ //迴ｾ蝨ｨ縺ｮ繝√ャ繝励→1縺､蜑阪ｮ繝√ャ繝励ｮ髢馴囈縺4蛻莉･荳九°縺､16蛻莉･荳
+ dkdkCount = 0;
+ if( pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93 )
+ {
+ pChip.nSenote = 1;
+ }
+ else if( pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94 )
+ {
+ pChip.nSenote = 4;
+ }
+
+ if( nCount + 1 >= list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝.Count )
+ break;
+
+
+ if( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount + 1 ].f逋ｺ螢ｰ譎ょ綾ms - pChip.f逋ｺ螢ｰ譎ょ綾ms >= fUnit4 )
+ {
+ //谺｡縺ｮ繝√ャ繝励→迴ｾ蝨ｨ縺ｮ繝√ャ繝励ｮ髢馴囈縺4蛻莉･荳
+ if( pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93 )
+ pChip.nSenote = 0;
+ else if( pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94 )
+ pChip.nSenote = 3;
+ }
+ else if( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount + 1 ].f逋ｺ螢ｰ譎ょ綾ms - pChip.f逋ｺ螢ｰ譎ょ綾ms < fUnit4 && list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount + 1 ].f逋ｺ螢ｰ譎ょ綾ms - pChip.f逋ｺ螢ｰ譎ょ綾ms > fUnit16 )
+ {
+ //谺｡縺ｮ繝√ャ繝励→迴ｾ蝨ｨ縺ｮ繝√ャ繝励ｮ髢馴囈縺4蛻莉･荳
+ if( pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93 )
+ pChip.nSenote = 1;
+ else if( pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94 )
+ pChip.nSenote = 4;
+
+ if( nCount + 2 >= list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝.Count )
+ break;
+
+ //谺｡縺ｮ繝√ャ繝励′0x93
+ //if( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount + 1 ].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93 )
+ //{
+ // if( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount + 2 ].n逋ｺ螢ｰ譎ょ綾ms - list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount + 1 ].n逋ｺ螢ｰ譎ょ綾ms < nUnit8 )
+ // {
+ // list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount + 1 ].nSenote = 2;
+ // }
+ //}
+ }
+ else if( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount + 1 ].f逋ｺ螢ｰ譎ょ綾ms - pChip.f逋ｺ螢ｰ譎ょ綾ms <= fUnit16 )
+ {
+ //谺｡縺ｮ繝√ャ繝励→迴ｾ蝨ｨ縺ｮ繝√ャ繝励ｮ髢馴囈縺16蛻莉･荳
+ //縺昴≧縺ｪ繧九→1縺､蜑阪ｮ繝√ャ繝励ｯ縲後ラ繝ｳ縲阪°縲後き繝縲阪↓縺ｪ繧
+ //if( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 1 ].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93 )
+ // list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 1 ].nSenote = 0;
+ //else if( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 1 ].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94 )
+ // list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 1 ].nSenote = 0;
+ }
+ }
+ else if( pChip.f逋ｺ螢ｰ譎ょ綾ms - list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 1 ].f逋ｺ螢ｰ譎ょ綾ms <= fUnit16 )
+ {
+ //迴ｾ蝨ｨ縺ｮ繝弱ｼ繝縺ｨ1縺､蜑阪ｮ繝弱ｼ繝縺ｮ髢馴囈縺16蛻縺九◎繧御ｻ･荳
+ if( pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93 )
+ {
+ pChip.nSenote = 1;
+ }
+ else if( pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94 )
+ {
+ pChip.nSenote = 4;
+ }
+
+
+ try
+ {
+ if( nCount + 1 >= list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝.Count ) //荳逡ｪ譛蠕後ｮ繝弱ｼ繝縺縺｣縺滓凾縺ｮ繧ｨ繝ｩ繝ｼ蟇ｾ遲悶
+ break;
+
+ //蠕後ｍ縺4蛻
+ if( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount + 1 ].f逋ｺ螢ｰ譎ょ綾ms - pChip.f逋ｺ螢ｰ譎ょ綾ms >= fUnit4 )
+ {
+ dkdkCount = 0;
+ if( pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93 )
+ {
+ pChip.nSenote = 0;
+ }
+ else if( pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94 )
+ {
+ pChip.nSenote = 3;
+ }
+ }
+ else if( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount + 1 ].f逋ｺ螢ｰ譎ょ綾ms - pChip.f逋ｺ螢ｰ譎ょ綾ms <= fUnit8 && list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount + 1 ].f逋ｺ螢ｰ譎ょ綾ms - pChip.f逋ｺ螢ｰ譎ょ綾ms > fUnit16 )
+ {
+ //谺｡縺ｮ繝弱ｼ繝縺ｨ迴ｾ蝨ｨ縺ｮ繝弱ｼ繝縺ｮ髢馴囈縺8蛻縺九◎繧御ｻ･荳九〒縺九▽16蛻莉･荳
+ dkdkCount = 0;
+ if( pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93 )
+ {
+ pChip.nSenote = 0;
+ }
+ else if( pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94 )
+ {
+ pChip.nSenote = 3;
+ }
+ }
+ else if( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount + 1 ].f逋ｺ螢ｰ譎ょ綾ms - pChip.f逋ｺ螢ｰ譎ょ綾ms <= fUnit16 )
+ {
+ if( pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93 )
+ {
+ pChip.nSenote = 1;
+
+ if( nCount + 2 >= list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝.Count )
+ break;
+
+ if( pChip.f逋ｺ螢ｰ譎ょ綾ms - list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 1 ].f逋ｺ螢ｰ譎ょ綾ms == fUnit16 )
+ {
+ //1縺､蜑阪ｮ繝弱ｼ繝縺ｨ迴ｾ蝨ｨ縺ｮ繝弱ｼ繝縺ｮ髢馴囈縺16蛻
+ if( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 1 ].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93 )
+ {
+ //繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ縺0x93
+ if( dkdkCount == 0 )
+ {
+ pChip.nSenote = 2;
+ dkdkCount = 1;
+ }
+ else
+ {
+ pChip.nSenote = 1;
+ dkdkCount = 0;
+ }
+ }
+
+ }
+ else
+ {
+ if (pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93)
+ pChip.nSenote = 1;
+ else
+ pChip.nSenote = 4;
+ }
+ }
+ else if( pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94 )
+ {
+ pChip.nSenote = 4;
+ }
+ }
+ }
+ catch( Exception ex )
+ {
+
+ }
+
+
+ }
+ #endregion
+ */
+ #endregion
+
+ #region[ 繝溘Μ遘 ]
+
+ if (nCount == 1)
+ {
+ #region[ 荳逡ｪ譛蛻 ]
+ //nCount - 1縺ｯ荳逡ｪ譛蛻昴ｮ繝弱ｼ繝縺ｫ縺ｪ繧九
+
+ if (pChip.n逋ｺ螢ｰ譎ょ綾ms - list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[0].n逋ｺ螢ｰ譎ょ綾ms >= nUnit4)
+ {
+ //2逡ｪ逶ｮ縺ｮ繝弱ｼ繝縺ｨ1逡ｪ逶ｮ縺ｮ繝弱ｼ繝縺ｮ髢馴囈縺4蛻縺九◎繧御ｻ･荳
+ if (list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[0].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93)
+ list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[0].nSenote = 0;
+ else if (list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[0].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94)
+ list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[0].nSenote = 3;
+
+ if (list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[nCount + 1].n逋ｺ螢ｰ譎ょ綾ms - pChip.n逋ｺ螢ｰ譎ょ綾ms < nUnit4)
+ {
+ if (list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[nCount + 1].n逋ｺ螢ｰ譎ょ綾ms - pChip.n逋ｺ螢ｰ譎ょ綾ms < nUnit8)
+ {
+
+
+
+ //16蛻縺ｪ繧峨後ラ縲
+ if (pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93)
+ pChip.nSenote = 1;
+ }
+ else
+ {
+ if (pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93)
+ {
+ pChip.nSenote = 0;
+ }
+ else if (pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94)
+ {
+ pChip.nSenote = 3;
+ }
+ }
+ }
+ else
+ {
+ //谺｡繧4蛻縺ｪ繧峨後ラ繝ｳ縲阪°縲後き繝縲
+ if (pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93)
+ {
+ pChip.nSenote = 0;
+ }
+ else if (pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94)
+ {
+ pChip.nSenote = 3;
+ }
+ }
+ }
+ else if (pChip.n逋ｺ螢ｰ譎ょ綾ms - list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[nCount - 1].n逋ｺ螢ｰ譎ょ綾ms < nUnit4 && pChip.n逋ｺ螢ｰ譎ょ綾ms - list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[nCount - 1].n逋ｺ螢ｰ譎ょ綾ms > nUnit16)
+ {
+ //2逡ｪ逶ｮ縺ｮ繝√ャ繝励→1逡ｪ逶ｮ縺ｮ繝√ャ繝励ｮ髢馴囈縺4蛻莉･荳九〒縺九▽16蛻莉･荳
+ if (list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[0].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93)
+ list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[0].nSenote = 1;
+ else if (list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[0].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94)
+ list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[0].nSenote = 4;
+
+
+
+ if (pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93)
+ {
+ pChip.nSenote = 1;
+ }
+ else if (pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94)
+ {
+ pChip.nSenote = 4;
+ }
+
+ if (list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[nCount + 1].n逋ｺ螢ｰ譎ょ綾ms - pChip.n逋ｺ螢ｰ譎ょ綾ms >= nUnit4)
+ {
+ //3逡ｪ逶ｮ縺ｮ繝√ャ繝励→2逡ｪ逶ｮ縺ｮ繝√ャ繝励ｮ髢馴囈縺4蛻莉･荳
+ if (pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93)
+ {
+ pChip.nSenote = 0;
+ }
+ else if (pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94)
+ {
+ pChip.nSenote = 3;
+ }
+ }
+ if (list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[nCount + 1].n逋ｺ螢ｰ譎ょ綾ms - pChip.n逋ｺ螢ｰ譎ょ綾ms < nUnit4)
+ {
+ //3逡ｪ逶ｮ縺ｮ繝√ャ繝励→2逡ｪ逶ｮ縺ｮ繝√ャ繝励ｮ髢馴囈縺4蛻莉･荳
+ if (list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[nCount + 1].n逋ｺ螢ｰ譎ょ綾ms - pChip.n逋ｺ螢ｰ譎ょ綾ms <= nUnit8)
+ {
+
+ if (list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[nCount + 1].n逋ｺ螢ｰ譎ょ綾ms - pChip.n逋ｺ螢ｰ譎ょ綾ms < nUnit8)
+ {
+ if (list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[0].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93)
+ list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[0].nSenote = 0;
+ else if (list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[0].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94)
+ list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[0].nSenote = 3;
+ }
+
+
+
+
+ //16蛻縺ｪ繧峨後ラ縲
+ if (pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93)
+ pChip.nSenote = 1;
+ }
+ else
+ {
+ if (pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93)
+ {
+ pChip.nSenote = 1;
+ }
+ else if (pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94)
+ {
+ pChip.nSenote = 4;
+ }
+ }
+ }
+ }
+ else if (pChip.n逋ｺ螢ｰ譎ょ綾ms - list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[nCount - 1].n逋ｺ螢ｰ譎ょ綾ms <= nUnit16)
+ {
+ //2逡ｪ逶ｮ縺ｮ繝√ャ繝励→1逡ｪ逶ｮ縺ｮ繝√ャ繝励ｮ髢馴囈縺16蛻縺九◎繧御ｻ･荳
+ if (list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[nCount - 1].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93)
+ list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[nCount - 1].nSenote = 1;
+ else if (list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[nCount - 1].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94)
+ list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[nCount - 1].nSenote = 4;
+
+ if (pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93)
+ {
+ pChip.nSenote = 1;
+ }
+ else if (pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94)
+ {
+ pChip.nSenote = 4;
+ }
+
+ //1逡ｪ逶ｮ縺ｮ繝√ャ繝励′0x93
+ if (list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[nCount - 1].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93)
+ {
+ //3逡ｪ逶ｮ縺ｮ繝√ャ繝励→2逡ｪ逶ｮ縺ｮ繝√ャ繝励ｮ髢馴囈縺16蛻
+ if (list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[nCount + 1].n逋ｺ螢ｰ譎ょ綾ms - pChip.n逋ｺ螢ｰ譎ょ綾ms == nUnit16)
+ {
+ if (list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[nCount + 1].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93)
+ {
+ pChip.nSenote = 2;
+ }
+ }
+ }
+
+
+ }
+
+ nCount++;
+ continue;
+
+ #endregion
+ }
+
+ double db2蛟句燕縺ｮ逋ｺ螢ｰ譎ょ綾ms = list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[nCount - 2].n逋ｺ螢ｰ譎ょ綾ms * 1;
+
+ #region[譁ｰ縺励＞繧縺､]
+ if (pChip.n逋ｺ螢ｰ譎ょ綾ms - list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[nCount - 1].n逋ｺ螢ｰ譎ょ綾ms >= nUnit4)
+ {
+ //迴ｾ蝨ｨ縺ｮ繝√ャ繝励→1縺､蜑阪ｮ繝√ャ繝励ｮ髢馴囈縺4蛻莉･荳
+ dkdkCount = 0;
+ if (pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93)
+ {
+ pChip.nSenote = 0;
+ }
+ else if (pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94)
+ {
+ pChip.nSenote = 3;
+ }
+
+ if (nCount + 1 >= list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝.Count)
+ break;
+
+ //谺｡縺ｮ繝√ャ繝励→迴ｾ蝨ｨ縺ｮ繝√ャ繝励ｮ髢薙′4蛻莉･荳
+ if (list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[nCount + 1].n逋ｺ螢ｰ譎ょ綾ms - pChip.n逋ｺ螢ｰ譎ょ綾ms < nUnit6)
+ {
+ if (pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93)
+ pChip.nSenote = 1;
+ else if (pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94)
+ pChip.nSenote = 4;
+
+ //12縲16蛻縺後≠繧九↑繧峨後ラ繝ｳ縲阪°縲後き繝縲阪↓螟峨∴繧
+
+ if (list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[nCount + 2].n逋ｺ螢ｰ譎ょ綾ms - list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[nCount + 1].n逋ｺ螢ｰ譎ょ綾ms <= nUnit16)
+ {
+ if (pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93)
+ pChip.nSenote = 1;
+ else if (pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94)
+ pChip.nSenote = 4;
+ }
+ if (list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[nCount + 2].n逋ｺ螢ｰ譎ょ綾ms - list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[nCount + 1].n逋ｺ螢ｰ譎ょ綾ms < nUnit8)
+ {
+ if (pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93)
+ pChip.nSenote = 0;
+ else if (pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94)
+ pChip.nSenote = 3;
+ }
+ }
+ //else
+ //{
+ // if( pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93 )
+ // {
+ // pChip.nSenote = 0;
+ // }
+ // else if( pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94 )
+ // {
+ // pChip.nSenote = 3;
+ // }
+ //}
+ }
+ else if (pChip.n逋ｺ螢ｰ譎ょ綾ms - list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[nCount - 1].n逋ｺ螢ｰ譎ょ綾ms < nUnit4 && pChip.n逋ｺ螢ｰ譎ょ綾ms - list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[nCount - 1].n逋ｺ螢ｰ譎ょ綾ms > nUnit16)
+ {
+ //迴ｾ蝨ｨ縺ｮ繝√ャ繝励→1縺､蜑阪ｮ繝√ャ繝励ｮ髢馴囈縺4蛻莉･荳九°縺､16蛻莉･荳
+ dkdkCount = 0;
+ if (pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93)
+ {
+ pChip.nSenote = 1;
+ }
+ else if (pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94)
+ {
+ pChip.nSenote = 4;
+ }
+
+ if (nCount + 1 >= list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝.Count)
+ break;
+
+
+ if (list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[nCount + 1].n逋ｺ螢ｰ譎ょ綾ms - pChip.n逋ｺ螢ｰ譎ょ綾ms >= nUnit4)
+ {
+ //谺｡縺ｮ繝√ャ繝励→迴ｾ蝨ｨ縺ｮ繝√ャ繝励ｮ髢馴囈縺4蛻莉･荳
+ if (pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93)
+ pChip.nSenote = 0;
+ else if (pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94)
+ pChip.nSenote = 3;
+ }
+ else if (list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[nCount + 1].n逋ｺ螢ｰ譎ょ綾ms - pChip.n逋ｺ螢ｰ譎ょ綾ms < nUnit4 && list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[nCount + 1].n逋ｺ螢ｰ譎ょ綾ms - pChip.n逋ｺ螢ｰ譎ょ綾ms > nUnit16)
+ {
+ //谺｡縺ｮ繝√ャ繝励→迴ｾ蝨ｨ縺ｮ繝√ャ繝励ｮ髢馴囈縺4蛻莉･荳
+ if (pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93)
+ pChip.nSenote = 1;
+ else if (pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94)
+ pChip.nSenote = 4;
+
+ if (nCount + 2 >= list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝.Count)
+ break;
+
+ //谺｡縺ｮ繝√ャ繝励′0x93
+ //if( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount + 1 ].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93 )
+ //{
+ // if( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount + 2 ].n逋ｺ螢ｰ譎ょ綾ms - list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount + 1 ].n逋ｺ螢ｰ譎ょ綾ms < nUnit8 )
+ // {
+ // list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount + 1 ].nSenote = 2;
+ // }
+ //}
+
+ //12縲16蛻縺後≠繧九↑繧峨後ラ繝ｳ縲阪°縲後き繝縲阪↓螟峨∴繧
+ if (list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[nCount + 2].n逋ｺ螢ｰ譎ょ綾ms - list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[nCount + 1].n逋ｺ螢ｰ譎ょ綾ms < nUnit8)
+ {
+ if (pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93)
+ pChip.nSenote = 0;
+ else if (pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94)
+ pChip.nSenote = 3;
+
+ if (list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[nCount - 1].n逋ｺ螢ｰ譎ょ綾ms - list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[nCount - 2].n逋ｺ螢ｰ譎ょ綾ms >= nUnit8)
+ {
+ if (pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93)
+ pChip.nSenote = 1;
+ else if (pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94)
+ pChip.nSenote = 4;
+ }
+
+
+ }
+ }
+ else if (list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[nCount + 1].n逋ｺ螢ｰ譎ょ綾ms - pChip.n逋ｺ螢ｰ譎ょ綾ms <= nUnit16)
+ {
+ //谺｡縺ｮ繝√ャ繝励→迴ｾ蝨ｨ縺ｮ繝√ャ繝励ｮ髢馴囈縺16蛻莉･荳
+ //縺昴≧縺ｪ繧九→1縺､蜑阪ｮ繝√ャ繝励ｯ縲後ラ繝ｳ縲阪°縲後き繝縲阪↓縺ｪ繧
+ //if( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 1 ].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93 )
+ // list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 1 ].nSenote = 0;
+ //else if( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 1 ].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94 )
+ // list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 1 ].nSenote = 3;
+ }
+ else
+ {
+ if (pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93)
+ pChip.nSenote = 0;
+ else if (pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94)
+ pChip.nSenote = 3;
+ }
+ }
+ else if (pChip.n逋ｺ螢ｰ譎ょ綾ms - list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[nCount - 1].n逋ｺ螢ｰ譎ょ綾ms <= nUnit16)
+ {
+ //迴ｾ蝨ｨ縺ｮ繝弱ｼ繝縺ｨ1縺､蜑阪ｮ繝弱ｼ繝縺ｮ髢馴囈縺16蛻縺九◎繧御ｻ･荳
+ if (pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93)
+ {
+ pChip.nSenote = 1;
+ }
+ else if (pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94)
+ {
+ pChip.nSenote = 4;
+ }
+
+
+ try
+ {
+ if (nCount + 1 >= list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝.Count) //荳逡ｪ譛蠕後ｮ繝弱ｼ繝縺縺｣縺滓凾縺ｮ繧ｨ繝ｩ繝ｼ蟇ｾ遲悶
+ break;
+
+ //蠕後ｍ縺4蛻
+ if (list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[nCount + 1].n逋ｺ螢ｰ譎ょ綾ms - pChip.n逋ｺ螢ｰ譎ょ綾ms >= nUnit4)
+ {
+ dkdkCount = 0;
+ if (pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93)
+ {
+ pChip.nSenote = 0;
+ }
+ else if (pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94)
+ {
+ pChip.nSenote = 3;
+ }
+ }
+ else if (list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[nCount + 1].n逋ｺ螢ｰ譎ょ綾ms - pChip.n逋ｺ螢ｰ譎ょ綾ms <= nUnit4 && list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[nCount + 1].n逋ｺ螢ｰ譎ょ綾ms - pChip.n逋ｺ螢ｰ譎ょ綾ms >= nUnit8)
+ {
+ //谺｡縺ｮ繝弱ｼ繝縺ｨ迴ｾ蝨ｨ縺ｮ繝弱ｼ繝縺ｮ髢馴囈縺8蛻縺九◎繧御ｻ･荳九〒縺九▽16蛻莉･荳
+ dkdkCount = 0;
+ if (pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93)
+ {
+ pChip.nSenote = 0;
+ }
+ else if (pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94)
+ {
+ pChip.nSenote = 3;
+ }
+ }
+ else if (list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[nCount + 1].n逋ｺ螢ｰ譎ょ綾ms - pChip.n逋ｺ螢ｰ譎ょ綾ms < nUnit8)
+ {
+ if (pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93)
+ {
+ pChip.nSenote = 1;
+
+ if (nCount + 2 >= list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝.Count)
+ break;
+
+
+ //2015.03.31 kairera0467縲縲後さ縲阪ｒ隱ｿ遽縺吶ｋ驛ｨ蛻縲ゅ◆縺縺怜虚菴懊′縺ゅｄ縺励☆縺弱ｋ縺溘ａ縲√＞縺｣縺溘ｓ蟆∝魂縲
+ if (pChip.n逋ｺ螢ｰ譎ょ綾ms - list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[nCount - 1].n逋ｺ螢ｰ譎ょ綾ms <= nUnit16)
+ {
+ //1縺､蜑阪ｮ繝弱ｼ繝縺ｨ迴ｾ蝨ｨ縺ｮ繝弱ｼ繝縺ｮ髢馴囈縺16蛻
+ if (list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[nCount - 1].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93)
+ {
+ //繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ縺0x93
+ //if( dkdkCount == 0 )
+ //{
+ // pChip.nSenote = 2;
+ // dkdkCount = 1;
+ //}
+ //else
+ //{
+ // pChip.nSenote = 1;
+ // dkdkCount = 0;
+ //}
+ }
+
+ }
+ }
+ else if (pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94)
+ {
+ pChip.nSenote = 4;
+ }
+ }
+ }
+ catch (Exception ex)
+ {
+ Trace.TraceError(ex.ToString());
+ Trace.TraceError("萓句､悶′逋ｺ逕溘＠縺ｾ縺励◆縺悟ｦ逅繧堤ｶ咏ｶ壹＠縺ｾ縺吶 (1503896a-0dfb-4643-87f1-bd821a125137)");
+ }
+ }
+ else
+ {
+ if (pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93)
+ {
+ pChip.nSenote = 0;
+ }
+ else if (pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94)
+ {
+ pChip.nSenote = 3;
+ }
+ }
+ #endregion
+
+ #endregion
+
+ #region[蜿､縺繧縺､]
+ ////2縺､蜑阪→1縺､蜑阪ｮ繝√ャ繝励ｮSenote繧呈ｱｺ繧√※縺縺上
+ ////騾｣謇薙∝､ｧ髻ｳ隨ｦ縺ｪ縺ｩ縺ｯ繝√ャ繝鈴咲ｽｮ縺ｮ髫帙↓豎ｺ繧√∪縺吶
+ //if (( db1蛟句燕縺ｮ逋ｺ逕滓凾蛻ｻms - db2蛟句燕縺ｮ逋ｺ螢ｰ譎ょ綾ms ) >= nUnit4)
+ //{
+ // //2縺､蜑阪ｮ髻ｳ隨ｦ縺ｨ1縺､蜑阪ｮ髻ｳ隨ｦ縺ｮ髢薙′4蛻莉･荳翫〒縺九▽縲√◎縺ｮ髻ｳ隨ｦ縺後ラ繝ｳ縺ｪ繧2縺､蜑阪ｮSenote縺ｯ縲後ラ繝ｳ縲阪〒遒ｺ螳壹
+ // //蜷梧凾縺ｫdkdk繧偵Μ繧ｻ繝繝
+ // dkdkCount = false;
+ // if( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[nCount - 2].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93 )
+ // list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[nCount - 2].nSenote = 0;
+ // else if( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[nCount - 2].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94 )
+ // list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[nCount - 2].nSenote = 3;
+
+ // if( ( pChip.n逋ｺ螢ｰ譎ょ綾ms - db1蛟句燕縺ｮ逋ｺ逕滓凾蛻ｻms ) >= nUnit4 )
+ // {
+ // //1縺､蜑阪ｮ髻ｳ隨ｦ縺ｨ迴ｾ蝨ｨ縺ｮ髻ｳ隨ｦ縺ｮ髢薙′4蛻莉･荳翫°縺､縲√◎縺ｮ髻ｳ隨ｦ縺後ラ繝ｳ縺ｪ繧1縺､蜑阪ｮ髻ｳ隨ｦ縺ｯ縲後ラ繝ｳ縲阪〒遒ｺ螳壹
+ // if( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[nCount - 1].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93 )
+ // list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[nCount - 1].nSenote = 0;
+ // else if( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[nCount - 1].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94 )
+ // list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[nCount - 1].nSenote = 3;
+ // }
+ // else if( ( pChip.n逋ｺ螢ｰ譎ょ綾ms - db1蛟句燕縺ｮ逋ｺ逕滓凾蛻ｻms ) <= nUnit4 )
+ // {
+ // //4蛻
+ // if( ( pChip.n逋ｺ螢ｰ譎ょ綾ms - db1蛟句燕縺ｮ逋ｺ逕滓凾蛻ｻms ) >= nUnit8 )
+ // {
+ // dkdkCount = false;
+ // //1縺､蜑阪ｮ髻ｳ隨ｦ縺ｨ迴ｾ蝨ｨ縺ｮ髻ｳ隨ｦ縺ｮ髢薙′8蛻莉･蜀縺ｧ16蛻莉･荳翫〒縺九▽縲√◎縺ｮ髻ｳ隨ｦ縺瑚ｵ､縺ｪ繧1縺､蜑阪ｮ髻ｳ隨ｦ縺ｯ縲後ラ縲阪〒遒ｺ螳壹
+ // if( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 1 ].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94 )
+ // list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 1 ].nSenote = 2;
+ // else if( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 1 ].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94 )
+ // list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 1 ].nSenote = 4;
+ // }
+ // else if( ( db1蛟句燕縺ｮ逋ｺ逕滓凾蛻ｻms - db2蛟句燕縺ｮ逋ｺ螢ｰ譎ょ綾ms ) <= nUnit8 )
+ // {
+ // dkdkCount = false;
+ // if( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 2 ].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93 )
+ // {
+ // list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 2 ].nSenote = 1;
+
+ // //繝峨さ繝峨Φ
+ // if( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 1 ].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93 )
+ // {
+ // if( pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93 )
+ // pChip.nSenote = dkdkCount ? 2 : 1;
+ // if( dkdkCount == false )
+ // dkdkCount = true;
+ // else
+ // dkdkCount = false;
+ // }
+ // }
+ // else if( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 2 ].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94 )
+ // list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 2 ].nSenote = 4;
+ // }
+
+ // }
+ //}
+ //else if ( ( db1蛟句燕縺ｮ逋ｺ逕滓凾蛻ｻms - db2蛟句燕縺ｮ逋ｺ螢ｰ譎ょ綾ms ) <= nUnit4 && ( db1蛟句燕縺ｮ逋ｺ逕滓凾蛻ｻms - db2蛟句燕縺ｮ逋ｺ螢ｰ譎ょ綾ms ) >= nUnit8)
+ //{
+ // //2縺､蜑阪ｮ髻ｳ隨ｦ縺ｨ1縺､蜑阪ｮ髻ｳ隨ｦ縺ｮ髢薙′8蛻莉･荳翫〒縺九▽縲16蛻莉･蜀
+
+ // if( ( db1蛟句燕縺ｮ逋ｺ逕滓凾蛻ｻms - db2蛟句燕縺ｮ逋ｺ螢ｰ譎ょ綾ms ) >= nUnit8 && ( db1蛟句燕縺ｮ逋ｺ逕滓凾蛻ｻms - db2蛟句燕縺ｮ逋ｺ螢ｰ譎ょ綾ms ) > nUnit16 )
+ // {
+ // //2縺､蜑阪ｮ髻ｳ隨ｦ縺ｨ1縺､蜑阪ｮ髻ｳ隨ｦ縺ｮ髢薙′8蛻莉･荳翫〒縺九▽縲16蛻莉･蜀縺ｪ繧峨後ラ縲
+ // if( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 2 ].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93 )
+ // {
+ // list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 2 ].nSenote = 1;
+ // }
+ // else if( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 2 ].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94 )
+ // {
+ // list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 2 ].nSenote = 4;
+ // }
+ // }
+ // else if( ( db1蛟句燕縺ｮ逋ｺ逕滓凾蛻ｻms - db2蛟句燕縺ｮ逋ｺ螢ｰ譎ょ綾ms ) < nUnit8 )
+ // {
+ // //2縺､蜑阪ｮ髻ｳ隨ｦ縺ｨ1縺､蜑阪ｮ髻ｳ隨ｦ縺ｮ髢薙′16蛻莉･蜀縺ｪ繧峨後ラ縲阪〒遒ｺ螳
+ // if( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 2 ].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93 )
+ // {
+ // list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 2 ].nSenote = 1;
+ // }
+ // else if( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 2 ].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94 )
+ // list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 2 ].nSenote = 4;
+ // }
+
+ // if( ( pChip.n逋ｺ螢ｰ譎ょ綾ms - db1蛟句燕縺ｮ逋ｺ逕滓凾蛻ｻms ) >= nUnit16 )
+ // {
+ // if( ( pChip.n逋ｺ螢ｰ譎ょ綾ms - db1蛟句燕縺ｮ逋ｺ逕滓凾蛻ｻms ) >= nUnit8 )
+ // {
+ // if( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 2 ].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93 )
+ // {
+ // list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 1 ].nSenote = 0;
+ // }
+ // else if( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 2 ].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94 )
+ // list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 1 ].nSenote = 3;
+ // }
+ // }
+ //}
+ //else if ( ( db1蛟句燕縺ｮ逋ｺ逕滓凾蛻ｻms - db2蛟句燕縺ｮ逋ｺ螢ｰ譎ょ綾ms ) >= nUnit16 && ( db1蛟句燕縺ｮ逋ｺ逕滓凾蛻ｻms - db2蛟句燕縺ｮ逋ｺ螢ｰ譎ょ綾ms ) <= nUnit8 )
+ //{
+ // //2縺､蜑阪ｮ髻ｳ隨ｦ縺ｨ1縺､蜑阪ｮ髻ｳ隨ｦ縺ｮ髢薙′16蛻莉･荳
+ // if( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 2 ].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93 )
+ // {
+ // list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 2 ].nSenote = 1;
+ // }
+ // else if( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 2 ].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94 )
+ // list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 2 ].nSenote = 4;
+
+ // if( ( pChip.n逋ｺ螢ｰ譎ょ綾ms - db1蛟句燕縺ｮ逋ｺ逕滓凾蛻ｻms ) >= nUnit8 )
+ // {
+ // if( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 2 ].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x93 )
+ // {
+ // list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 1 ].nSenote = 0;
+ // }
+ // else if( list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 2 ].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x94 )
+ // list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[ nCount - 1 ].nSenote = 3;
+ // }
+
+
+ //}
+ #endregion
+
+ nCount++;
+ }
+ }
+
+ ///
+ /// 繧ｳ繧｢驛ｨ蛻Ver2縲５JAP2縺九ｉ遘ｻ讀阪＠縺溘□縺代
+ ///
+ ///
+ private void tSenotes_Core_V2(List list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝, bool ignoreSENote = false)
+ {
+ const int DATA = 3;
+ int doco_count = 0;
+ int[] sort = new int[7];
+ double[] time = new double[7];
+ double[] scroll = new double[7];
+ double time_tmp;
+
+ for (int i = 0; i < list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝.Count; i++)
+ {
+ for (int j = 0; j < 7; j++)
+ {
+ if (i + (j - 3) < 0)
+ {
+ sort[j] = -1;
+ time[j] = -1000000000;
+ scroll[j] = 1.0;
+ }
+ else if (i + (j - 3) >= list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝.Count)
+ {
+ sort[j] = -1;
+ time[j] = 1000000000;
+ scroll[j] = 1.0;
+ }
+ else
+ {
+ sort[j] = list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[i + (j - 3)].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ;
+ time[j] = list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[i + (j - 3)].fBMSCROLLTime;
+ scroll[j] = list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[i + (j - 3)].dbSCROLL;
+ }
+ }
+ time_tmp = time[DATA];
+ for (int j = 0; j < 7; j++)
+ {
+ time[j] = (time[j] - time_tmp) * scroll[j];
+ if (time[j] < 0) time[j] *= -1;
+ }
+
+ if (ignoreSENote && list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[i].IsFixedSENote) continue;
+
+ switch (list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[i].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ)
+ {
+ case 0x11:
+
+ //ｼ亥ｷｦ2繧医ｊ髮｢繧後※縺繧具ｽ懶ｼ雲蜿ｳ2_蜿ｳ繝峨Φ_蜿ｳ蜿ｳ4_蜿ｳ蜿ｳ繝峨Φ窶ｦ
+ if ((time[DATA - 1] > 2/* || (sort[DATA-1] != 1 && time[DATA-1] >= 2 && time[DATA-2] >= 4 && time[DATA-3] <= 5)*/) && time[DATA + 1] == 2 && sort[DATA + 1] == 1 && time[DATA + 2] == 4 && sort[DATA + 2] == 0x11 && time[DATA + 3] == 6 && sort[DATA + 3] == 0x11)
+ {
+ list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[i].nSenote = 1;
+ doco_count = 1;
+ break;
+ }
+ //繝峨さ繝峨さ荳ｭ_蟾ｦ2_蜿ｳ2_蜿ｳ繝峨Φ
+ else if (doco_count != 0 && time[DATA - 1] == 2 && time[DATA + 1] == 2 && (sort[DATA + 1] == 0x11 || sort[DATA + 1] == 0x11))
+ {
+ if (doco_count % 2 == 0)
+ list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[i].nSenote = 1;
+ else
+ list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[i].nSenote = 2;
+ doco_count++;
+ break;
+ }
+ else
+ {
+ doco_count = 0;
+ }
+
+ //8蛻繝峨さ繝峨Φ
+ if ((time[DATA - 2] >= 4.1 && time[DATA - 1] == 2 && time[DATA + 1] == 2 && time[DATA + 2] >= 4.1) && (sort[DATA - 1] == 0x11 && sort[DATA + 1] == 0x11))
+ {
+ if (list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[i].dbBPM >= 120.0)
+ {
+ list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[i - 1].nSenote = 1;
+ list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[i].nSenote = 2;
+ list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[i + 1].nSenote = 0;
+ break;
+ }
+ else if (list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[i].dbBPM < 120.0)
+ {
+ list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[i - 1].nSenote = 0;
+ list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[i].nSenote = 0;
+ list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[i + 1].nSenote = 0;
+ break;
+ }
+ }
+
+ //BPM120莉･荳九ｮ縺ｿ
+ //8蛻髢馴囈縺ｮ縲後ラ繝峨ラ縲坂偵後ラ繝ｳ繝峨Φ繝峨Φ縲
+
+ if (time[DATA - 1] >= 2 && time[DATA + 1] >= 2)
+ {
+ if (list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[i].dbBPM < 120.0)
+ {
+ list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[i].nSenote = 0;
+ break;
+ }
+ }
+
+ //繝峨さ繝峨さ繝峨Φ
+ if (time[DATA - 3] >= 3.4 && time[DATA - 2] == 2 && time[DATA - 1] == 1 && time[DATA + 1] == 1 && time[DATA + 2] == 2 && time[DATA + 3] >= 3.4 && sort[DATA - 2] == 0x93 && sort[DATA - 1] == 0x11 && sort[DATA + 1] == 0x11 && sort[DATA + 2] == 0x11)
+ {
+ list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[i - 2].nSenote = 1;
+ list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[i - 1].nSenote = 2;
+ list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[i + 0].nSenote = 1;
+ list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[i + 1].nSenote = 2;
+ list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[i + 2].nSenote = 0;
+ i += 2;
+ //break;
+ }
+ //繝峨さ繝峨Φ
+ else if (time[DATA - 2] >= 2.4 && time[DATA - 1] == 1 && time[DATA + 1] == 1 && time[DATA + 2] >= 2.4 && sort[DATA - 1] == 0x11 && sort[DATA + 1] == 0x11)
+ {
+ list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[i].nSenote = 2;
+ }
+ //蜿ｳ縺ｮ髻ｳ隨ｦ縺2莉･荳企屬繧後※縺繧
+ else if (time[DATA + 1] > 2)
+ {
+ list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[i].nSenote = 0;
+ }
+ //蜿ｳ縺ｮ髻ｳ隨ｦ縺1.4莉･荳垣蟾ｦ縺ｮ髻ｳ隨ｦ縺1.4莉･蜀
+ else if (time[DATA + 1] >= 1.4 && time[DATA - 1] <= 1.4)
+ {
+ list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[i].nSenote = 0;
+ }
+ //蜿ｳ縺ｮ髻ｳ隨ｦ縺2莉･荳垣蜿ｳ蜿ｳ縺ｮ髻ｳ隨ｦ縺3莉･蜀
+ else if (time[DATA + 1] >= 2 && time[DATA + 2] <= 3)
+ {
+ list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[i].nSenote = 0;
+ }
+ //蜿ｳ縺ｮ髻ｳ隨ｦ縺2莉･荳垣螟ｧ髻ｳ隨ｦ
+ else if (time[DATA + 1] >= 2 && (sort[DATA + 1] == 0x13 || sort[DATA + 1] == 0x14))
+ {
+ list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[i].nSenote = 0;
+ }
+ else
+ {
+ list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[i].nSenote = 1;
+ }
+ break;
+ case 0x12:
+ doco_count = 0;
+
+ //BPM120莉･荳九ｮ縺ｿ
+ //8蛻髢馴囈縺ｮ縲後ラ繝峨ラ縲坂偵後ラ繝ｳ繝峨Φ繝峨Φ縲
+ if (time[DATA - 1] == 2 && time[DATA + 1] == 2)
+ {
+ if (list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[i - 1].dbBPM < 120.0 && list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[i].dbBPM < 120.0 && list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[i + 1].dbBPM < 120.0)
+ {
+ list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[i].nSenote = 3;
+ break;
+ }
+ }
+
+ //蜿ｳ縺ｮ髻ｳ隨ｦ縺2莉･荳企屬繧後※縺繧
+ if (time[DATA + 1] > 2)
+ {
+ list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[i].nSenote = 3;
+ }
+ //蜿ｳ縺ｮ髻ｳ隨ｦ縺1.4莉･荳垣蟾ｦ縺ｮ髻ｳ隨ｦ縺1.4莉･蜀
+ else if (time[DATA + 1] >= 1.4 && time[DATA - 1] <= 1.4)
+ {
+ list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[i].nSenote = 3;
+ }
+ //蜿ｳ縺ｮ髻ｳ隨ｦ縺2莉･荳垣蜿ｳ蜿ｳ縺ｮ髻ｳ隨ｦ縺3莉･蜀
+ else if (time[DATA + 1] >= 2 && time[DATA + 2] <= 3)
+ {
+ list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[i].nSenote = 3;
+ }
+ //蜿ｳ縺ｮ髻ｳ隨ｦ縺2莉･荳垣螟ｧ髻ｳ隨ｦ
+ else if (time[DATA + 1] >= 2 && (sort[DATA + 1] == 0x13 || sort[DATA + 1] == 0x14))
+ {
+ list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[i].nSenote = 3;
+ }
+ else
+ {
+ list髻ｳ隨ｦ縺ｮ縺ｿ縺ｮ繝ｪ繧ｹ繝[i].nSenote = 4;
+ }
+ break;
+ default:
+ doco_count = 0;
+ break;
+ }
+ }
+ }
+
+ ///
+ /// 繧ｵ繧ｦ繝ｳ繝峨Α繧ｭ繧ｵ繝ｼ縺ｫ繧ｵ繧ｦ繝ｳ繝峨ｒ逋ｻ骭ｲ_蜑企勁縺吶ｋ譎ょ綾繧剃ｺ句燕縺ｫ邂怜ｺ縺吶ｋ
+ ///
+ public void PlanToAddMixerChannel()
+ {
+ if (TJAPlayer3.Sound邂｡逅.GetCurrentSoundDeviceType() == "DirectSound") // DShow縺ｧ縺ｮ蜀咲函縺ｮ蝣ｴ蜷医ｯ繝溘く繧ｷ繝ｳ繧ｰ雋闕ｷ縺碁ｫ倥￥縺ｪ縺縺溘ａ縲
+ { // 繝√ャ繝励ｮ繝ｩ繧､繝輔ち繧､繝邂｡逅繧定｡後ｏ縺ｪ縺
+ return;
+ }
+
+ List listAddMixerChannel = new List(128); ;
+ List listRemoveMixerChannel = new List(128);
+ List listRemoveTiming = new List(128);
+
+ foreach (CChip pChip in listChip)
+ {
+ switch (pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ)
+ {
+ // BGM, 貍泌･上メ繝｣繝阪Ν, 荳榊庄隕悶し繧ｦ繝ｳ繝, 繝輔ぅ繝ｫ繧､繝ｳ繧ｵ繧ｦ繝ｳ繝, 遨ｺ謇薙■髻ｳ縺ｯ繝溘く繧ｵ繝ｼ邂｡逅縺ｮ蟇ｾ雎｡
+ // BGM:
+ case 0x01:
+ // Dr貍泌･上メ繝｣繝阪Ν
+ //case 0x11: case 0x12: case 0x13: case 0x14: case 0x15: case 0x16: case 0x17: case 0x18: case 0x19: case 0x1A: case 0x1B: case 0x1C:
+ // Gt貍泌･上メ繝｣繝阪Ν
+ //case 0x20: case 0x21: case 0x22: case 0x23: case 0x24: case 0x25: case 0x26: case 0x27: case 0x28:
+ // Bs貍泌･上メ繝｣繝阪Ν
+ //case 0xA0: case 0xA1: case 0xA2: case 0xA3: case 0xA4: case 0xA5: case 0xA6: case 0xA7: case 0xA8:
+ // Dr荳榊庄隕悶メ繝繝
+ //case 0x31: case 0x32: case 0x33: case 0x34: case 0x35: case 0x36: case 0x37:
+ //case 0x38: case 0x39: case 0x3A:
+ // Dr/Gt/Bs遨ｺ謇薙■
+ //case 0xB1: case 0xB2: case 0xB3: case 0xB4: case 0xB5: case 0xB6: case 0xB7: case 0xB8:
+ //case 0xB9: case 0xBA: case 0xBB: case 0xBC:
+ // 繝輔ぅ繝ｫ繧､繝ｳ繧ｵ繧ｦ繝ｳ繝
+ //case 0x1F: case 0x2F: case 0xAF:
+ // 閾ｪ蜍墓ｼ泌･上メ繝繝
+ //case 0x61: case 0x62: case 0x63: case 0x64: case 0x65: case 0x66: case 0x67: case 0x68: case 0x69:
+ //case 0x70: case 0x71: case 0x72: case 0x73: case 0x74: case 0x75: case 0x76: case 0x77: case 0x78: case 0x79:
+ //case 0x80: case 0x81: case 0x82: case 0x83: case 0x84: case 0x85: case 0x86: case 0x87: case 0x88: case 0x89:
+ //case 0x90: case 0x91: case 0x92:
+
+ #region [ 逋ｺ髻ｳ1遘貞燕縺ｮ繧ｿ繧､繝溘Φ繧ｰ繧堤ｮ怜ｺ ]
+ int n逋ｺ髻ｳ蜑堺ｽ呵｣瀕s = 1000, n逋ｺ髻ｳ蠕御ｽ呵｣瀕s = 800;
+ {
+ int ch = pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ >> 4;
+ if (ch == 0x02 || ch == 0x0A)
+ {
+ n逋ｺ髻ｳ蜑堺ｽ呵｣瀕s = 800;
+ n逋ｺ髻ｳ蜑堺ｽ呵｣瀕s = 500;
+ }
+ if (ch == 0x06 || ch == 0x07 || ch == 0x08 || ch == 0x09)
+ {
+ n逋ｺ髻ｳ蜑堺ｽ呵｣瀕s = 200;
+ n逋ｺ髻ｳ蜑堺ｽ呵｣瀕s = 500;
+ }
+ }
+ #endregion
+ #region [ BGM繝√ャ繝励↑繧峨ｰ蜊ｳ繝溘く繧ｵ繝ｼ縺ｫ霑ｽ蜉 ]
+ //if ( pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ == 0x01 ) // BGM繝√ャ繝励ｯ蜊ｳ繝溘く繧ｵ繝ｼ縺ｫ霑ｽ蜉
+ //{
+ // if ( listWAV.ContainsKey( pChip.n謨ｴ謨ｰ蛟､_蜀驛ｨ逡ｪ蜿ｷ ) )
+ // {
+ // CDTX.CWAV wc = CDTXMania.DTX.listWAV[ pChip.n謨ｴ謨ｰ蛟､_蜀驛ｨ逡ｪ蜿ｷ ];
+ // if ( wc.rSound[ 0 ] != null )
+ // {
+ // CDTXMania.Sound邂｡逅.AddMixer( wc.rSound[ 0 ] ); // BGM縺ｯ螟夐榊咲函縺励↑縺莉墓ｧ倥→縺励※縺繧九ｮ縺ｧ縲1蛟狗岼縺縺代Α繧ｭ繧ｵ繝ｼ縺ｫ逋ｻ骭ｲ縺吶ｌ縺ｰ繧医＞
+ // }
+ // }
+ //}
+ #endregion
+ #region [ 逋ｺ髻ｳ1遘貞燕縺ｮ繧ｿ繧､繝溘Φ繧ｰ繧堤ｮ怜ｺ ]
+ int nAddMixer譎ょ綾ms, nAddMixer菴咲ｽｮ = 0;
+ //Debug.WriteLine("==================================================================");
+ //Debug.WriteLine( "Start: ch=" + pChip.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ.ToString("x2") + ", nWAV逡ｪ蜿ｷ=" + pChip.n謨ｴ謨ｰ蛟､ + ", time=" + pChip.n逋ｺ螢ｰ譎ょ綾ms + ", lasttime=" + listChip[ listChip.Count - 1 ].n逋ｺ螢ｰ譎ょ綾ms );
+ t逋ｺ螢ｰ譎ょ綾ms縺ｨ逋ｺ螢ｰ菴咲ｽｮ繧貞叙蠕励☆繧(pChip.n逋ｺ螢ｰ譎ょ綾ms - n逋ｺ髻ｳ蜑堺ｽ呵｣瀕s, out nAddMixer譎ょ綾ms, out nAddMixer菴咲ｽｮ);
+ //Debug.WriteLine( "nAddMixer譎ょ綾ms=" + nAddMixer譎ょ綾ms + ",nAddMixer菴咲ｽｮ=" + nAddMixer菴咲ｽｮ );
+
+ CChip c_AddMixer = new CChip()
+ {
+ n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ = 0xDA,
+ n謨ｴ謨ｰ蛟､ = pChip.n謨ｴ謨ｰ蛟､,
+ n謨ｴ謨ｰ蛟､_蜀驛ｨ逡ｪ蜿ｷ = pChip.n謨ｴ謨ｰ蛟､_蜀驛ｨ逡ｪ蜿ｷ,
+ n逋ｺ螢ｰ譎ょ綾ms = nAddMixer譎ょ綾ms,
+ n逋ｺ螢ｰ菴咲ｽｮ = nAddMixer菴咲ｽｮ,
+ b貍泌･冗ｵゆｺ蠕後ｂ蜀咲函縺檎ｶ壹￥繝√ャ繝励〒縺ゅｋ = false
+ };
+ listAddMixerChannel.Add(c_AddMixer);
+ //Debug.WriteLine("listAddMixerChannel:" );
+ //DebugOut_CChipList( listAddMixerChannel );
+ #endregion
+
+ int duration = 0;
+ if (listWAV.TryGetValue(pChip.n謨ｴ謨ｰ蛟､_蜀驛ｨ逡ｪ蜿ｷ, out CDTX.CWAV wc))
+ {
+ double _db蜀咲函騾溷ｺｦ = (TJAPlayer3.DTXVmode.Enabled) ? this.dbDTXVPlaySpeed : this.db蜀咲函騾溷ｺｦ;
+ duration = (wc.rSound[0] == null) ? 0 : (int)(wc.rSound[0].n邱乗ｼ泌･乗凾髢杜s / _db蜀咲函騾溷ｺｦ); // #23664 duration縺ｫ蜀咲函騾溷ｺｦ縺悟刈蜻ｳ縺輔ｌ縺ｦ縺翫ｉ縺壹∽ｽ朱溷咲函縺ｧBGM縺碁泌繧後ｋ蝠城｡後ｒ菫ｮ豁｣ (逋ｺ螢ｰ譎ょ綾ms縺ｯ縲．TX隱ｭ縺ｿ霎ｼ縺ｿ譎ゅ↓蜀咲函騾溷ｺｦ蜉蜻ｳ貂)
+ }
+ //Debug.WriteLine("duration=" + duration );
+ int n譁ｰRemoveMixer譎ょ綾ms, n譁ｰRemoveMixer菴咲ｽｮ;
+ t逋ｺ螢ｰ譎ょ綾ms縺ｨ逋ｺ螢ｰ菴咲ｽｮ繧貞叙蠕励☆繧(pChip.n逋ｺ螢ｰ譎ょ綾ms + duration + n逋ｺ髻ｳ蠕御ｽ呵｣瀕s, out n譁ｰRemoveMixer譎ょ綾ms, out n譁ｰRemoveMixer菴咲ｽｮ);
+ //Debug.WriteLine( "n譁ｰRemoveMixer譎ょ綾ms=" + n譁ｰRemoveMixer譎ょ綾ms + ",n譁ｰRemoveMixer菴咲ｽｮ=" + n譁ｰRemoveMixer菴咲ｽｮ );
+ if (n譁ｰRemoveMixer譎ょ綾ms < pChip.n逋ｺ螢ｰ譎ょ綾ms + duration) // 譖ｲ縺ｮ譛蠕後〒繧ｵ繧ｦ繝ｳ繝峨′蛻繧後ｋ繧医≧縺ｪ蝣ｴ蜷医ｯ
+ {
+ CChip c_AddMixer_noremove = c_AddMixer;
+ c_AddMixer_noremove.b貍泌･冗ｵゆｺ蠕後ｂ蜀咲函縺檎ｶ壹￥繝√ャ繝励〒縺ゅｋ = true;
+ listAddMixerChannel[listAddMixerChannel.Count - 1] = c_AddMixer_noremove;
+ //continue; // 逋ｺ螢ｰ菴咲ｽｮ縺ｮ險育ｮ励′縺ｧ縺阪↑縺縺ｮ縺ｧ縲｀ixer蜑企勁繧偵≠縺阪ｉ繧√ｋ___縺ｮ縺ｧ縺ｯ縺ｪ縺
+ // #32248 2013.10.15 yyagi 貍泌･冗ｵゆｺ蠕後ｂ蜀咲函繧堤ｶ壹¢繧九メ繝繝励〒縺ゅｋ縺ｨ縺縺繝輔Λ繧ｰ繧恥Chip蜀縺ｫ遶九※繧
+ break;
+ }
+ #region [ 譛ｪ菴ｿ逕ｨ繧ｳ繝ｼ繝 ]
+ //if ( n譁ｰRemoveMixer譎ょ綾ms < pChip.n逋ｺ螢ｰ譎ょ綾ms + duration ) // 譖ｲ縺ｮ譛蠕後〒繧ｵ繧ｦ繝ｳ繝峨′蛻繧後ｋ繧医≧縺ｪ蝣ｴ蜷
+ //{
+ // n譁ｰRemoveMixer譎ょ綾ms = pChip.n逋ｺ螢ｰ譎ょ綾ms + duration;
+ // // 縲御ｽ咲ｽｮ縲阪ｯ豈比ｾ玖ｨ育ｮ励〒豎ゅａ縺ｦ縺願幻繧呈ｿ√☆...縺薙ｮ繧繧頑婿縺縺ｨ隱､蜍穂ｽ懊＠縺溘◆繧∝ｯｾ蠢應ｸｭ豁｢
+ // n譁ｰRemoveMixer菴咲ｽｮ = listChip[ listChip.Count - 1 ].n逋ｺ螢ｰ菴咲ｽｮ * n譁ｰRemoveMixer譎ょ綾ms / listChip[ listChip.Count - 1 ].n逋ｺ螢ｰ譎ょ綾ms;
+ //}
+ #endregion
+
+ #region [ 逋ｺ髻ｳ邨ゆｺ2遘貞ｾ後↓mixer縺九ｉ蜑企勁縺吶ｋ縺後√◎縺ｮ蜑阪↓蜀咲匱髻ｳ縺吶ｋ縺薙→縺ｫ縺ｪ繧九ｮ縺九ｒ遒ｺ隱(蜀咲匱髻ｳ縺ｪ繧盈ixer蜑企勁繧ｿ繧､繝溘Φ繧ｰ繧貞ｻｶ譛) ]
+ int n謨ｴ謨ｰ蛟､ = pChip.n謨ｴ謨ｰ蛟､;
+ int index = listRemoveTiming.FindIndex(
+ delegate (CChip cchip) { return cchip.n謨ｴ謨ｰ蛟､ == n謨ｴ謨ｰ蛟､; }
+ );
+ //Debug.WriteLine( "index=" + index );
+ if (index >= 0) // 驕主悉縺ｫ蜷後§繝√ャ繝励〒逋ｺ髻ｳ荳ｭ縺ｮ繧ゅｮ縺瑚ｦ九▽縺九▲縺溷ｴ蜷
+ { // 驕主悉縺ｮ逋ｺ髻ｳ縺ｮmixer蜑企勁繧堤｢ｺ螳壹＆縺帙ｋ縺九∝ｻｶ譛溘☆繧九°縺ｮ2謚槭
+ int n譌ｧRemoveMixer譎ょ綾ms = listRemoveTiming[index].n逋ｺ螢ｰ譎ょ綾ms;
+ int n譌ｧRemoveMixer菴咲ｽｮ = listRemoveTiming[index].n逋ｺ螢ｰ菴咲ｽｮ;
+
+ //Debug.WriteLine( "n譌ｧRemoveMixer譎ょ綾ms=" + n譌ｧRemoveMixer譎ょ綾ms + ",n譌ｧRemoveMixer菴咲ｽｮ=" + n譌ｧRemoveMixer菴咲ｽｮ );
+ if (pChip.n逋ｺ螢ｰ譎ょ綾ms - n逋ｺ髻ｳ蜑堺ｽ呵｣瀕s <= n譌ｧRemoveMixer譎ょ綾ms) // mixer蜑企勁蜑阪↓縲∝酔縺倬浹縺ｮ蜀咲匱髻ｳ縺後≠繧句ｴ蜷医ｯ縲
+ { // mixer蜑企勁譎ょ綾繧帝≦蟒ｶ縺輔○繧(if-else蠕後↓陦後≧)
+ //Debug.WriteLine( "remove TAIL of listAddMixerChannel. TAIL INDEX=" + listAddMixerChannel.Count );
+ //DebugOut_CChipList( listAddMixerChannel );
+ listAddMixerChannel.RemoveAt(listAddMixerChannel.Count - 1); // 縺ｾ縺溘∝酔縺倥メ繝繝鈴浹縺ｮ縲稽ixer縺ｸ縺ｮ蜀崎ｿｽ蜉縲阪ｯ蜑企勁縺吶ｋ
+ //Debug.WriteLine( "removed result:" );
+ //DebugOut_CChipList( listAddMixerChannel );
+ }
+ else // 騾縺ｫ縲∵凾髢楢ｻｸ荳翫［ixer蜑企勁蠕後↓蜀咲匱髻ｳ縺吶ｋ繧医≧縺ｪ豬√ｌ縺ｮ蝣ｴ蜷医ｯ
+ {
+ //Debug.WriteLine( "Publish the value(listRemoveTiming[index] to listRemoveMixerChannel." );
+ listRemoveMixerChannel.Add(listRemoveTiming[index]); // mixer蜑企勁繧堤｢ｺ螳壹＆縺帙ｋ
+ //Debug.WriteLine( "listRemoveMixerChannel:" );
+ //DebugOut_CChipList( listRemoveMixerChannel );
+ //listRemoveTiming.RemoveAt( index );
+ }
+ CChip c = new CChip() // mixer蜑企勁譎ょ綾繧呈峩譁ｰ(驕蟒ｶ)縺吶ｋ
+ {
+ n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ = 0xDB,
+ n謨ｴ謨ｰ蛟､ = listRemoveTiming[index].n謨ｴ謨ｰ蛟､,
+ n謨ｴ謨ｰ蛟､_蜀驛ｨ逡ｪ蜿ｷ = listRemoveTiming[index].n謨ｴ謨ｰ蛟､_蜀驛ｨ逡ｪ蜿ｷ,
+ n逋ｺ螢ｰ譎ょ綾ms = n譁ｰRemoveMixer譎ょ綾ms,
+ n逋ｺ螢ｰ菴咲ｽｮ = n譁ｰRemoveMixer菴咲ｽｮ
+ };
+ listRemoveTiming[index] = c;
+ //listRemoveTiming[ index ].n逋ｺ螢ｰ譎ょ綾ms = n譁ｰRemoveMixer譎ょ綾ms; // mixer蜑企勁譎ょ綾繧呈峩譁ｰ(驕蟒ｶ)縺吶ｋ
+ //listRemoveTiming[ index ].n逋ｺ螢ｰ菴咲ｽｮ = n譁ｰRemoveMixer菴咲ｽｮ;
+ //Debug.WriteLine( "listRemoveTiming: modified" );
+ //DebugOut_CChipList( listRemoveTiming );
+ }
+ else // 驕主悉縺ｫ蜷後§繝√ャ繝励ｒ逋ｺ髻ｳ縺励※縺縺ｪ縺or
+ { // 逋ｺ髻ｳ縺励※縺縺溘′譌｢縺ｫmixer蜑企勁遒ｺ螳壹＠縺ｦ縺縺溘↑繧
+ CChip c = new CChip() // 譁ｰ縺励￥mixer蜑企勁蛟呵｣懊→縺励※霑ｽ蜉縺吶ｋ
+ {
+ n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ = 0xDB,
+ n謨ｴ謨ｰ蛟､ = pChip.n謨ｴ謨ｰ蛟､,
+ n謨ｴ謨ｰ蛟､_蜀驛ｨ逡ｪ蜿ｷ = pChip.n謨ｴ謨ｰ蛟､_蜀驛ｨ逡ｪ蜿ｷ,
+ n逋ｺ螢ｰ譎ょ綾ms = n譁ｰRemoveMixer譎ょ綾ms,
+ n逋ｺ螢ｰ菴咲ｽｮ = n譁ｰRemoveMixer菴咲ｽｮ
+ };
+ //Debug.WriteLine( "Add new chip to listRemoveMixerTiming: " );
+ //Debug.WriteLine( "ch=" + c.n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ.ToString( "x2" ) + ", nWAV逡ｪ蜿ｷ=" + c.n謨ｴ謨ｰ蛟､ + ", time=" + c.n逋ｺ螢ｰ譎ょ綾ms + ", lasttime=" + listChip[ listChip.Count - 1 ].n逋ｺ螢ｰ譎ょ綾ms );
+ listRemoveTiming.Add(c);
+ //Debug.WriteLine( "listRemoveTiming:" );
+ //DebugOut_CChipList( listRemoveTiming );
+ }
+ #endregion
+ break;
+ }
+ }
+ //Debug.WriteLine("==================================================================");
+ //Debug.WriteLine( "Result:" );
+ //Debug.WriteLine( "listAddMixerChannel:" );
+ //DebugOut_CChipList( listAddMixerChannel );
+ //Debug.WriteLine( "listRemoveMixerChannel:" );
+ //DebugOut_CChipList( listRemoveMixerChannel );
+ //Debug.WriteLine( "listRemoveTiming:" );
+ //DebugOut_CChipList( listRemoveTiming );
+ //Debug.WriteLine( "==================================================================" );
+
+ listChip.AddRange(listAddMixerChannel);
+ listChip.AddRange(listRemoveMixerChannel);
+ listChip.AddRange(listRemoveTiming);
+ listChip.Sort();
+ }
+ private void DebugOut_CChipList(List c)
+ {
+ //Debug.WriteLine( "Count=" + c.Count );
+ for (int i = 0; i < c.Count; i++)
+ {
+ Debug.WriteLine(i + ": ch=" + c[i].n繝√Ε繝ｳ繝阪Ν逡ｪ蜿ｷ.ToString("x2") + ", WAV逡ｪ蜿ｷ=" + c[i].n謨ｴ謨ｰ蛟､ + ", time=" + c[i].n逋ｺ螢ｰ譎ょ綾ms);
+ }
+ }
+ private bool t逋ｺ螢ｰ譎ょ綾ms縺ｨ逋ｺ螢ｰ菴咲ｽｮ繧貞叙蠕励☆繧(int n蟶梧悍逋ｺ螢ｰ譎ょ綾ms, out int n譁ｰ逋ｺ螢ｰ譎ょ綾ms, out int n譁ｰ逋ｺ螢ｰ菴咲ｽｮ)
+ {
+ // 逋ｺ螢ｰ譎ょ綾ms縺九ｉ逋ｺ螢ｰ菴咲ｽｮ繧帝邂励☆繧九％縺ｨ縺ｯ縺ｧ縺阪↑縺縺溘ａ縲∬ｿ台ｼｼ險育ｮ励☆繧九
+ // 蜈ｷ菴鍋噪縺ｫ縺ｯ縲∝ｸ梧悍逋ｺ螢ｰ菴咲ｽｮ蜑榊ｾ後ｮ2縺､縺ｮ繝√ャ繝励ｮ逋ｺ螢ｰ菴咲ｽｮ縺ｮ荳ｭ髢薙ｒ蜿悶ｋ縲
+
+ if (n蟶梧悍逋ｺ螢ｰ譎ょ綾ms < 0)
+ {
+ n蟶梧悍逋ｺ螢ｰ譎ょ綾ms = 0;
+ }
+ //else if ( n蟶梧悍逋ｺ螢ｰ譎ょ綾ms > listChip[ listChip.Count - 1 ].n逋ｺ螢ｰ譎ょ綾ms ) // BGM縺ｮ譛蠕後ｮ菴咎渊繧呈ｮｺ縺励※縺励∪縺縺ｮ縺ｧ縲√％縺ｮ譚｡莉ｶ縺ｯ螟悶☆
+ //{
+ // n蟶梧悍逋ｺ螢ｰ譎ょ綾ms = listChip[ listChip.Count - 1 ].n逋ｺ螢ｰ譎ょ綾ms;
+ //}
+
+ int index_min = -1, index_max = -1;
+ for (int i = 0; i < listChip.Count; i++) // 蟶梧悍逋ｺ螢ｰ菴咲ｽｮ蜑榊ｾ後ｮ縲悟燕縲阪ｮ譁ｹ縺ｮ繝√ャ繝励ｒ讀懃ｴ｢
+ {
+ if (listChip[i].n逋ｺ螢ｰ譎ょ綾ms >= n蟶梧悍逋ｺ螢ｰ譎ょ綾ms)
+ {
+ index_min = i;
+ break;
+ }
+ }
+ if (index_min < 0) // 蟶梧悍逋ｺ螢ｰ譎ょ綾縺ｫ閾ｳ繧峨★縺ｫ譖ｲ縺檎ｵゆｺ縺励※縺励∪縺蝣ｴ蜷
+ {
+ // list縺ｮ譛邨る逶ｮ縺ｮ譎ょ綾繧偵◎縺ｮ縺ｾ縺ｾ菴ｿ逕ｨ縺吶ｋ
+ //___縺ｮ縺ｧ縺ｯ繝繝｡縲BGM縺悟ｰｻ蛻繧後↓縺ｪ繧九
+ // 縺昴％縺ｧ縲〕ist縺ｮ譛邨る逶ｮ縺ｮ逋ｺ螢ｰ譎ょ綾ms縺ｨ逋ｺ逕滉ｽ咲ｽｮ縺九ｉ縲∝ｸ梧悍逋ｺ螢ｰ譎ょ綾縺ｫ逶ｸ蠖薙☆繧句ｸ梧悍逋ｺ螢ｰ菴咲ｽｮ繧呈ｯ比ｾ玖ｨ育ｮ励＠縺ｦ豎ゅａ繧九
+ //n譁ｰ逋ｺ螢ｰ譎ょ綾ms = n蟶梧悍逋ｺ螢ｰ譎ょ綾ms;
+ //n譁ｰ逋ｺ螢ｰ菴咲ｽｮ = listChip[ listChip.Count - 1 ].n逋ｺ螢ｰ菴咲ｽｮ * n蟶梧悍逋ｺ螢ｰ譎ょ綾ms / listChip[ listChip.Count - 1 ].n逋ｺ螢ｰ譎ょ綾ms;
+ n譁ｰ逋ｺ螢ｰ譎ょ綾ms = listChip[listChip.Count - 1].n逋ｺ螢ｰ譎ょ綾ms;
+ n譁ｰ逋ｺ螢ｰ菴咲ｽｮ = listChip[listChip.Count - 1].n逋ｺ螢ｰ菴咲ｽｮ;
+ return false;
+ }
+ index_max = index_min + 1;
+ if (index_max >= listChip.Count)
+ {
+ index_max = index_min;
+ }
+ n譁ｰ逋ｺ螢ｰ譎ょ綾ms = (listChip[index_max].n逋ｺ螢ｰ譎ょ綾ms + listChip[index_min].n逋ｺ螢ｰ譎ょ綾ms) / 2;
+ n譁ｰ逋ｺ螢ｰ菴咲ｽｮ = (listChip[index_max].n逋ｺ螢ｰ菴咲ｽｮ + listChip[index_min].n逋ｺ螢ｰ菴咲ｽｮ) / 2;
+
+ return true;
+ }
+
+ public void SwapGuitarBassInfos()
+ {
+ }
+
+ // SwapGuitarBassInfos_AutoFlags()縺ｯ縲，DTX縺九ｉCConfigIni縺ｫ遘ｻ蜍輔
+
+ // CActivity 螳溯｣
+ private CPrivateFastFont pf豁瑚ｩ槭ヵ繧ｩ繝ｳ繝;
+ public override void On豢ｻ諤ｧ蛹()
+ {
+ if (!string.IsNullOrEmpty(TJAPlayer3.Skin.Game_Lyric_FontName))
+ {
+ this.pf豁瑚ｩ槭ヵ繧ｩ繝ｳ繝 = new CPrivateFastFont(new FontFamily(TJAPlayer3.Skin.Game_Lyric_FontName), TJAPlayer3.Skin.Game_Lyric_FontSize);
+ }
+ else
+ {
+ this.pf豁瑚ｩ槭ヵ繧ｩ繝ｳ繝 = new CPrivateFastFont(new FontFamily("MS UI Gothic"), TJAPlayer3.Skin.Game_Lyric_FontSize);
+ }
+ this.listWAV = new Dictionary();
+ this.listBPM = new Dictionary();
+ this.listSCROLL = new Dictionary();
+ this.listSCROLL_Normal = new Dictionary();
+ this.listSCROLL_Expert = new Dictionary();
+ this.listSCROLL_Master = new Dictionary();
+ this.listJPOSSCROLL = new Dictionary();
+ this.listDELAY = new Dictionary();
+ this.listBRANCH = new Dictionary();
+ this.listAVI = new Dictionary();
+ this.listAVIPAN = new Dictionary();
+ this.listDS = new Dictionary();
+ this.listChip = new List();
+ this.listChip_Branch = new List[3];
+ this.listChip_Branch[0] = new List();
+ this.listChip_Branch[1] = new List();
+ this.listChip_Branch[2] = new List();
+ this.listBalloon = new List();
+ this.listBalloon_Normal = new List();
+ this.listBalloon_Expert = new List();
+ this.listBalloon_Master = new List