public static void フォルダ変数を追加する( string 変数名, string 置換するパス文字列 )
{
- フォルダ.フォルダ変数toパス[ 変数名 ] = 置換するパス文字列;
+ フォルダ._フォルダ変数toパス[ 変数名 ] = 置換するパス文字列;
}
public static void フォルダ変数を削除する( string 変数名 )
{
- if( フォルダ.フォルダ変数toパス.ContainsKey( 変数名 ) )
- フォルダ.フォルダ変数toパス.Remove( 変数名 );
+ if( フォルダ._フォルダ変数toパス.ContainsKey( 変数名 ) )
+ フォルダ._フォルダ変数toパス.Remove( 変数名 );
else
throw new FDKException( $"指定されたフォルダ変数「{変数名}」は存在しません。" );
}
{
if( null != path )
{
- foreach( var kvp in フォルダ.フォルダ変数toパス )
+ foreach( var kvp in フォルダ._フォルダ変数toパス )
{
if( kvp.Value.Nullまたは空である() )
continue;
{
if( null != path )
{
- foreach( var kvp in フォルダ.フォルダ変数toパス )
+ foreach( var kvp in フォルダ._フォルダ変数toパス )
{
if( kvp.Value.Nullまたは空である() )
continue;
return path;
}
- protected static readonly Dictionary<string, string> フォルダ変数toパス = new Dictionary<string, string>();
+ private static readonly Dictionary<string, string> _フォルダ変数toパス = new Dictionary<string, string>();
}
}
public bool 加算合成する { get; set; } = false;
- public SharpDX.Size2F サイズdpx => ( this.ShaderResourceViewSize );
+ public SharpDX.Size2F サイズdpx => ( this._ShaderResourceViewSize );
public テクスチャ( string 画像ファイルパス, SharpDX.Direct3D11.BindFlags bindFlags = SharpDX.Direct3D11.BindFlags.ShaderResource )
{
// ↓ どちらかを選択的に指定すること。
this._画像ファイルパス = 画像ファイルパス;
- this._ユーザ指定サイズdpx = SharpDX.Size2.Empty;
+ this.ユーザ指定サイズdpx = SharpDX.Size2.Empty;
}
public テクスチャ( SharpDX.Size2 サイズdpx, SharpDX.Direct3D11.BindFlags bindFlags = SharpDX.Direct3D11.BindFlags.ShaderResource )
// ↓ どちらかを選択的に指定すること。
this._画像ファイルパス = null;
- this._ユーザ指定サイズdpx = サイズdpx;
+ this.ユーザ指定サイズdpx = サイズdpx;
}
protected override void Onデバイス依存リソースの作成( デバイスリソース dr )
SizeInBytes = SharpDX.Utilities.SizeOf<ST定数バッファの転送元データ>(), // バッファサイズ
StructureByteStride = 0,
};
- this.ConstantBuffer = new SharpDX.Direct3D11.Buffer( d3dDevice, cBufferDesc );
+ this._ConstantBuffer = new SharpDX.Direct3D11.Buffer( d3dDevice, cBufferDesc );
//----------------
#endregion
#region " テクスチャとシェーダーリソースビュー "
if( this._画像ファイルパス.Nullでも空でもない() )
{
// (A) 画像ファイルから生成する場合。
- this.ShaderResourceView = FDK.Utilities.CreateShaderResourceViewFromFile(
+ this._ShaderResourceView = FDK.Utilities.CreateShaderResourceViewFromFile(
d3dDevice,
this._bindFlags,
FDK.フォルダ.絶対パスに含まれるフォルダ変数を展開して返す( this._画像ファイルパス ),
- out this.ShaderResourceViewSize,
+ out this._ShaderResourceViewSize,
out this.Texture );
}
- else if( this._ユーザ指定サイズdpx != SharpDX.Size2.Empty )
+ else if( this.ユーザ指定サイズdpx != SharpDX.Size2.Empty )
{
// (B) サイズを指定して生成する場合。
- this.ShaderResourceView = FDK.Utilities.CreateShaderResourceView(
+ this._ShaderResourceView = FDK.Utilities.CreateShaderResourceView(
d3dDevice,
this._bindFlags,
- this._ユーザ指定サイズdpx,
+ this.ユーザ指定サイズdpx,
out this.Texture );
- this.ShaderResourceViewSize = new SharpDX.Size2F( this._ユーザ指定サイズdpx.Width, this._ユーザ指定サイズdpx.Height );
+ this._ShaderResourceViewSize = new SharpDX.Size2F( this.ユーザ指定サイズdpx.Width, this.ユーザ指定サイズdpx.Height );
}
else
{
protected override void Onデバイス依存リソースの解放( デバイスリソース dr )
{
- FDK.Utilities.解放する( ref this.ShaderResourceView );
+ FDK.Utilities.解放する( ref this._ShaderResourceView );
FDK.Utilities.解放する( ref this.Texture );
- FDK.Utilities.解放する( ref this.ConstantBuffer );
+ FDK.Utilities.解放する( ref this._ConstantBuffer );
}
/// <summary>
// 定数バッファへ書き込む。
var dataBox = d3dContext.MapSubresource(
- resourceRef: this.ConstantBuffer,
+ resourceRef: this._ConstantBuffer,
subresource: 0,
mapType: SharpDX.Direct3D11.MapMode.WriteDiscard,
mapFlags: SharpDX.Direct3D11.MapFlags.None );
SharpDX.Utilities.Write( dataBox.DataPointer, ref this._定数バッファの転送元データ );
- d3dContext.UnmapSubresource( this.ConstantBuffer, 0 );
+ d3dContext.UnmapSubresource( this._ConstantBuffer, 0 );
}
//----------------
#endregion
// 頂点シェーダ
using( var VS = d3dContext.VertexShader )
{
- VS.Set( テクスチャ.VertexShader );
- VS.SetConstantBuffers( 0, this.ConstantBuffer );
+ VS.Set( テクスチャ._VertexShader );
+ VS.SetConstantBuffers( 0, this._ConstantBuffer );
}
// ジオメトリシェーダ
using( var GS = d3dContext.GeometryShader )
using( var RS = d3dContext.Rasterizer )
{
RS.SetViewports( dr.D3DViewPort );
- RS.State = テクスチャ.RasterizerState;
+ RS.State = テクスチャ._RasterizerState;
}
// ピクセルシェーダ
using( var PS = d3dContext.PixelShader )
{
- PS.Set( テクスチャ.PixelShader );
- PS.SetConstantBuffers( 0, this.ConstantBuffer );
- PS.SetShaderResources( 0, 1, this.ShaderResourceView );
- PS.SetSamplers( 0, 1, テクスチャ.SamplerState );
+ PS.Set( テクスチャ._PixelShader );
+ PS.SetConstantBuffers( 0, this._ConstantBuffer );
+ PS.SetShaderResources( 0, 1, this._ShaderResourceView );
+ PS.SetSamplers( 0, 1, テクスチャ._SamplerState );
}
// 出力マージャ
using( var OM = d3dContext.OutputMerger )
{
OM.SetTargets( dr.D3DDepthStencilView, dr.D3DRenderTargetView );
OM.SetBlendState(
- ( this.加算合成する ) ? テクスチャ.BlendState加算合成 : テクスチャ.BlendState通常合成,
+ ( this.加算合成する ) ? テクスチャ._BlendState加算合成 : テクスチャ._BlendState通常合成,
new SharpDX.Mathematics.Interop.RawColor4( 0f, 0f, 0f, 0f ),
-1 );
OM.SetDepthStencilState( dr.D3DDepthStencilState, 0 );
}
}
- protected SharpDX.Direct3D11.Buffer ConstantBuffer = null;
+ protected SharpDX.Size2 ユーザ指定サイズdpx;
protected SharpDX.Direct3D11.Texture2D Texture = null;
- protected SharpDX.Direct3D11.ShaderResourceView ShaderResourceView = null;
- protected SharpDX.Size2F ShaderResourceViewSize;
- protected SharpDX.Direct3D11.BindFlags _bindFlags;
- protected string _画像ファイルパス = null;
- protected SharpDX.Size2 _ユーザ指定サイズdpx;
- protected struct ST定数バッファの転送元データ
+
+ private string _画像ファイルパス = null;
+ private SharpDX.Direct3D11.Buffer _ConstantBuffer = null;
+ private SharpDX.Direct3D11.ShaderResourceView _ShaderResourceView = null;
+ private SharpDX.Size2F _ShaderResourceViewSize;
+ private SharpDX.Direct3D11.BindFlags _bindFlags;
+ private struct ST定数バッファの転送元データ
{
public SharpDX.Matrix World; // ワールド変換行列
public SharpDX.Matrix View; // ビュー変換行列
public float dummy2; // float4境界に合わせるためのダミー
public float dummy3; // float4境界に合わせるためのダミー
};
- protected ST定数バッファの転送元データ _定数バッファの転送元データ;
+ private ST定数バッファの転送元データ _定数バッファの転送元データ;
// (2) 全インスタンス共通項目(static)
"VS", "vs_4_0", シェーダコンパイルのオプション ) )
{
// 頂点シェーダを生成する。
- テクスチャ.VertexShader = new SharpDX.Direct3D11.VertexShader( d3dDevice, code );
+ テクスチャ._VertexShader = new SharpDX.Direct3D11.VertexShader( d3dDevice, code );
}
//----------------
#endregion
"PS", "ps_4_0", シェーダコンパイルのオプション ) )
{
// ピクセルシェーダを作成する。
- テクスチャ.PixelShader = new SharpDX.Direct3D11.PixelShader( d3dDevice, code );
+ テクスチャ._PixelShader = new SharpDX.Direct3D11.PixelShader( d3dDevice, code );
}
//----------------
#endregion
BlendStateNorm.RenderTarget[ 0 ].BlendOperation = SharpDX.Direct3D11.BlendOperation.Add;
// ブレンドステートを作成する。
- テクスチャ.BlendState通常合成 = new SharpDX.Direct3D11.BlendState( d3dDevice, BlendStateNorm );
+ テクスチャ._BlendState通常合成 = new SharpDX.Direct3D11.BlendState( d3dDevice, BlendStateNorm );
//----------------
#endregion
#region " ブレンドステート（加算合成）"
BlendStateAdd.RenderTarget[ 0 ].BlendOperation = SharpDX.Direct3D11.BlendOperation.Add;
// ブレンドステートを作成する。
- テクスチャ.BlendState加算合成 = new SharpDX.Direct3D11.BlendState( d3dDevice, BlendStateNorm );
+ テクスチャ._BlendState加算合成 = new SharpDX.Direct3D11.BlendState( d3dDevice, BlendStateNorm );
//----------------
#endregion
#region " ラスタライザステート "
IsMultisampleEnabled = false,
IsAntialiasedLineEnabled = false,
};
- テクスチャ.RasterizerState = new SharpDX.Direct3D11.RasterizerState( d3dDevice, RSDesc );
+ テクスチャ._RasterizerState = new SharpDX.Direct3D11.RasterizerState( d3dDevice, RSDesc );
//----------------
#endregion
#region " サンプラーステート "
MinimumLod = float.MinValue,
MaximumLod = float.MaxValue,
};
- テクスチャ.SamplerState = new SharpDX.Direct3D11.SamplerState( d3dDevice, descSampler );
+ テクスチャ._SamplerState = new SharpDX.Direct3D11.SamplerState( d3dDevice, descSampler );
//----------------
#endregion
}
public static void 全インスタンスで共有するリソースを解放する()
{
- FDK.Utilities.解放する( ref テクスチャ.SamplerState );
- FDK.Utilities.解放する( ref テクスチャ.RasterizerState );
- FDK.Utilities.解放する( ref テクスチャ.BlendState加算合成 );
- FDK.Utilities.解放する( ref テクスチャ.BlendState通常合成 );
- FDK.Utilities.解放する( ref テクスチャ.PixelShader );
- FDK.Utilities.解放する( ref テクスチャ.VertexShader );
+ FDK.Utilities.解放する( ref テクスチャ._SamplerState );
+ FDK.Utilities.解放する( ref テクスチャ._RasterizerState );
+ FDK.Utilities.解放する( ref テクスチャ._BlendState加算合成 );
+ FDK.Utilities.解放する( ref テクスチャ._BlendState通常合成 );
+ FDK.Utilities.解放する( ref テクスチャ._PixelShader );
+ FDK.Utilities.解放する( ref テクスチャ._VertexShader );
}
- protected static SharpDX.Direct3D11.VertexShader VertexShader = null;
- protected static SharpDX.Direct3D11.PixelShader PixelShader = null;
- protected static SharpDX.Direct3D11.BlendState BlendState通常合成 = null;
- protected static SharpDX.Direct3D11.BlendState BlendState加算合成 = null;
- protected static SharpDX.Direct3D11.RasterizerState RasterizerState = null;
- protected static SharpDX.Direct3D11.SamplerState SamplerState = null;
+ private static SharpDX.Direct3D11.VertexShader _VertexShader = null;
+ private static SharpDX.Direct3D11.PixelShader _PixelShader = null;
+ private static SharpDX.Direct3D11.BlendState _BlendState通常合成 = null;
+ private static SharpDX.Direct3D11.BlendState _BlendState加算合成 = null;
+ private static SharpDX.Direct3D11.RasterizerState _RasterizerState = null;
+ private static SharpDX.Direct3D11.SamplerState _SamplerState = null;
}
}
}
}
- protected FDK.メディア.テクスチャ _文字盤 = null;
- protected FDK.メディア.矩形リスト _文字矩形リスト = null;
+ private FDK.メディア.テクスチャ _文字盤 = null;
+ private FDK.メディア.矩形リスト _文字矩形リスト = null;
}
}
PixelFormat = new SharpDX.Direct2D1.PixelFormat( dxgiSurface.Description.Format, SharpDX.Direct2D1.AlphaMode.Premultiplied ),
BitmapOptions = SharpDX.Direct2D1.BitmapOptions.Target | SharpDX.Direct2D1.BitmapOptions.CannotDraw,
};
- this.BitmapTarget = new SharpDX.Direct2D1.Bitmap1( dr.D2DContext1, dxgiSurface, bmpProp );
+ this._BitmapTarget = new SharpDX.Direct2D1.Bitmap1( dr.D2DContext1, dxgiSurface, bmpProp );
}
}
protected override void Onデバイス依存リソースの解放( デバイスリソース dr )
{
// ビットマップターゲットを解放する。
- FDK.Utilities.解放する( ref this.BitmapTarget );
+ FDK.Utilities.解放する( ref this._BitmapTarget );
// テクスチャを解放する。
base.Onデバイス依存リソースの解放( dr );
try
{
dr.D2DContextの設定をリセットする( dr.D2DContext1 );
- dr.D2DContext1.Target = this.BitmapTarget;
+ dr.D2DContext1.Target = this._BitmapTarget;
FDK.Utilities.D2DBatchDraw( dr.D2DContext1, () => {
- 描画アクション( dr.D2DContext1, this.BitmapTarget );
+ 描画アクション( dr.D2DContext1, this._BitmapTarget );
} );
}
finally
}
}
- protected SharpDX.Direct2D1.Bitmap1 BitmapTarget = null;
+ private SharpDX.Direct2D1.Bitmap1 _BitmapTarget = null;
}
}
public 動画( string 動画ファイルパス, int キューのサイズ = 16 )
{
this.動画ファイルパス = FDK.フォルダ.絶対パスに含まれるフォルダ変数を展開して返す( 動画ファイルパス );
- this.キューのサイズ = キューのサイズ;
+ this._キューのサイズ = キューのサイズ;
}
public void 再生を開始する( double 開始位置sec = 0.0, bool ループ再生する = false )
{
- this.ループ再生する = ループ再生する;
+ this._ループ再生する = ループ再生する;
// タスクを起動する。
- this.デコードタスク = System.Threading.Tasks.Task.Factory.StartNew( this._デコードタスクエントリ, (object) 開始位置sec );
- this.デコードタスク起動完了.WaitOne();
+ this._デコードタスク = System.Threading.Tasks.Task.Factory.StartNew( this._デコードタスクエントリ, (object) 開始位置sec );
+ this._デコードタスク起動完了.WaitOne();
}
public void 進行描画する( デバイスリソース dr, SharpDX.RectangleF 描画先矩形dpx, float 不透明度0to1 = 1.0f )
{
#region " 条件チェック。"
//----------------
- if( null == this.デコードタスク || // 再生をまだ開始していないか、あるいはすでに再生を完了してデコードタスクを終了済みである。
- null == this.SourceReaderEx || // 動画の準備に失敗した。
- null == this.MediaType || // 同上
- null == this.WicBitmap ) // 同上
+ if( null == this._デコードタスク || // 再生をまだ開始していないか、あるいはすでに再生を完了してデコードタスクを終了済みである。
+ null == this._SourceReaderEx || // 動画の準備に失敗した。
+ null == this._MediaType || // 同上
+ null == this._WicBitmap ) // 同上
{
return;
}
Action<FrameQueueItem> 次のフレームを表示する = ( frame ) => {
this._次のフレームを取り出す( out frame );
- this.最後に表示したフレーム?.Dispose();
- this.最後に表示したフレーム = frame;
+ this._最後に表示したフレーム?.Dispose();
+ this._最後に表示したフレーム = frame;
this._D2DBitmapを描画する( dr, 変換行列, frame.D2DBitmap, 不透明度0to1 );
};
Action 前のフレームを表示する = () => {
- this._D2DBitmapを描画する( dr, 変換行列, this.最後に表示したフレーム?.D2DBitmap, 不透明度0to1 );
+ this._D2DBitmapを描画する( dr, 変換行列, this._最後に表示したフレーム?.D2DBitmap, 不透明度0to1 );
};
var フレーム = (FrameQueueItem) null;
if( null != フレーム ) // 次のフレームがある。
{
// (A) 次のフレームが前のフレームより過去 → ループしたので、タイマをリセットする。
- if( ( null != this.最後に表示したフレーム ) &&
- ( フレーム.表示時刻sec < this.最後に表示したフレーム.表示時刻sec ) )
+ if( ( null != this._最後に表示したフレーム ) &&
+ ( フレーム.表示時刻sec < this._最後に表示したフレーム.表示時刻sec ) )
{
this._再生タイマ.Value.リセットする( FDK.カウンタ.QPCTimer.秒をカウントに変換して返す( フレーム.表示時刻sec ) );
次のフレームを表示する( フレーム );
}
}
- protected int キューのサイズ = 0;
-
- protected class FrameQueueItem : IDisposable
- {
- public double 表示時刻sec = 0;
- public SharpDX.Direct2D1.Bitmap D2DBitmap = null;
-
- public void Dispose()
- {
- FDK.Utilities.解放する( ref this.D2DBitmap );
- }
- }
- protected ConcurrentQueue<FrameQueueItem> フレームキュー = null;
- protected bool ループ再生する = false;
- protected System.Threading.Tasks.Task デコードタスク = null;
- protected System.Threading.AutoResetEvent デコードタスク起動完了 = null;
- protected System.Threading.ManualResetEvent キューが空いた = null;
- protected System.Threading.AutoResetEvent デコードタスクを終了せよ = null;
- protected SharpDX.MediaFoundation.SourceReaderEx SourceReaderEx = null;
- protected SharpDX.MediaFoundation.MediaType MediaType = null;
- protected SharpDX.WIC.Bitmap WicBitmap = null; // MediaFoundation は WICBitmap に出力する。
- protected SharpDX.Direct2D1.DeviceContext1 デコードタスク用D2DDeviceContext参照 = null; // D2Dはスレッドセーフであること。
- protected FrameQueueItem 最後に表示したフレーム = null;
-
protected override void On活性化( デバイスリソース dr )
{
- this.デコードタスク = null; // タスクが起動していないときは null であることを保証する。
- this.デコードタスク起動完了 = new System.Threading.AutoResetEvent( false );
- this.キューが空いた = new System.Threading.ManualResetEvent( true );
- this.デコードタスクを終了せよ = new System.Threading.AutoResetEvent( false );
+ this._デコードタスク = null; // タスクが起動していないときは null であることを保証する。
+ this._デコードタスク起動完了 = new System.Threading.AutoResetEvent( false );
+ this._キューが空いた = new System.Threading.ManualResetEvent( true );
+ this._デコードタスクを終了せよ = new System.Threading.AutoResetEvent( false );
this._再生タイマ.Value = new カウンタ.QPCTimer();
}
protected override void On非活性化( デバイスリソース dr )
{
- this.キューが空いた.Close();
- this.デコードタスクを終了せよ.Close();
+ this._キューが空いた.Close();
+ this._デコードタスクを終了せよ.Close();
}
protected override void Onデバイス依存リソースの作成( デバイスリソース dr )
FDK.Log.BeginInfo( $"{FDK.Utilities.現在のメソッド名}" );
try
{
- this.デコードタスク用D2DDeviceContext参照 = dr.D2DContext1;
- this.フレームキュー = new ConcurrentQueue<FrameQueueItem>();
- this.最後に表示したフレーム = null;
+ this._デコードタスク用D2DDeviceContext参照 = dr.D2DContext1;
+ this._フレームキュー = new ConcurrentQueue<FrameQueueItem>();
+ this._最後に表示したフレーム = null;
// 動画ファイルから、SourceReaderEx, MediaType, WicBitmap を生成する。
// 属性を使って、SourceReaderEx を生成。
using( var sourceReader = new SharpDX.MediaFoundation.SourceReader( 動画ファイルパス, 属性 ) ) // パスは URI 扱い
{
- this.SourceReaderEx = sourceReader.QueryInterface<SharpDX.MediaFoundation.SourceReaderEx>();
+ this._SourceReaderEx = sourceReader.QueryInterface<SharpDX.MediaFoundation.SourceReaderEx>();
}
}
}
//-----------------
try
{
- this.SourceReaderEx.SetStreamSelection( SharpDX.MediaFoundation.SourceReaderIndex.AllStreams, false );
- this.SourceReaderEx.SetStreamSelection( SharpDX.MediaFoundation.SourceReaderIndex.FirstVideoStream, true );
+ this._SourceReaderEx.SetStreamSelection( SharpDX.MediaFoundation.SourceReaderIndex.AllStreams, false );
+ this._SourceReaderEx.SetStreamSelection( SharpDX.MediaFoundation.SourceReaderIndex.FirstVideoStream, true );
}
catch( SharpDX.SharpDXException e )
{
mediaType.Set<Guid>( SharpDX.MediaFoundation.MediaTypeAttributeKeys.Subtype, SharpDX.MediaFoundation.VideoFormatGuids.Argb32 );
// 部分メディアタイプを SourceReaderEx にセットする。SourceReaderEx は、必要なデコーダをロードするだろう。
- this.SourceReaderEx.SetCurrentMediaType( SharpDX.MediaFoundation.SourceReaderIndex.FirstVideoStream, mediaType );
+ this._SourceReaderEx.SetCurrentMediaType( SharpDX.MediaFoundation.SourceReaderIndex.FirstVideoStream, mediaType );
}
}
catch( SharpDX.SharpDXException e )
//-----------------
try
{
- this.SourceReaderEx.SetStreamSelection( SharpDX.MediaFoundation.SourceReaderIndex.FirstVideoStream, true );
+ this._SourceReaderEx.SetStreamSelection( SharpDX.MediaFoundation.SourceReaderIndex.FirstVideoStream, true );
}
catch( SharpDX.SharpDXException e )
{
//-----------------
try
{
- this.MediaType = this.SourceReaderEx.GetCurrentMediaType( SharpDX.MediaFoundation.SourceReaderIndex.FirstVideoStream );
+ this._MediaType = this._SourceReaderEx.GetCurrentMediaType( SharpDX.MediaFoundation.SourceReaderIndex.FirstVideoStream );
}
catch( SharpDX.SharpDXException e )
{
try
{
// 動画の途中でのサイズ変更には対応しない。
- var packedFrameSize = this.MediaType.Get<long>( SharpDX.MediaFoundation.MediaTypeAttributeKeys.FrameSize );
+ var packedFrameSize = this._MediaType.Get<long>( SharpDX.MediaFoundation.MediaTypeAttributeKeys.FrameSize );
this.サイズdpx = new SharpDX.Size2F( ( packedFrameSize >> 32 ) & 0xFFFFFFFF, ( packedFrameSize ) & 0xFFFFFFFF );
}
catch( SharpDX.SharpDXException e )
// 動画の長さを取得する。
try
{
- this.長さsec = this.SourceReaderEx.GetPresentationAttribute(
+ this.長さsec = this._SourceReaderEx.GetPresentationAttribute(
SharpDX.MediaFoundation.SourceReaderIndex.MediaSource,
SharpDX.MediaFoundation.PresentationDescriptionAttributeKeys.Duration
) / ( 1000.0 * 1000.0 * 10.0 );
//-----------------
try
{
- this.WicBitmap = new SharpDX.WIC.Bitmap(
+ this._WicBitmap = new SharpDX.WIC.Bitmap(
dr.WicImagingFactory2,
(int) this.サイズdpx.Width,
(int) this.サイズdpx.Height,
#region " デコードタスクが起動していたら、終了する。"
//----------------
- this.デコードタスクを終了せよ.Set();
+ this._デコードタスクを終了せよ.Set();
- if( !this.デコードタスク.Wait( 2000 ) )
+ if( !this._デコードタスク.Wait( 2000 ) )
FDK.Log.WARNING( "デコードタスクの終了待ちがタイムアウトしました。" );
- this.デコードタスク = null;
+ this._デコードタスク = null;
//----------------
#endregion
- FDK.Utilities.解放する( ref this.最後に表示したフレーム );
- FDK.Utilities.解放する( ref this.WicBitmap );
- FDK.Utilities.解放する( ref this.MediaType );
- FDK.Utilities.解放する( ref this.SourceReaderEx );
+ FDK.Utilities.解放する( ref this._最後に表示したフレーム );
+ FDK.Utilities.解放する( ref this._WicBitmap );
+ FDK.Utilities.解放する( ref this._MediaType );
+ FDK.Utilities.解放する( ref this._SourceReaderEx );
this._キューをクリアする();
- this.フレームキュー = null;
- this.デコードタスク用D2DDeviceContext参照 = null;
+ this._フレームキュー = null;
+ this._デコードタスク用D2DDeviceContext参照 = null;
FDK.Log.EndInfo( $"{FDK.Utilities.現在のメソッド名}" );
}
+ private int _キューのサイズ = 0;
+ private class FrameQueueItem : IDisposable
+ {
+ public double 表示時刻sec = 0;
+ public SharpDX.Direct2D1.Bitmap D2DBitmap = null;
+
+ public void Dispose()
+ {
+ FDK.Utilities.解放する( ref this.D2DBitmap );
+ }
+ }
+ private ConcurrentQueue<FrameQueueItem> _フレームキュー = null;
+ private FrameQueueItem _最後に表示したフレーム = null;
+ private bool _ループ再生する = false;
+ private System.Threading.Tasks.Task _デコードタスク = null;
+ private System.Threading.AutoResetEvent _デコードタスク起動完了 = null;
+ private System.Threading.ManualResetEvent _キューが空いた = null;
+ private System.Threading.AutoResetEvent _デコードタスクを終了せよ = null;
+ private SharpDX.MediaFoundation.SourceReaderEx _SourceReaderEx = null;
+ private SharpDX.MediaFoundation.MediaType _MediaType = null;
+ private SharpDX.WIC.Bitmap _WicBitmap = null; // MediaFoundation は WICBitmap に出力する。
+ private SharpDX.Direct2D1.DeviceContext1 _デコードタスク用D2DDeviceContext参照 = null; // D2Dはスレッドセーフであること。
+
private void _キューをクリアする()
{
- while( 0 < this.フレームキュー.Count )
+ while( 0 < this._フレームキュー.Count )
{
var item = (FrameQueueItem) null;
- if( this.フレームキュー.TryDequeue( out item ) )
+ if( this._フレームキュー.TryDequeue( out item ) )
item.Dispose();
}
- this.キューが空いた?.Set();
+ this._キューが空いた?.Set();
}
private void _次のフレームを確認する( out FrameQueueItem フレーム )
{
- if( ( 0 == this.フレームキュー.Count ) ||
- ( false == this.フレームキュー.TryPeek( out フレーム ) ) ) // キューから取り出さない
+ if( ( 0 == this._フレームキュー.Count ) ||
+ ( false == this._フレームキュー.TryPeek( out フレーム ) ) ) // キューから取り出さない
{
フレーム = null; // キューが空だったか、Peek が一歩遅かった？（ないはずだが
}
private void _次のフレームを取り出す( out FrameQueueItem フレーム )
{
- if( ( 0 == this.フレームキュー.Count ) ||
- ( false == this.フレームキュー.TryDequeue( out フレーム ) ) ) // キューから取り出す
+ if( ( 0 == this._フレームキュー.Count ) ||
+ ( false == this._フレームキュー.TryDequeue( out フレーム ) ) ) // キューから取り出す
{
フレーム = null; // キューが空だったか、Peek が一歩遅かった？（ないはずだが
}
else
{
- this.キューが空いた.Set();
+ this._キューが空いた.Set();
}
}
const int EVID_キューが空いた = 0;
const int EVID_デコードタスクを終了せよ = 1;
var events = new System.Threading.WaitHandle[ 2 ];
- events[ EVID_キューが空いた ] = this.キューが空いた;
- events[ EVID_デコードタスクを終了せよ ] = this.デコードタスクを終了せよ;
+ events[ EVID_キューが空いた ] = this._キューが空いた;
+ events[ EVID_デコードタスクを終了せよ ] = this._デコードタスクを終了せよ;
- this.デコードタスク起動完了.Set();
+ this._デコードタスク起動完了.Set();
this._再生タイマ.Value.リセットする( FDK.カウンタ.QPCTimer.秒をカウントに変換して返す( 再生開始位置sec ) );
if( this._サンプルをひとつデコードしてフレームをキューへ格納する() )
{
// キューがいっぱいになったら、空くまで待つ。
- if( キューのサイズ == this.フレームキュー.Count )
+ if( _キューのサイズ == this._フレームキュー.Count )
{
- this.キューが空いた.Reset(); // 次の while で空くのを待つ。
+ this._キューが空いた.Reset(); // 次の while で空くのを待つ。
}
}
else
}
}
- this.デコードタスク = null;
+ this._デコードタスク = null;
FDK.Log.Info( "デコードタスクを終了しました。" );
}
var ストリームフラグ = SharpDX.MediaFoundation.SourceReaderFlags.None;
int 実ストリーム番号 = 0;
- sample = this.SourceReaderEx.ReadSample(
+ sample = this._SourceReaderEx.ReadSample(
SharpDX.MediaFoundation.SourceReaderIndex.FirstVideoStream,
SharpDX.MediaFoundation.SourceReaderControlFlags.None,
out 実ストリーム番号,
{
#region " ストリーム終了 "
//----------------
- if( this.ループ再生する )
+ if( this._ループ再生する )
{
FDK.Log.Info( "動画をループ再生します。" );
- this.SourceReaderEx.SetCurrentPosition( 0 );
+ this._SourceReaderEx.SetCurrentPosition( 0 );
return this._サンプルをひとつデコードしてフレームをキューへ格納する();
}
else
this._サンプルをビットマップに転送する( sample, out bitmap );
- this.フレームキュー.Enqueue( new FrameQueueItem() {
+ this._フレームキュー.Enqueue( new FrameQueueItem() {
D2DBitmap = bitmap,
表示時刻sec = サンプルの表示時刻100ns / ( 10.0 * 1000.0 * 1000.0 ),
} );
{
#region " ストリームがシーク不可なら何もしない。"
//----------------
- var flags = this.SourceReaderEx.GetPresentationAttribute(
+ var flags = this._SourceReaderEx.GetPresentationAttribute(
SharpDX.MediaFoundation.SourceReaderIndex.MediaSource,
SharpDX.MediaFoundation.SourceReaderAttributeKeys.MediaSourceCharacteristics );
if( ( flags & (int) SharpDX.MediaFoundation.MediaSourceCharacteristics.CanSeek ) == 0 )
this._キューをクリアする();
long 再生位置100ns = (long) ( 再生位置sec * 1000.0 * 1000.0 * 10.0 );
- this.SourceReaderEx.SetCurrentPosition( 再生位置100ns );
+ this._SourceReaderEx.SetCurrentPosition( 再生位置100ns );
// キーフレームから再生位置100nsまで ReadSample する。
while( サンプルの表示時刻100ns < 再生位置100ns )
{
// サンプルを取得。
- var sample = this.SourceReaderEx.ReadSample(
+ var sample = this._SourceReaderEx.ReadSample(
SharpDX.MediaFoundation.SourceReaderIndex.FirstVideoStream,
SharpDX.MediaFoundation.SourceReaderControlFlags.None,
out 実ストリーム番号,
private void _ストックする()
{
- for( int i = 0; i < this.キューのサイズ; i++ )
+ for( int i = 0; i < this._キューのサイズ; i++ )
this._サンプルをひとつデコードしてフレームをキューへ格納する();
- this.キューが空いた.Reset(); // 埋まった
+ this._キューが空いた.Reset(); // 埋まった
}
private unsafe void _サンプルをビットマップに転送する( SharpDX.MediaFoundation.Sample Sample, out SharpDX.Direct2D1.Bitmap D2DBitmap )
try
{
// 描画先である WICBitmap をロックする。
- using( var bitmapLock = this.WicBitmap.Lock(
- new SharpDX.Rectangle( 0, 0, this.WicBitmap.Size.Width, this.WicBitmap.Size.Height ),
+ using( var bitmapLock = this._WicBitmap.Lock(
+ new SharpDX.Rectangle( 0, 0, this._WicBitmap.Size.Width, this._WicBitmap.Size.Height ),
SharpDX.WIC.BitmapLockFlags.Write ) )
{
// サンプルバッファからWICビットマップへ、ARGB32 を G8B8R8X8 に変換しながらコピーする。
//----------------
try
{
- D2DBitmap = SharpDX.Direct2D1.Bitmap.FromWicBitmap( this.デコードタスク用D2DDeviceContext参照, this.WicBitmap );
+ D2DBitmap = SharpDX.Direct2D1.Bitmap.FromWicBitmap( this._デコードタスク用D2DDeviceContext参照, this._WicBitmap );
}
catch( SharpDX.SharpDXException e )
{
public 画像フォント( string 文字盤の画像ファイルパス, FDK.メディア.矩形リスト 文字矩形リスト )
{
- this.子リスト.Add( this.文字盤 = new 画像( 文字盤の画像ファイルパス ) );
- this.文字矩形リスト = 文字矩形リスト;
+ this.子リスト.Add( this._文字盤 = new 画像( 文字盤の画像ファイルパス ) );
+ this._文字矩形リスト = 文字矩形リスト;
}
public void 描画する( デバイスリソース dr, float 左位置dpx, float 上位置dpx, string 表示文字列 )
// 有効文字（矩形リストに登録されている文字）の矩形、文字数を抽出し、文字列全体のサイズを計算する。
var 有効文字矩形s =
from 文字 in 表示文字列
- where ( this.文字矩形リスト.文字列to矩形.ContainsKey( new string( new char[] { 文字 } ) ) )
- select this.文字矩形リスト.文字列to矩形[ new string( new char[] { 文字 } ) ];
+ where ( this._文字矩形リスト.文字列to矩形.ContainsKey( new string( new char[] { 文字 } ) ) )
+ select this._文字矩形リスト.文字列to矩形[ new string( new char[] { 文字 } ) ];
int 有効文字数 = 有効文字矩形s.Count();
if( 0 == 有効文字数 )
for( int i = 0; i < 有効文字数; i++ )
{
var 文字矩形 = 有効文字矩形s.ElementAt( i );
- this.文字盤.描画する( dr, 左位置dpx, 上位置dpx, 転送元矩形dpx: 文字矩形 );
+ this._文字盤.描画する( dr, 左位置dpx, 上位置dpx, 転送元矩形dpx: 文字矩形 );
左位置dpx += 文字矩形.Width;
}
}
- protected FDK.メディア.画像 文字盤 = null;
- protected FDK.メディア.矩形リスト 文字矩形リスト = null;
+ private FDK.メディア.画像 _文字盤 = null;
+ private FDK.メディア.矩形リスト _文字矩形リスト = null;
}
}
}
}
- private FDK.メディア.画像 _背景画像;
+ private FDK.メディア.画像 _背景画像 = null;
}
}
}
private List<FDK.メディア.文字列画像> _ユーザパネル = null;
- private readonly FDK.メディア.文字列画像 _ログイン画面見出し;
+ private FDK.メディア.文字列画像 _ログイン画面見出し = null;
}
}
namespace SST.ステージ.演奏
{
/// <summary>
- /// この名前空間で使用するXML用の各種文字列定数。nameof() と一緒に使う。
+ /// この名前空間で使用するXML用の各種文字列定数。nameof() と一緒に使う。
/// </summary>
enum XML
{
private EMode _現在のモード;
private int _前回のCOMBO値 = 0;
- private long _コンボが切れた時刻;
- private int _コンボが切れたときのCOMBO値;
- private readonly コンボジャンプ _単位付き数値;
- private readonly ReaderWriterLockSlim スレッド間同期 = null;
+ private long _コンボが切れた時刻 = FDK.カウンタ.QPCTimer.未使用;
+ private int _コンボが切れたときのCOMBO値 = 0;
+ private コンボジャンプ _単位付き数値 = null;
+ private ReaderWriterLockSlim スレッド間同期 = null;
}
}
this.数値 = new FDK.同期.RWLock<int>( this._スレッド間同期, 0 );
this.表示する = new FDK.同期.RWLock<bool>( this._スレッド間同期, true );
- this.子リスト.Add( this.数値と単位の画像 = new 画像( @"$(Static)\images\combo.png" ) );
+ this.子リスト.Add( this._数値と単位の画像 = new 画像( @"$(Static)\images\combo.png" ) );
// 180度分のジャンプY座標差分を算出。(i:{0 → 90 → 179} で、[i]:{0 → -15 → 0})
for( int i = 0; i < 180; i++ )
protected override void On活性化( デバイスリソース dr )
{
this.数値.Value = 0;
- this.現在の数値 = 0;
+ this._現在の数値 = 0;
this._ジャンプインデックス値 = 99999;
this._ジャンプインデックス進行 = new FDK.カウンタ.定間隔進行();
}
#endregion
#region " 数値が増加していればジャンプを開始する。"
//-----------------
- if( this.数値.Value > this.現在の数値 )
+ if( this.数値.Value > this._現在の数値 )
{
this._ジャンプインデックス値 = 0;
this._ジャンプインデックス進行 = new FDK.カウンタ.定間隔進行();
//-----------------
#endregion
- this.現在の数値 = this.数値.Value;
+ this._現在の数値 = this.数値.Value;
// 描画。
#region " 現在の数値 の桁を 逆順に 位の数[] に格納する。（例：現在の数値=125 のとき 位の数 = { 5,2,1,0,0,0,0,0,0,0 }, 桁数 = 3 ） "
//-----------------
- int n = this.現在の数値;
+ int n = this._現在の数値;
while( ( 0 < n ) && ( 10 > 桁数 ) )
{
位の数[ 桁数 ] = n % 10; // 1の位を格納
#endregion
#region " 単位文字の矩形(COMBO矩形) と 数字と単位を合わせた画像の全幅dpx を算出。"
//-----------------
- var COMBO矩形 = this.文字矩形dpx[ 10 ];
- float 数字と単位を合わせた画像の全幅dpx = this.文字矩形dpx[ 10 ].Width;
+ var COMBO矩形 = this._文字矩形dpx[ 10 ];
+ float 数字と単位を合わせた画像の全幅dpx = this._文字矩形dpx[ 10 ].Width;
for( int i = 0; i < 桁数; i++ )
- 数字と単位を合わせた画像の全幅dpx += this.文字矩形dpx[ 位の数[ i ] ].Width;
+ 数字と単位を合わせた画像の全幅dpx += this._文字矩形dpx[ 位の数[ i ] ].Width;
//-----------------
#endregion
#region " 位の数[] を、COMBO文字→ 1の位 → 10の位 … の順に、右から左へ向かって順番に表示する。"
// "COMBO" を表示。
x -= COMBO矩形.Width;
- this.数値と単位の画像.描画する( dr, x, ( 下辺Ydpx - COMBO矩形.Height ), _不透明度0to1, 転送元矩形dpx: COMBO矩形 );
+ this._数値と単位の画像.描画する( dr, x, ( 下辺Ydpx - COMBO矩形.Height ), _不透明度0to1, 転送元矩形dpx: COMBO矩形 );
// 数値を1の位から順に表示。
for( int i = 0; i < 桁数; i++ )
{
- var rc = this.文字矩形dpx[ 位の数[ i ] ];
+ var rc = this._文字矩形dpx[ 位の数[ i ] ];
x -= rc.Width + 文字間隔dpx;
y = 下辺Ydpx - rc.Height;
if( ( 0 <= jump ) && ( 180 > jump ) )
y += this._ジャンプ差分値[ jump ];
- this.数値と単位の画像.描画する( dr, x, y, _不透明度0to1, 転送元矩形dpx: rc );
+ this._数値と単位の画像.描画する( dr, x, y, _不透明度0to1, 転送元矩形dpx: rc );
}
//-----------------
#endregion
}
}
- protected int 現在の数値 = -1;
- protected readonly FDK.メディア.画像 数値と単位の画像;
- protected readonly List<SharpDX.RectangleF> 文字矩形dpx = new List<SharpDX.RectangleF>() {
+ private int _現在の数値 = -1;
+ private FDK.メディア.画像 _数値と単位の画像 = null;
+ private readonly List<SharpDX.RectangleF> _文字矩形dpx = new List<SharpDX.RectangleF>() {
#region " [0]～[9]: '0'～'9', [10]:'COMBO' "
//----------------
new SharpDX.RectangleF( 0, 0, 45, 70 ),
//----------------
#endregion
};
-
private const int _桁ごとのジャンプの遅れ = 50; // 1桁につき 50 インデックス遅れる
private const float _不透明度0to1 = 0.7f;
private int _ジャンプインデックス値 = 9999;
private int[] _ジャンプ差分値 = new int[ 180 ];
private FDK.カウンタ.定間隔進行 _ジャンプインデックス進行 = null;
- private readonly System.Threading.ReaderWriterLockSlim _スレッド間同期 = null;
+ private System.Threading.ReaderWriterLockSlim _スレッド間同期 = null;
}
}
public スクロール譜面()
{
- this.子リスト.Add( this.チップ画像 = new 画像( @"$(Static)\images\Chips.png" ) );
+ this.子リスト.Add( this._チップ画像 = new 画像( @"$(Static)\images\Chips.png" ) );
}
protected override void On活性化( デバイスリソース dr )
{
- this.描画開始チップ番号 = -1;
- this.チップ画像の矩形リスト = new FDK.メディア.矩形リスト( @"$(Static)\images\Chips Rectangle List.xml" ); // ここで読み込む → 変更があったら反映される（デバッグ用途）。
+ this._描画開始チップ番号 = -1;
+ this._チップ画像の矩形リスト = new FDK.メディア.矩形リスト( @"$(Static)\images\Chips Rectangle List.xml" ); // ここで読み込む → 変更があったら反映される（デバッグ用途）。
var ユーザ = StrokeStyleT.ユーザ管理.現在選択されているユーザ;
- this.ヒット判定を行うチップと対応するレーン = new Dictionary<SSTFormat.チップ種別, ヒットレーン種別>() {
+ this._ヒット判定を行うチップと対応するレーン = new Dictionary<SSTFormat.チップ種別, ヒットレーン種別>() {
{ SSTFormat.チップ種別.LeftCrash, ヒットレーン種別.LeftCrash },
{ SSTFormat.チップ種別.Ride, ( ユーザ.Rideは左 ) ? ヒットレーン種別.LeftCrash : ヒットレーン種別.RightCrash },
{ SSTFormat.チップ種別.Ride_Cup, ( ユーザ.Rideは左 ) ? ヒットレーン種別.LeftCrash : ヒットレーン種別.RightCrash },
{ SSTFormat.チップ種別.Tom3_Rim, ヒットレーン種別.Tom2 },
{ SSTFormat.チップ種別.RightCrash, ヒットレーン種別.RightCrash },
};
- this.活性化した直後である = true;
+ this._活性化した直後である = true;
}
protected override void On非活性化( デバイスリソース dr )
}
else
{
- this.描画開始チップ番号 = i;
+ this._描画開始チップ番号 = i;
演奏開始時刻sec = スコア.チップリスト[ i ].発声時刻sec;
#region " 演奏開始時刻sec を少し早めに設定する。"
public void 演奏を停止する()
{
- this.描画開始チップ番号 = -1;
+ this._描画開始チップ番号 = -1;
}
public void 小節線拍線を進行描画する( デバイスリソース dr, double 現在の演奏時刻sec )
現在の演奏時刻sec );
}
-
- protected bool 活性化した直後である = false;
-
+ private bool _活性化した直後である = false;
/// <summary>
/// 演奏スコア.チップリスト[] のうち、描画を始めるチップのインデックス番号を示す。
/// 演奏開始直後は 0 で始まり、対象番号のチップが描画範囲を流れ去るたびに +1 される。
/// 未演奏時・演奏終了時は -1 。
/// </summary>
- protected int 描画開始チップ番号 = -1;
-
- protected readonly FDK.メディア.画像 チップ画像;
-
- protected FDK.メディア.矩形リスト チップ画像の矩形リスト = null;
-
- protected Dictionary<SSTFormat.チップ種別, ヒットレーン種別> ヒット判定を行うチップと対応するレーン = null;
- protected readonly FDK.カウンタ.単純増加後反復カウンタ チップアニメ = new FDK.カウンタ.単純増加後反復カウンタ();
- protected readonly Dictionary<SSTFormat.レーン種別, float> レーン種別toレーンフレーム左端からの相対X位置dpx = new Dictionary<SSTFormat.レーン種別, float>() {
+ private int _描画開始チップ番号 = -1;
+ private FDK.メディア.画像 _チップ画像 = null;
+ private FDK.メディア.矩形リスト _チップ画像の矩形リスト = null;
+ private Dictionary<SSTFormat.チップ種別, ヒットレーン種別> _ヒット判定を行うチップと対応するレーン = null;
+ private FDK.カウンタ.単純増加後反復カウンタ _チップアニメ = new FDK.カウンタ.単純増加後反復カウンタ();
+ private readonly Dictionary<SSTFormat.レーン種別, float> _レーン種別toレーンフレーム左端からの相対X位置dpx = new Dictionary<SSTFormat.レーン種別, float>() {
{ SSTFormat.レーン種別.LeftCrash, +36f },
{ SSTFormat.レーン種別.HiHat, +105f },
{ SSTFormat.レーン種別.Foot, +145f },
{ SSTFormat.レーン種別.Tom3, +544f },
{ SSTFormat.レーン種別.RightCrash, +632f },
};
-
private float _画面の高さdpx = 0f; // 進行スレッドからはデバイスリソースを参照しないので、ここにキャッシュしておく。
private FDK.同期.TriStateEvent _高頻度進行タスクへのイベント = null;
private readonly object _スレッド間同期 = new object();
#region " 最初の進行描画。"
//----------------
- if( this.活性化した直後である )
+ if( this._活性化した直後である )
{
- this.活性化した直後である = false;
- this.描画開始チップ番号 = 0; // -1 → 0; 演奏開始。
- this.チップアニメ.開始する( 最初の値: 0, 最後の値: 48, 値をひとつ増加させるのにかける時間ms: 10 );
+ this._活性化した直後である = false;
+ this._描画開始チップ番号 = 0; // -1 → 0; 演奏開始。
+ this._チップアニメ.開始する( 最初の値: 0, 最後の値: 48, 値をひとつ増加させるのにかける時間ms: 10 );
this._高頻度進行タスクへのイベント = new FDK.同期.TriStateEvent( FDK.同期.TriStateEvent.状態種別.ON );
//----------------
#endregion
- for( int i = this.描画開始チップ番号; ( 0 <= i ) && ( 演奏スコア.チップリスト.Count > i ); i++ )
+ for( int i = this._描画開始チップ番号; ( 0 <= i ) && ( 演奏スコア.チップリスト.Count > i ); i++ )
{
var チップ = 演奏スコア.チップリスト[ i ];
#region " チップが描画開始チップであり、かつ、そのY座標が画面下端を超えたなら、描画開始チップ番号を更新する。"
//----------------
- if( ( this.描画開始チップ番号 == i ) && ( this._画面の高さdpx + 40.0 < y ) ) // +40 dpx はチップが（以下同上
+ if( ( this._描画開始チップ番号 == i ) && ( this._画面の高さdpx + 40.0 < y ) ) // +40 dpx はチップが（以下同上
{
- this.描画開始チップ番号++;
- if( 演奏スコア.チップリスト.Count <= this.描画開始チップ番号 )
+ this._描画開始チップ番号++;
+ if( 演奏スコア.チップリスト.Count <= this._描画開始チップ番号 )
{
this.ステージクリア();
- this.描画開始チップ番号 = -1; // 演奏終了。
+ this._描画開始チップ番号 = -1; // 演奏終了。
}
}
//----------------
if( null != 演奏スコア )
{
- for( int i = this.描画開始チップ番号; ( 0 <= i ) && ( 演奏スコア.チップリスト.Count > i ); i++ )
+ for( int i = this._描画開始チップ番号; ( 0 <= i ) && ( 演奏スコア.チップリスト.Count > i ); i++ )
{
var チップ = 演奏スコア.チップリスト[ i ];
private void _Miss判定を行う( SSTFormat.チップ chip, double 描画時間差sec )
{
if( ( chip.ヒットされていない ) && // チップが未ヒット、かつ、
- ( this.ヒット判定を行うチップと対応するレーン.ContainsKey( chip.チップ種別 ) ) && // チップがヒット判定対象である、かつ、
+ ( this._ヒット判定を行うチップと対応するレーン.ContainsKey( chip.チップ種別 ) ) && // チップがヒット判定対象である、かつ、
( 描画時間差sec > StrokeStyleT.ユーザ管理.現在選択されているユーザ.ヒット範囲sec.Poor ) ) // 描画時間差が Poor 範囲を超えている。
{
chip.ヒット済みである = true;
private void _小節線拍線を１つ描画する( デバイスリソース dr, SSTFormat.チップ chip, float Ydpx )
{
- if( null == this.チップ画像 )
+ if( null == this._チップ画像 )
return;
- this.チップ画像.加算合成 = false;
+ this._チップ画像.加算合成 = false;
switch( chip.チップ種別 )
{
#region " 小節線を１本表示する。"
//----------------
{
- float 左位置dpx = 座標.レーンフレーム左端のX座標dpx + this.レーン種別toレーンフレーム左端からの相対X位置dpx[ SSTFormat.レーン種別.LeftCrash ] - 1f;
+ float 左位置dpx = 座標.レーンフレーム左端のX座標dpx + this._レーン種別toレーンフレーム左端からの相対X位置dpx[ SSTFormat.レーン種別.LeftCrash ] - 1f;
float 上位置dpx = Ydpx - 1f;
- var 画像範囲orNull = this.チップ画像の矩形リスト[ nameof( SSTFormat.チップ種別.小節線 ) ];
+ var 画像範囲orNull = this._チップ画像の矩形リスト[ nameof( SSTFormat.チップ種別.小節線 ) ];
if( null != 画像範囲orNull )
{
var 画像範囲 = (SharpDX.RectangleF) 画像範囲orNull;
- this.チップ画像.描画する( dr, 左位置dpx, 上位置dpx, 転送元矩形dpx: 画像範囲 );
- this.チップ画像.描画する( dr, 左位置dpx + 画像範囲.Width, 上位置dpx, 転送元矩形dpx: 画像範囲 );
+ this._チップ画像.描画する( dr, 左位置dpx, 上位置dpx, 転送元矩形dpx: 画像範囲 );
+ this._チップ画像.描画する( dr, 左位置dpx + 画像範囲.Width, 上位置dpx, 転送元矩形dpx: 画像範囲 );
}
}
//----------------
#region " 拍線を１本表示する。"
//----------------
{
- float 左位置dpx = 座標.レーンフレーム左端のX座標dpx + this.レーン種別toレーンフレーム左端からの相対X位置dpx[ SSTFormat.レーン種別.LeftCrash ] - 1f;
+ float 左位置dpx = 座標.レーンフレーム左端のX座標dpx + this._レーン種別toレーンフレーム左端からの相対X位置dpx[ SSTFormat.レーン種別.LeftCrash ] - 1f;
float 上位置dpx = Ydpx;
- var 画像範囲orNull = this.チップ画像の矩形リスト[ nameof( SSTFormat.チップ種別.拍線 ) ];
+ var 画像範囲orNull = this._チップ画像の矩形リスト[ nameof( SSTFormat.チップ種別.拍線 ) ];
if( null != 画像範囲orNull )
{
var 画像範囲 = (SharpDX.RectangleF) 画像範囲orNull;
- this.チップ画像.描画する( dr, 左位置dpx: 左位置dpx, 上位置dpx: 上位置dpx, 転送元矩形dpx: 画像範囲 );
- this.チップ画像.描画する( dr, 左位置dpx: 左位置dpx + 画像範囲.Width, 上位置dpx: 上位置dpx, 転送元矩形dpx: 画像範囲 );
+ this._チップ画像.描画する( dr, 左位置dpx: 左位置dpx, 上位置dpx: 上位置dpx, 転送元矩形dpx: 画像範囲 );
+ this._チップ画像.描画する( dr, 左位置dpx: 左位置dpx + 画像範囲.Width, 上位置dpx: 上位置dpx, 転送元矩形dpx: 画像範囲 );
}
}
//----------------
private void _チップを１つ描画する( デバイスリソース dr, SSTFormat.チップ chip, float Ydpx )
{
- if( null == this.チップ画像 )
+ if( null == this._チップ画像 )
return;
- this.チップ画像.加算合成 = false;
+ this._チップ画像.加算合成 = false;
float 音量0to1 = chip.音量 * 0.25f; // 1～4 → 0.25～1.00
switch( chip.チップ種別 )
{
case SSTFormat.チップ種別.LeftCrash:
- this._単画チップを１つ描画する( dr, SSTFormat.レーン種別.LeftCrash, this.チップ画像の矩形リスト[ nameof( SSTFormat.チップ種別.LeftCrash ) ], Ydpx, 音量0to1 );
+ this._単画チップを１つ描画する( dr, SSTFormat.レーン種別.LeftCrash, this._チップ画像の矩形リスト[ nameof( SSTFormat.チップ種別.LeftCrash ) ], Ydpx, 音量0to1 );
break;
case SSTFormat.チップ種別.HiHat_Close:
- this._アニメチップを１つ描画する( dr, this.チップ画像の矩形リスト[ nameof( SSTFormat.チップ種別.HiHat_Close ) ], SSTFormat.レーン種別.HiHat, Ydpx, 音量0to1 );
+ this._アニメチップを１つ描画する( dr, this._チップ画像の矩形リスト[ nameof( SSTFormat.チップ種別.HiHat_Close ) ], SSTFormat.レーン種別.HiHat, Ydpx, 音量0to1 );
break;
case SSTFormat.チップ種別.HiHat_HalfOpen:
- this._アニメチップを１つ描画する( dr, this.チップ画像の矩形リスト[ nameof( SSTFormat.チップ種別.HiHat_Close ) ], SSTFormat.レーン種別.HiHat, Ydpx, 音量0to1 );
- this._単画チップを１つ描画する( dr, SSTFormat.レーン種別.Foot, this.チップ画像の矩形リスト[ nameof( SSTFormat.チップ種別.HiHat_HalfOpen ) ], Ydpx, 1.0f ); // 音量は反映しない
+ this._アニメチップを１つ描画する( dr, this._チップ画像の矩形リスト[ nameof( SSTFormat.チップ種別.HiHat_Close ) ], SSTFormat.レーン種別.HiHat, Ydpx, 音量0to1 );
+ this._単画チップを１つ描画する( dr, SSTFormat.レーン種別.Foot, this._チップ画像の矩形リスト[ nameof( SSTFormat.チップ種別.HiHat_HalfOpen ) ], Ydpx, 1.0f ); // 音量は反映しない
break;
case SSTFormat.チップ種別.HiHat_Open:
- this._アニメチップを１つ描画する( dr, this.チップ画像の矩形リスト[ nameof( SSTFormat.チップ種別.HiHat_Close ) ], SSTFormat.レーン種別.HiHat, Ydpx, 音量0to1 );
- this._単画チップを１つ描画する( dr, SSTFormat.レーン種別.Foot, this.チップ画像の矩形リスト[ nameof( SSTFormat.チップ種別.HiHat_Open ) ], Ydpx, 1.0f ); // 音量は反映しない
+ this._アニメチップを１つ描画する( dr, this._チップ画像の矩形リスト[ nameof( SSTFormat.チップ種別.HiHat_Close ) ], SSTFormat.レーン種別.HiHat, Ydpx, 音量0to1 );
+ this._単画チップを１つ描画する( dr, SSTFormat.レーン種別.Foot, this._チップ画像の矩形リスト[ nameof( SSTFormat.チップ種別.HiHat_Open ) ], Ydpx, 1.0f ); // 音量は反映しない
break;
case SSTFormat.チップ種別.HiHat_Foot:
- this._単画チップを１つ描画する( dr, SSTFormat.レーン種別.Foot, this.チップ画像の矩形リスト[ nameof( SSTFormat.チップ種別.HiHat_Foot ) ], Ydpx, 1.0f ); // 音量は反映しない
+ this._単画チップを１つ描画する( dr, SSTFormat.レーン種別.Foot, this._チップ画像の矩形リスト[ nameof( SSTFormat.チップ種別.HiHat_Foot ) ], Ydpx, 1.0f ); // 音量は反映しない
break;
case SSTFormat.チップ種別.Snare:
- this._アニメチップを１つ描画する( dr, this.チップ画像の矩形リスト[ nameof( SSTFormat.チップ種別.Snare ) ], SSTFormat.レーン種別.Snare, Ydpx, 音量0to1 );
+ this._アニメチップを１つ描画する( dr, this._チップ画像の矩形リスト[ nameof( SSTFormat.チップ種別.Snare ) ], SSTFormat.レーン種別.Snare, Ydpx, 音量0to1 );
break;
case SSTFormat.チップ種別.Snare_ClosedRim:
- this._単画チップを１つ描画する( dr, SSTFormat.レーン種別.Snare, this.チップ画像の矩形リスト[ nameof( SSTFormat.チップ種別.Snare_ClosedRim ) ], Ydpx, 1.0f ); // 音量は反映しない
+ this._単画チップを１つ描画する( dr, SSTFormat.レーン種別.Snare, this._チップ画像の矩形リスト[ nameof( SSTFormat.チップ種別.Snare_ClosedRim ) ], Ydpx, 1.0f ); // 音量は反映しない
break;
case SSTFormat.チップ種別.Snare_OpenRim:
- this._単画チップを１つ描画する( dr, SSTFormat.レーン種別.Snare, this.チップ画像の矩形リスト[ nameof( SSTFormat.チップ種別.Snare_OpenRim ) ], Ydpx, 音量0to1 );
+ this._単画チップを１つ描画する( dr, SSTFormat.レーン種別.Snare, this._チップ画像の矩形リスト[ nameof( SSTFormat.チップ種別.Snare_OpenRim ) ], Ydpx, 音量0to1 );
//this.単画チップを１つ描画する( dr, SSTFormat.レーン種別.Snare, this.チップ画像の矩形リスト[ nameof( SSTFormat.チップ種別.Snare ) ], y, 音量0to1 ); → ないほうが見た目がいいかも。
break;
case SSTFormat.チップ種別.Snare_Ghost:
- this._単画チップを１つ描画する( dr, SSTFormat.レーン種別.Snare, this.チップ画像の矩形リスト[ nameof( SSTFormat.チップ種別.Snare_Ghost ) ], Ydpx, 1.0f ); // 音量は反映しない
+ this._単画チップを１つ描画する( dr, SSTFormat.レーン種別.Snare, this._チップ画像の矩形リスト[ nameof( SSTFormat.チップ種別.Snare_Ghost ) ], Ydpx, 1.0f ); // 音量は反映しない
break;
case SSTFormat.チップ種別.Bass:
- this._アニメチップを１つ描画する( dr, this.チップ画像の矩形リスト[ nameof( SSTFormat.チップ種別.Bass ) ], SSTFormat.レーン種別.Bass, Ydpx, 音量0to1 );
+ this._アニメチップを１つ描画する( dr, this._チップ画像の矩形リスト[ nameof( SSTFormat.チップ種別.Bass ) ], SSTFormat.レーン種別.Bass, Ydpx, 音量0to1 );
break;
case SSTFormat.チップ種別.Tom1:
- this._アニメチップを１つ描画する( dr, this.チップ画像の矩形リスト[ nameof( SSTFormat.チップ種別.Tom1 ) ], SSTFormat.レーン種別.Tom1, Ydpx, 音量0to1 );
+ this._アニメチップを１つ描画する( dr, this._チップ画像の矩形リスト[ nameof( SSTFormat.チップ種別.Tom1 ) ], SSTFormat.レーン種別.Tom1, Ydpx, 音量0to1 );
break;
case SSTFormat.チップ種別.Tom1_Rim:
- this._単画チップを１つ描画する( dr, SSTFormat.レーン種別.Tom1, this.チップ画像の矩形リスト[ nameof( SSTFormat.チップ種別.Tom1_Rim ) ], Ydpx, 1.0f ); // 音量は反映しない
+ this._単画チップを１つ描画する( dr, SSTFormat.レーン種別.Tom1, this._チップ画像の矩形リスト[ nameof( SSTFormat.チップ種別.Tom1_Rim ) ], Ydpx, 1.0f ); // 音量は反映しない
break;
case SSTFormat.チップ種別.Tom2:
- this._アニメチップを１つ描画する( dr, this.チップ画像の矩形リスト[ nameof( SSTFormat.チップ種別.Tom2 ) ], SSTFormat.レーン種別.Tom2, Ydpx, 音量0to1 );
+ this._アニメチップを１つ描画する( dr, this._チップ画像の矩形リスト[ nameof( SSTFormat.チップ種別.Tom2 ) ], SSTFormat.レーン種別.Tom2, Ydpx, 音量0to1 );
break;
case SSTFormat.チップ種別.Tom2_Rim:
- this._単画チップを１つ描画する( dr, SSTFormat.レーン種別.Tom2, this.チップ画像の矩形リスト[ nameof( SSTFormat.チップ種別.Tom2_Rim ) ], Ydpx, 1.0f ); // 音量は反映しない
+ this._単画チップを１つ描画する( dr, SSTFormat.レーン種別.Tom2, this._チップ画像の矩形リスト[ nameof( SSTFormat.チップ種別.Tom2_Rim ) ], Ydpx, 1.0f ); // 音量は反映しない
break;
case SSTFormat.チップ種別.Tom3:
- this._アニメチップを１つ描画する( dr, this.チップ画像の矩形リスト[ nameof( SSTFormat.チップ種別.Tom3 ) ], SSTFormat.レーン種別.Tom3, Ydpx, 音量0to1 );
+ this._アニメチップを１つ描画する( dr, this._チップ画像の矩形リスト[ nameof( SSTFormat.チップ種別.Tom3 ) ], SSTFormat.レーン種別.Tom3, Ydpx, 音量0to1 );
break;
case SSTFormat.チップ種別.Tom3_Rim:
- this._単画チップを１つ描画する( dr, SSTFormat.レーン種別.Tom3, this.チップ画像の矩形リスト[ nameof( SSTFormat.チップ種別.Tom3_Rim ) ], Ydpx, 1.0f ); // 音量は反映しない
+ this._単画チップを１つ描画する( dr, SSTFormat.レーン種別.Tom3, this._チップ画像の矩形リスト[ nameof( SSTFormat.チップ種別.Tom3_Rim ) ], Ydpx, 1.0f ); // 音量は反映しない
break;
case SSTFormat.チップ種別.RightCrash:
- this._単画チップを１つ描画する( dr, SSTFormat.レーン種別.RightCrash, this.チップ画像の矩形リスト[ nameof( SSTFormat.チップ種別.RightCrash ) ], Ydpx, 音量0to1 );
+ this._単画チップを１つ描画する( dr, SSTFormat.レーン種別.RightCrash, this._チップ画像の矩形リスト[ nameof( SSTFormat.チップ種別.RightCrash ) ], Ydpx, 音量0to1 );
break;
case SSTFormat.チップ種別.China:
if( StrokeStyleT.ユーザ管理.現在選択されているユーザ.Chinaは左 )
- this._単画チップを１つ描画する( dr, SSTFormat.レーン種別.LeftCrash, this.チップ画像の矩形リスト[ "LeftChina" ], Ydpx, 音量0to1 );
+ this._単画チップを１つ描画する( dr, SSTFormat.レーン種別.LeftCrash, this._チップ画像の矩形リスト[ "LeftChina" ], Ydpx, 音量0to1 );
else
- this._単画チップを１つ描画する( dr, SSTFormat.レーン種別.RightCrash, this.チップ画像の矩形リスト[ "RightChina" ], Ydpx, 音量0to1 );
+ this._単画チップを１つ描画する( dr, SSTFormat.レーン種別.RightCrash, this._チップ画像の矩形リスト[ "RightChina" ], Ydpx, 音量0to1 );
break;
case SSTFormat.チップ種別.Ride:
if( StrokeStyleT.ユーザ管理.現在選択されているユーザ.Rideは左 )
- this._単画チップを１つ描画する( dr, SSTFormat.レーン種別.LeftCrash, this.チップ画像の矩形リスト[ "LeftRide" ], Ydpx, 音量0to1 );
+ this._単画チップを１つ描画する( dr, SSTFormat.レーン種別.LeftCrash, this._チップ画像の矩形リスト[ "LeftRide" ], Ydpx, 音量0to1 );
else
- this._単画チップを１つ描画する( dr, SSTFormat.レーン種別.RightCrash, this.チップ画像の矩形リスト[ "RightRide" ], Ydpx, 音量0to1 );
+ this._単画チップを１つ描画する( dr, SSTFormat.レーン種別.RightCrash, this._チップ画像の矩形リスト[ "RightRide" ], Ydpx, 音量0to1 );
break;
case SSTFormat.チップ種別.Ride_Cup:
if( StrokeStyleT.ユーザ管理.現在選択されているユーザ.Rideは左 )
- this._単画チップを１つ描画する( dr, SSTFormat.レーン種別.LeftCrash, this.チップ画像の矩形リスト[ "LeftRide_Cup" ], Ydpx, 音量0to1 );
+ this._単画チップを１つ描画する( dr, SSTFormat.レーン種別.LeftCrash, this._チップ画像の矩形リスト[ "LeftRide_Cup" ], Ydpx, 音量0to1 );
else
- this._単画チップを１つ描画する( dr, SSTFormat.レーン種別.RightCrash, this.チップ画像の矩形リスト[ "RightRide_Cup" ], Ydpx, 音量0to1 );
+ this._単画チップを１つ描画する( dr, SSTFormat.レーン種別.RightCrash, this._チップ画像の矩形リスト[ "RightRide_Cup" ], Ydpx, 音量0to1 );
break;
case SSTFormat.チップ種別.Splash:
if( StrokeStyleT.ユーザ管理.現在選択されているユーザ.Splashは左 )
- this._単画チップを１つ描画する( dr, SSTFormat.レーン種別.LeftCrash, this.チップ画像の矩形リスト[ "LeftSplash" ], Ydpx, 音量0to1 );
+ this._単画チップを１つ描画する( dr, SSTFormat.レーン種別.LeftCrash, this._チップ画像の矩形リスト[ "LeftSplash" ], Ydpx, 音量0to1 );
else
- this._単画チップを１つ描画する( dr, SSTFormat.レーン種別.RightCrash, this.チップ画像の矩形リスト[ "RightSplash" ], Ydpx, 音量0to1 );
+ this._単画チップを１つ描画する( dr, SSTFormat.レーン種別.RightCrash, this._チップ画像の矩形リスト[ "RightSplash" ], Ydpx, 音量0to1 );
break;
}
}
var 画像範囲 = (SharpDX.RectangleF) 画像範囲orNull;
float チップ1枚の高さdpx = 18f;
- 画像範囲.Offset( 0f, this.チップアニメ.現在値 * 15f ); // 下端3dpxは下のチップと共有する前提のデザインなので、18f-3f = 15f。
+ 画像範囲.Offset( 0f, this._チップアニメ.現在値 * 15f ); // 下端3dpxは下のチップと共有する前提のデザインなので、18f-3f = 15f。
画像範囲.Height = チップ1枚の高さdpx;
- float 左位置dpx = 座標.レーンフレーム左端のX座標dpx + this.レーン種別toレーンフレーム左端からの相対X位置dpx[ elane ] - 画像範囲.Width / 2f;
+ float 左位置dpx = 座標.レーンフレーム左端のX座標dpx + this._レーン種別toレーンフレーム左端からの相対X位置dpx[ elane ] - 画像範囲.Width / 2f;
float 上位置dpx = Ydpx - ( チップ1枚の高さdpx / 2f ) * 音量0to1;
- this.チップ画像.描画する( dr, 左位置dpx, 上位置dpx, 転送元矩形dpx: 画像範囲, Y方向拡大率: 音量0to1 );
+ this._チップ画像.描画する( dr, 左位置dpx, 上位置dpx, 転送元矩形dpx: 画像範囲, Y方向拡大率: 音量0to1 );
}
private void _単画チップを１つ描画する( デバイスリソース dr, SSTFormat.レーン種別 eLane, SharpDX.RectangleF? 元矩形dpx, float 上位置dpx, float 音量0to1 )
return;
var 画像範囲dpx = (SharpDX.RectangleF) 元矩形dpx;
- this.チップ画像.描画する(
+ this._チップ画像.描画する(
dr,
- 左位置dpx: 座標.レーンフレーム左端のX座標dpx + this.レーン種別toレーンフレーム左端からの相対X位置dpx[ eLane ] - ( 画像範囲dpx.Width / 2f ),
+ 左位置dpx: 座標.レーンフレーム左端のX座標dpx + this._レーン種別toレーンフレーム左端からの相対X位置dpx[ eLane ] - ( 画像範囲dpx.Width / 2f ),
上位置dpx: 上位置dpx - ( ( 画像範囲dpx.Height / 2f ) * 音量0to1 ),
転送元矩形dpx: 元矩形dpx,
Y方向拡大率: 音量0to1 );
{
lock( this._スレッド間同期 )
{
- if( false == this.チップtoコンテキスト.ContainsKey( chipType ) )
+ if( false == this._チップtoコンテキスト.ContainsKey( chipType ) )
return; // コンテキスト未登録のチップなら何もしない。
- var context = this.チップtoコンテキスト[ chipType ];
+ var context = this._チップtoコンテキスト[ chipType ];
// 現在発声中のサウンドを全部止めるチップ種別の場合は止める。
if( 0 != chipType.排他発声グループID() ) // ID = 0 は対象外。
{
// 同じ排他発声グループIDを持つコンテキストの Sounds[] を select する。
var 停止するサウンド群 =
- from kvp in this.チップtoコンテキスト
+ from kvp in this._チップtoコンテキスト
where ( kvp.Key.排他発声グループID() == chipType.排他発声グループID() )
select kvp.Value.Sounds;
// サウンドローテーション。
context.次に再生するSound番号++;
- if( context.次に再生するSound番号 >= ドラムサウンド.多重度 )
+ if( context.次に再生するSound番号 >= ドラムサウンド._多重度 )
context.次に再生するSound番号 = 0;
}
}
- protected const int 多重度 = 2;
-
- protected class Cコンテキスト : IDisposable
+ private const int _多重度 = 2;
+ private class Cコンテキスト : IDisposable
{
- public FDK.メディア.サウンド.WASAPI.Sound[] Sounds = new FDK.メディア.サウンド.WASAPI.Sound[ ドラムサウンド.多重度 ];
+ public FDK.メディア.サウンド.WASAPI.Sound[] Sounds = new FDK.メディア.サウンド.WASAPI.Sound[ ドラムサウンド._多重度 ];
public int 次に再生するSound番号 = 0;
public void Dispose()
}
}
};
-
- protected Dictionary<SSTFormat.チップ種別, Cコンテキスト> チップtoコンテキスト = null;
-
+ private Dictionary<SSTFormat.チップ種別, Cコンテキスト> _チップtoコンテキスト = null;
private readonly string _KitXmlファイルパス = @"$(Static)\sounds\Kit.xml";
private readonly object _スレッド間同期 = new object();
private void _すべてのコンテキストを初期化する()
{
// すでに存在しているなら解放する。
- if( null != this.チップtoコンテキスト )
+ if( null != this._チップtoコンテキスト )
{
- foreach( var kvp in this.チップtoコンテキスト )
+ foreach( var kvp in this._チップtoコンテキスト )
( (Cコンテキスト) kvp.Value ).Dispose();
}
// 生成する。
- this.チップtoコンテキスト = new Dictionary<SSTFormat.チップ種別, Cコンテキスト>();
+ this._チップtoコンテキスト = new Dictionary<SSTFormat.チップ種別, Cコンテキスト>();
}
private void _KitXmlを読み込む()
if( File.Exists( サウンドファイルパス ) )
{
// すでに辞書に存在してるなら、解放して削除する。
- if( this.チップtoコンテキスト.ContainsKey( チップ種別 ) )
+ if( this._チップtoコンテキスト.ContainsKey( チップ種別 ) )
{
- this.チップtoコンテキスト[ チップ種別 ]?.Dispose();
- this.チップtoコンテキスト.Remove( チップ種別 );
+ this._チップtoコンテキスト[ チップ種別 ]?.Dispose();
+ this._チップtoコンテキスト.Remove( チップ種別 );
}
// コンテキストを作成する。
var context = new Cコンテキスト() {
- Sounds = new FDK.メディア.サウンド.WASAPI.Sound[ ドラムサウンド.多重度 ],
+ Sounds = new FDK.メディア.サウンド.WASAPI.Sound[ ドラムサウンド._多重度 ],
次に再生するSound番号 = 0,
};
context.Sounds[ i ] = StrokeStyleT.サウンドデバイス.CreateSound( サウンドファイルパス );
// コンテキストを辞書に追加する。
- this.チップtoコンテキスト.Add( チップ種別, context );
+ this._チップtoコンテキスト.Add( チップ種別, context );
}
else
{
public ヒット判定文字列()
{
// すべての文字列画像を子リストに追加。
- foreach( var kvp in this.文字列画像 )
+ foreach( var kvp in this._文字列画像 )
this.子リスト.Add( kvp.Value );
}
return;
// レーンに対応する進行描画コンテキストを更新し、表示を開始するためのパラメータを設定する。
- if( this.ヒット判定レーンto進行描画コンテキスト.ContainsKey( レーン種別 ) ) // すでにあったら、
- this.ヒット判定レーンto進行描画コンテキスト.Remove( レーン種別 ); // 削除してから、
- this.ヒット判定レーンto進行描画コンテキスト.Add( // 追加。
+ if( this._ヒット判定レーンto進行描画コンテキスト.ContainsKey( レーン種別 ) ) // すでにあったら、
+ this._ヒット判定レーンto進行描画コンテキスト.Remove( レーン種別 ); // 削除してから、
+ this._ヒット判定レーンto進行描画コンテキスト.Add( // 追加。
レーン種別,
new 進行描画コンテキスト() {
ヒット判定種別 = ヒット判定種別,
protected override void On活性化( デバイスリソース dr )
{
// すべてのヒット判定レーンに対する進行描画コンテキストを生成する。
- this.ヒット判定レーンto進行描画コンテキスト = new Dictionary<ヒットレーン種別, 進行描画コンテキスト>();
+ this._ヒット判定レーンto進行描画コンテキスト = new Dictionary<ヒットレーン種別, 進行描画コンテキスト>();
foreach( var judgeType in typeof( ヒットレーン種別 ).GetEnumValues() )
- this.ヒット判定レーンto進行描画コンテキスト.Add( (ヒットレーン種別) judgeType, new 進行描画コンテキスト() );
+ this._ヒット判定レーンto進行描画コンテキスト.Add( (ヒットレーン種別) judgeType, new 進行描画コンテキスト() );
}
protected override void On非活性化( デバイスリソース dr )
{
- this.ヒット判定レーンto進行描画コンテキスト.Clear();
+ this._ヒット判定レーンto進行描画コンテキスト.Clear();
}
public void 進行描画する( デバイスリソース dr )
foreach( var lane_object in typeof( ヒットレーン種別 ).GetEnumValues() )
{
var lane = (ヒットレーン種別) lane_object;
- var context = this.ヒット判定レーンto進行描画コンテキスト[ lane ];
+ var context = this._ヒット判定レーンto進行描画コンテキスト[ lane ];
if( context.進行カウンタ.停止中である )
continue; // カウンタが停止中 → このレーンについては何もしない。
// 描画。
- var 判定文字列の画像 = this.文字列画像[ context.ヒット判定種別 ];
+ var 判定文字列の画像 = this._文字列画像[ context.ヒット判定種別 ];
if( 判定文字列の画像.生成失敗 )
return;
/// <summary>
/// ヒット判定レーンには、それぞれに１つずつの進行描画コンテキストを用意する。
/// </summary>
- protected class 進行描画コンテキスト
+ private class 進行描画コンテキスト
{
/// <summary>
/// ヒット判定文字列のアニメ進行用カウンタ。
this.透明度0to1 = 1.0f;
}
}
-
- protected Dictionary<ヒットレーン種別, 進行描画コンテキスト> ヒット判定レーンto進行描画コンテキスト = null;
-
- protected readonly Dictionary<ヒット判定種別, FDK.メディア.画像> 文字列画像 = new Dictionary<ヒット判定種別, 画像>() {
+ private Dictionary<ヒットレーン種別, 進行描画コンテキスト> _ヒット判定レーンto進行描画コンテキスト = null;
+ private readonly Dictionary<ヒット判定種別, FDK.メディア.画像> _文字列画像 = new Dictionary<ヒット判定種別, 画像>() {
{ ヒット判定種別.PERFECT, new 画像( @"$(Static)\images\Judge Perfect.png" ) },
{ ヒット判定種別.GREAT, new 画像( @"$(Static)\images\Judge Great.png" ) },
{ ヒット判定種別.GOOD, new 画像( @"$(Static)\images\Judge Good.png" ) },
{ ヒット判定種別.MISS, new 画像( @"$(Static)\images\Judge Miss.png" ) },
{ ヒット判定種別.AUTO, new 画像( @"$(Static)\images\Judge Auto.png" ) },
};
-
private readonly object _スレッド間同期 = new object();
}
}
public レーンフレーム()
{
- this.子リスト.Add( this.レーンフレーム画像 = new 画像( @"$(Static)\images\レーン.png" ) );
+ this.子リスト.Add( this._レーンフレーム画像 = new 画像( @"$(Static)\images\レーン.png" ) );
}
public void 進行描画する( デバイスリソース dr )
{
- this.レーンフレーム画像.描画する( dr, 座標.レーンフレーム左端のX座標dpx, 0f );
+ this._レーンフレーム画像.描画する( dr, 座標.レーンフレーム左端のX座標dpx, 0f );
}
- protected readonly FDK.メディア.画像 レーンフレーム画像;
+ private FDK.メディア.画像 _レーンフレーム画像 = null;
}
}
this.子リスト.Add( this._羽画像 = new 画像( @"$(Static)\images\Chip Fire.png" ) );
this._羽画像.加算合成 = true;
- this.コンテキスト = new Cコンテキスト[ 最大同時発火数 * 8 ]; // 1発火につき羽を大小 8 枚使う
+ this._コンテキスト = new コンテキスト[ 最大同時発火数 * 8 ]; // 1発火につき羽を大小 8 枚使う
}
public void 発火する( SSTFormat.チップ種別 chipType )
int i = 0;
for( int 羽番号 = 0; 羽番号 < 8; 羽番号++ ) // 0～3:大羽、4～7:小羽、計８枚。
{
- for( ; i < this.コンテキスト.Length; i++ ) // 空いているコンテキストを探す。
+ for( ; i < this._コンテキスト.Length; i++ ) // 空いているコンテキストを探す。
{
- if( false == this.コンテキスト[ i ].使用中 )
+ if( false == this._コンテキスト[ i ].使用中 )
{
- this.コンテキスト[ i ].使用中 = true;
- this.コンテキスト[ i ].中央位置dpx = 中央位置dpx;
- this.コンテキスト[ i ].回転開始角度 = SharpDX.MathUtil.DegreesToRadians( 開始角度 + ( 羽番号 * 90.0f ) ); // 回転開始角度 = 0, 90, 180, 270, 0, 90, 180, 270
- this.コンテキスト[ i ].回転速度 = ( 羽番号 < 4 ) ? -1.5f : 1.5f; // 小羽と大羽は反対の方向に回転する
- this.コンテキスト[ i ].サイズ = ( 羽番号 < 4 ) ? 1.0f : 0.6f; // 小羽は大羽の0.6倍
- this.コンテキスト[ i ].進行カウンタ = new FDK.カウンタ.単純増加後不変カウンタ( 最初の値: 0, 最後の値: 70, 値をひとつ増加させるのにかける時間ms: 3 ); // 0 to 70 (210ms)
+ this._コンテキスト[ i ].使用中 = true;
+ this._コンテキスト[ i ].中央位置dpx = 中央位置dpx;
+ this._コンテキスト[ i ].回転開始角度 = SharpDX.MathUtil.DegreesToRadians( 開始角度 + ( 羽番号 * 90.0f ) ); // 回転開始角度 = 0, 90, 180, 270, 0, 90, 180, 270
+ this._コンテキスト[ i ].回転速度 = ( 羽番号 < 4 ) ? -1.5f : 1.5f; // 小羽と大羽は反対の方向に回転する
+ this._コンテキスト[ i ].サイズ = ( 羽番号 < 4 ) ? 1.0f : 0.6f; // 小羽は大羽の0.6倍
+ this._コンテキスト[ i ].進行カウンタ = new FDK.カウンタ.単純増加後不変カウンタ( 最初の値: 0, 最後の値: 70, 値をひとつ増加させるのにかける時間ms: 3 ); // 0 to 70 (210ms)
break;
}
}
protected override void On活性化( デバイスリソース dr )
{
// 全コンテキストを初期化。
- for( int i = 0; i < this.コンテキスト.Length; i++ )
+ for( int i = 0; i < this._コンテキスト.Length; i++ )
{
- this.コンテキスト[ i ] = new Cコンテキスト() {
+ this._コンテキスト[ i ] = new コンテキスト() {
使用中 = false,
進行カウンタ = null,
};
{
lock( this._スレッド間同期 )
{
- for( int i = 0; i < this.コンテキスト.Length; i++ )
+ for( int i = 0; i < this._コンテキスト.Length; i++ )
{
- var context = this.コンテキスト[ i ];
+ var context = this._コンテキスト[ i ];
if( false == context.使用中 )
continue; // 未使用の羽はスキップする。
}
}
- protected class Cコンテキスト
+ private class コンテキスト
{
public bool 使用中;
public SharpDX.Vector2 中央位置dpx;
public float サイズ;
public FDK.カウンタ.単純増加後不変カウンタ 進行カウンタ;
}
-
- protected Cコンテキスト[] コンテキスト = null;
-
- private readonly FDK.メディア.画像 _羽画像;
+ private コンテキスト[] _コンテキスト = null;
+ private FDK.メディア.画像 _羽画像 = null;
private readonly object _スレッド間同期 = new object();
}
}
最大サイズdpx.Width,
最大サイズdpx.Height );
- this._ユーザ指定サイズdpx = new SharpDX.Size2(
+ this.ユーザ指定サイズdpx = new SharpDX.Size2(
(int) ( this._テキストレイアウト.Metrics.WidthIncludingTrailingWhitespace + 0.5f ),
(int) ( this._テキストレイアウト.Metrics.Height + 0.5f ) );
//----------------
OSDN Git Service
