コード例 #1
0
ファイル: CInputJoystick.cs プロジェクト: smallghost/TJAP2fPC
        /// <summary>
        /// 必要に応じて軸ボタンの上げ下げイベントを発生する
        /// </summary>
        /// <param name="target">軸ボタン番号 0=-X 1=+X ... 5=+Z</param>
        /// <param name="data"></param>
        /// <param name="currentMode">直前のボタン状態 true=押されていた</param>
        /// <returns>上げ下げイベント発生時true</returns>
        private bool bDoUpDownCore(int target, JoystickState 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);
        }
コード例 #2
0
        // メソッド

        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 );
                //}
            }
        }
コード例 #3
0
        public void tポーリング(bool bWindowがアクティブ中)
        {
            for (int i = 0; i < Enum.GetNames(typeof(MouseButton)).Length; i++)
            {
                this.bMousePushDown[i] = false;
                this.bMousePullUp[i]   = false;
            }

            if (bWindowがアクティブ中)
            {
                // this.list入力イベント = new List<STInputEvent>( 32 );
                this.list入力イベント.Clear();                            // #xxxxx 2012.6.11 yyagi; To optimize, I removed new();



                #region [ 入力 ]
                //-----------------------------

                OpenTK.Input.MouseState currentState = OpenTK.Input.Mouse.GetState();
                if (currentState.IsConnected)
                {
                    for (int j = 0; (j < Enum.GetNames(typeof(MouseButton)).Length); j++)
                    {
                        if (this.bMouseState[j] == false && currentState[(MouseButton)j] == true)
                        {
                            var ev = new STInputEvent()
                            {
                                nKey       = j,
                                b押された      = true,
                                b離された      = false,
                                nTimeStamp = CSound管理.rc演奏用タイマ.nシステム時刻,                                 // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                nVelocity  = CInput管理.n通常音量,
                            };
                            this.list入力イベント.Add(ev);

                            this.bMouseState[j]    = true;
                            this.bMousePushDown[j] = true;
                        }
                        else if (this.bMouseState[j] == true && currentState[(MouseButton)j] == false)
                        {
                            var ev = new STInputEvent()
                            {
                                nKey       = j,
                                b押された      = false,
                                b離された      = true,
                                nTimeStamp = CSound管理.rc演奏用タイマ.nシステム時刻,                                 // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                nVelocity  = CInput管理.n通常音量,
                            };
                            this.list入力イベント.Add(ev);

                            this.bMouseState[j]  = false;
                            this.bMousePullUp[j] = true;
                        }
                    }
                }
                //-----------------------------
                #endregion
            }
        }
コード例 #4
0
ファイル: CInputMouse.cs プロジェクト: Mr-Ojii/TJAPlayer3-f
        public void tPolling(bool bIsWindowActive, bool bEnableBufferInput)
        {
            for (int i = 0; i < Enum.GetNames(typeof(SlimDXKeys.Mouse)).Length; i++)
            {
                this.bMousePushDown[i] = false;
                this.bMousePullUp[i]   = false;
            }

            if (bIsWindowActive)
            {
                this.listInputEvents.Clear();                            // #xxxxx 2012.6.11 yyagi; To optimize, I removed new();

                //-----------------------------
                MouseState currentState = Mouse.GetState();

                if (currentState.IsConnected)
                {
                    for (int j = 0; j < Enum.GetNames(typeof(SlimDXKeys.Mouse)).Length; j++)
                    {
                        if (this.bMouseState[j] == false && currentState[(MouseButton)j] == true)
                        {
                            var ev = new STInputEvent()
                            {
                                nKey       = j,
                                bPressed   = true,
                                bReleased  = false,
                                nTimeStamp = CSoundManager.rc演奏用タイマ.nシステム時刻ms,                                 // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                            };
                            this.listInputEvents.Add(ev);

                            this.bMouseState[j]    = true;
                            this.bMousePushDown[j] = true;
                        }
                        else if (this.bMouseState[j] == true && currentState[(MouseButton)j] == false)
                        {
                            var ev = new STInputEvent()
                            {
                                nKey       = j,
                                bPressed   = false,
                                bReleased  = true,
                                nTimeStamp = CSoundManager.rc演奏用タイマ.nシステム時刻ms,                                 // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                            };
                            this.listInputEvents.Add(ev);

                            this.bMouseState[j]  = false;
                            this.bMousePullUp[j] = true;
                        }
                    }
                }
                //-----------------------------
            }
        }
コード例 #5
0
        public void tポーリング(bool bWindowがアクティブ中, bool bバッファ入力有効)
        {
            for (int i = 0; i < Enum.GetNames(typeof(MouseButton)).Length; i++)
            {
                this.bMousePushDown[i] = false;
                this.bMousePullUp[i]   = false;
            }

            if (bWindowがアクティブ中)
            {
                this.list入力イベント.Clear();                            // #xxxxx 2012.6.11 yyagi; To optimize, I removed new();

                //-----------------------------
                MouseState currentState = Mouse.GetState();

                if (currentState.IsConnected)
                {
                    for (int j = 0; j < Enum.GetNames(typeof(MouseButton)).Length; j++)
                    {
                        if (this.bMouseState[j] == false && currentState[(MouseButton)j] == true)
                        {
                            var ev = new STInputEvent()
                            {
                                nKey       = j,
                                b押された      = true,
                                b離された      = false,
                                nTimeStamp = CSound管理.rc演奏用タイマ.nシステム時刻ms,                                 // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                            };
                            this.list入力イベント.Add(ev);

                            this.bMouseState[j]    = true;
                            this.bMousePushDown[j] = true;
                        }
                        else if (this.bMouseState[j] == true && currentState[(MouseButton)j] == false)
                        {
                            var ev = new STInputEvent()
                            {
                                nKey       = j,
                                b押された      = false,
                                b離された      = true,
                                nTimeStamp = CSound管理.rc演奏用タイマ.nシステム時刻ms,                                 // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                            };
                            this.list入力イベント.Add(ev);

                            this.bMouseState[j]  = false;
                            this.bMousePullUp[j] = true;
                        }
                    }
                }
                //-----------------------------
            }
        }
コード例 #6
0
        // メソッド

        public unsafe void tメッセージからMIDI信号のみ受信(int dev, long time, IntPtr buffer, int length, IntPtr user)
        {
            Debug.Print(length.ToString());
            byte *buf        = (byte *)buffer;
            int   nMIDIevent = buf[0];
            int   nPara1     = buf[1];
            int   nPara2     = buf[2];

            if ((nMIDIevent == 0x90) && (nPara2 != 0))                  // Note ON
            {
                STInputEvent item = new STInputEvent();
                item.nKey       = nPara1;
                item.b押された      = true;
                item.nTimeStamp = time;
                this.listEventBuffer.Add(item);
            }
        }
コード例 #7
0
ファイル: CInputMIDI.cs プロジェクト: Mr-Ojii/TJAPlayer3-f
        // メソッド

        public unsafe void tメッセージからMIDI信号のみ受信(int dev, long time, byte[] buf, int count)
        {
            if (this.ID == dev)
            {
                int nMIDIevent = buf[count * 3];
                int nPara1     = buf[count * 3 + 1];
                int nPara2     = buf[count * 3 + 2];

                if ((nMIDIevent == 0x90) && (nPara2 != 0))                      // Note ON
                {
                    STInputEvent item = new STInputEvent();
                    item.nKey       = nPara1;
                    item.bPressed   = true;
                    item.nTimeStamp = time;
                    this.listEventBuffer.Add(item);
                }
            }
        }
コード例 #8
0
 public void Key押された受信(KeyEventArgs e)
 {
     if (e != null)
     {
         var key = DeviceConstantConverter.KeysToKey(e.KeyCode);
         if (SlimDXKey.Unknown == key)
         {
             return;                       // 未対応キーは無視。
         }
         STInputEvent item = new STInputEvent()
         {
             nKey       = (int)key,
             b押された      = true,
             b離された      = false,
             nTimeStamp = CSound管理.rc演奏用タイマ.nシステム時刻ms,
         };
         this.listEventBuffer.Add(item);
     }
 }
コード例 #9
0
        // メソッド

        public void tメッセージからMIDI信号のみ受信(uint wMsg, int dwInstance, int dwParam1, int dwParam2, long n受信システム時刻)
        {
            if (wMsg == CWin32.MIM_DATA)
            {
                int nMIDIevent = dwParam1 & 0xF0;
                int nPara1     = (dwParam1 >> 8) & 0xFF;
                int nPara2     = (dwParam1 >> 16) & 0xFF;

// Trace.TraceInformation( "MIDIevent={0:X2} para1={1:X2} para2={2:X2}", nMIDIevent, nPara1, nPara2 );

                if ((nMIDIevent == 0x90) && (nPara2 != 0))
                {
                    STInputEvent item = new STInputEvent();
                    item.nKey       = nPara1;
                    item.b押された      = true;
                    item.nTimeStamp = n受信システム時刻;
                    this.listEventBuffer.Add(item);
                }
            }
        }
コード例 #10
0
        public void Key離された受信(Keys Code)
        {
            var key = DeviceConstantConverter.KeysToKey(Code);

            if (SlimDXKey.Unknown == key)
            {
                return;                   // 未対応キーは無視。
            }
            if (this.bKeyStateForBuff[(int)key] == true)
            {
                STInputEvent item = new STInputEvent()
                {
                    nKey       = (int)key,
                    b押された      = false,
                    b離された      = true,
                    nTimeStamp = CSound管理.rc演奏用タイマ.nシステム時刻ms,
                };

                this.listEventBuffer.Add(item);
                this.bKeyStateForBuff[(int)key] = false;
            }
        }
コード例 #11
0
        public void Key押された受信(Key Code)
        {
            var key = DeviceConstantConverter.TKKtoKey(Code);

            if (SlimDXKey.Unknown == key)
            {
                return;                   // 未対応キーは無視。
            }
            if (this.bKeyStateForBuff[(int)key] == false)
            {
                STInputEvent item = new STInputEvent()
                {
                    nKey       = (int)key,
                    bPressed   = true,
                    bReleased  = false,
                    nTimeStamp = CSoundManager.rc演奏用タイマ.nシステム時刻ms,
                };
                this.listEventBuffer.Add(item);

                this.bKeyStateForBuff[(int)key] = true;
            }
        }
コード例 #12
0
        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);
        }
コード例 #13
0
ファイル: CInputJoystick.cs プロジェクト: smallghost/TJAP2fPC
        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().IsFailure) && !this.devJoystick.Poll().IsFailure)
            {
                // this.list入力イベント = new List<STInputEvent>( 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 (JoystickState data in bufferedData)
                        {
#if false
//if ( 0 < data.X && data.X < 128 && 0 < data.Y && data.Y < 128 && 0 < data.Z && data.Z < 128 )
                            {
                                Trace.TraceInformation("TS={0}: offset={4}, X={1},Y={2},Z={3}", data.TimeStamp, data.X, data.Y, data.Z, data.JoystickDeviceType);
                                if (data.JoystickDeviceType == (int)JoystickDeviceType.POV0 ||
                                    data.JoystickDeviceType == (int)JoystickDeviceType.POV1 ||
                                    data.JoystickDeviceType == (int)JoystickDeviceType.POV2 ||
                                    data.JoystickDeviceType == (int)JoystickDeviceType.POV3)
                                {
//if ( data.JoystickDeviceType== (int)JoystickDeviceType.POV0 )
//{
                                    Debug.WriteLine("POV0です!!");
                                }
//Trace.TraceInformation( "TS={0}: X={1},Y={2},Z={3}", data.TimeStamp, data.X, data.Y, data.Z );
                                string pp  = "";
                                int[]  pp0 = data.GetPointOfViewControllers();
                                for (int ii = 0; ii < pp0.Length; ii++)
                                {
                                    pp += pp0[ii];
                                }
                                Trace.TraceInformation("TS={0}: povs={1}", data.TimeStamp, pp);
                                string pp2 = "", pp3 = "";
                                for (int ii = 0; ii < 32; ii++)
                                {
                                    pp2 += (data.IsPressed(ii)) ? "1" : "0";
                                    pp3 += (data.IsReleased(ii)) ? "1" : "0";
                                }
                                Trace.TraceInformation("TS={0}: IsPressed={1}, IsReleased={2}", data.TimeStamp, pp2, pp3);
                            }
#endif
                            switch (data.JoystickDeviceType)
                            {
                            case (int)JoystickDeviceType.X:
                                #region [ X軸- ]
                                //-----------------------------
                                bButtonUpDown(data, data.X, 0, 1);
                                //-----------------------------
                                #endregion
                                #region [ X軸+ ]
                                //-----------------------------
                                bButtonUpDown(data, data.X, 1, 0);
                                //-----------------------------
                                #endregion
                                break;

                            case (int)JoystickDeviceType.Y:
                                #region [ Y軸- ]
                                //-----------------------------
                                bButtonUpDown(data, data.Y, 2, 3);
                                //-----------------------------
                                #endregion
                                #region [ Y軸+ ]
                                //-----------------------------
                                bButtonUpDown(data, data.Y, 3, 2);
                                #endregion
                                break;

                            case (int)JoystickDeviceType.Z:
                                #region [ Z軸- ]
                                //-----------------------------
                                bButtonUpDown(data, data.Z, 4, 5);
                                //-----------------------------
                                #endregion
                                #region [ Z軸+ ]
                                //-----------------------------
                                bButtonUpDown(data, data.Z, 5, 4);
                                #endregion
                                break;

                            case (int)JoystickDeviceType.POV0:
                            case (int)JoystickDeviceType.POV1:
                            case (int)JoystickDeviceType.POV2:
                            case (int)JoystickDeviceType.POV3:
                                // #24341 2011.3.12 yyagi: POV support
                                // #26880 2011.12.6 yyagi: improve to support "pullup" of POV buttons
                                #region [ POV HAT 4/8way ]
                                int[] povs = data.GetPointOfViewControllers();
                                if (povs != null)
                                {
                                    STInputEvent e = new STInputEvent();
                                    int          p = ((int)data.JoystickDeviceType - (int)JoystickDeviceType.POV0) / ((int)JoystickDeviceType.POV1 - (int)JoystickDeviceType.POV0);                                             // p = 0,1,2,3
                                    // #31030 2013.3.25 yyagi; p is not 0123 but 048.. Sop must be divided into 4 ( POV1 - POV0 == 4).
                                    int nPovDegree = povs[p];
                                    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            = 6 + 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                       = 6 + 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
                                break;

                            default:
                                #region [ ボタン ]
                                //-----------------------------
                                for (int i = 0; i < 32; i++)
                                {
                                    if (data.IsPressed(i))
                                    {
                                        STInputEvent e = new STInputEvent()
                                        {
                                            nKey       = 6 + i,
                                            b押された      = true,
                                            b離された      = false,
                                            nTimeStamp = CSound管理.rc演奏用タイマ.nサウンドタイマーのシステム時刻msへの変換(data.TimeStamp),
                                            nVelocity  = CInput管理.n通常音量
                                        };
                                        this.list入力イベント.Add(e);

                                        this.bButtonState[6 + i]    = true;
                                        this.bButtonPushDown[6 + i] = true;
                                    }
                                    else if (data.IsReleased(i))
                                    {
                                        var ev = new STInputEvent()
                                        {
                                            nKey       = 6 + i,
                                            b押された      = false,
                                            b離された      = true,
                                            nTimeStamp = CSound管理.rc演奏用タイマ.nサウンドタイマーのシステム時刻msへの変換(data.TimeStamp),
                                            nVelocity  = CInput管理.n通常音量,
                                        };
                                        this.list入力イベント.Add(ev);

                                        this.bButtonState[6 + i]  = false;
                                        this.bButtonPullUp[6 + 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システム時刻,                                     // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                    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システム時刻,                                     // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                    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システム時刻,                                     // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                    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システム時刻,                                     // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                    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システム時刻,                                     // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                    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システム時刻,                                     // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                    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システム時刻,                                     // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                    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システム時刻,                                     // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                    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システム時刻,                                     // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                    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システム時刻,                                     // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                    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システム時刻,                                     // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                    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システム時刻,                                     // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                    nVelocity  = CInput管理.n通常音量
                                };
                                this.list入力イベント.Add(event15);

                                this.bButtonState[5]  = false;
                                this.bButtonPullUp[5] = true;
                            }
                        }
                        //-----------------------------
                        #endregion
                        #region [ ボタン ]
                        //-----------------------------
                        bool   bIsButtonPressedReleased = false;
                        bool[] buttons = currentState.GetButtons();
                        for (int j = 0; (j < buttons.Length) && (j < 128); j++)
                        {
                            if (this.bButtonState[6 + j] == false && buttons[j])
                            {
                                STInputEvent item = new STInputEvent()
                                {
                                    nKey       = 6 + j,
                                    b押された      = true,
                                    nTimeStamp = CSound管理.rc演奏用タイマ.nシステム時刻,                                     // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                    nVelocity  = CInput管理.n通常音量
                                };
                                this.list入力イベント.Add(item);

                                this.bButtonState[6 + j]    = true;
                                this.bButtonPushDown[6 + j] = true;
                                bIsButtonPressedReleased    = true;
                            }
                            else if (this.bButtonState[6 + j] == true && !buttons[j])
                            {
                                STInputEvent item = new STInputEvent()
                                {
                                    nKey       = 6 + j,
                                    b押された      = false,
                                    nTimeStamp = CSound管理.rc演奏用タイマ.nシステム時刻,                                     // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                    nVelocity  = CInput管理.n通常音量
                                };
                                this.list入力イベント.Add(item);

                                this.bButtonState[6 + j]  = false;
                                this.bButtonPullUp[6 + 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.GetPointOfViewControllers();
                        if (povs != null)
                        {
                            if (povs[0] >= 0)
                            {
                                int nPovDegree = povs[0];
                                int nWay       = (nPovDegree + 2250) / 4500;
                                if (nWay == 8)
                                {
                                    nWay = 0;
                                }

                                if (this.bButtonState[6 + 128 + nWay] == false)
                                {
                                    STInputEvent stevent = new STInputEvent()
                                    {
                                        nKey = 6 + 128 + nWay,
                                        //Debug.WriteLine( "POVS:" + povs[ 0 ].ToString( CultureInfo.CurrentCulture ) + ", " +stevent.nKey );
                                        b押された      = true,
                                        nTimeStamp = CSound管理.rc演奏用タイマ.nシステム時刻,                                         // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                        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 他のボタンが何も押され/離されてない=POVが離された
                            {
                                int nWay = 0;
                                for (int i = 6 + 0x80; i < 6 + 0x80 + 8; i++)
                                {                                                                               // 離されたボタンを調べるために、元々押されていたボタンを探す。
                                    if (this.bButtonState[i] == true)                                           // DirectInputを直接いじるならこんなことしなくて良いのに、あぁ面倒。
                                    {                                                                           // この処理が必要なために、POVを1個しかサポートできない。無念。
                                        nWay = i;
                                        break;
                                    }
                                }
                                if (nWay != 0)
                                {
                                    STInputEvent stevent = new STInputEvent()
                                    {
                                        nKey       = nWay,
                                        b押された      = false,
                                        nTimeStamp = CSound管理.rc演奏用タイマ.nシステム時刻,                                         // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                        nVelocity  = 0
                                    };
                                    this.list入力イベント.Add(stevent);

                                    this.bButtonState[nWay]  = false;
                                    this.bButtonPullUp[nWay] = true;
                                }
                            }
                        }
                        #endregion
                    }
                    //-----------------------------
                    #endregion
                }
            }
        }
コード例 #14
0
        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.list入力イベント.Clear();                                        // #xxxxx 2012.6.11 yyagi; To optimize, I removed new();


                #region [ 入力 ]
                //-----------------------------
                JoystickState ButtonState = Joystick.GetState(ID);
                if (ButtonState.IsConnected)
                {
                    #region [ X軸- ]
                    //-----------------------------
                    if (ButtonState.GetAxis(0) < -0.5)
                    {
                        if (this.bButtonState[0] == false)
                        {
                            STInputEvent ev = new STInputEvent()
                            {
                                nKey       = 0,
                                b押された      = true,
                                nTimeStamp = CSound管理.rc演奏用タイマ.nシステム時刻ms,                                 // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                            };
                            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システム時刻ms,                                 // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                            };
                            this.list入力イベント.Add(ev);

                            this.bButtonState[0]  = false;
                            this.bButtonPullUp[0] = true;
                        }
                    }
                    //-----------------------------
                    #endregion
                    #region [ X軸+ ]
                    //-----------------------------
                    if (ButtonState.GetAxis(0) > 0.5)
                    {
                        if (this.bButtonState[1] == false)
                        {
                            STInputEvent ev = new STInputEvent()
                            {
                                nKey       = 1,
                                b押された      = true,
                                nTimeStamp = CSound管理.rc演奏用タイマ.nシステム時刻ms,                                 // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                            };
                            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システム時刻ms,                                 // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                            };
                            this.list入力イベント.Add(event7);

                            this.bButtonState[1]  = false;
                            this.bButtonPullUp[1] = true;
                        }
                    }
                    //-----------------------------
                    #endregion
                    #region [ Y軸- ]
                    //-----------------------------
                    if (ButtonState.GetAxis(1) < -0.5)
                    {
                        if (this.bButtonState[2] == false)
                        {
                            STInputEvent ev = new STInputEvent()
                            {
                                nKey       = 2,
                                b押された      = true,
                                nTimeStamp = CSound管理.rc演奏用タイマ.nシステム時刻ms,                                 // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                            };
                            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システム時刻ms,                                 // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                            };
                            this.list入力イベント.Add(ev);

                            this.bButtonState[2]  = false;
                            this.bButtonPullUp[2] = true;
                        }
                    }
                    //-----------------------------
                    #endregion
                    #region [ Y軸+ ]
                    //-----------------------------
                    if (ButtonState.GetAxis(1) > 0.5)
                    {
                        if (this.bButtonState[3] == false)
                        {
                            STInputEvent ev = new STInputEvent()
                            {
                                nKey       = 3,
                                b押された      = true,
                                nTimeStamp = CSound管理.rc演奏用タイマ.nシステム時刻ms,                                 // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                            };
                            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システム時刻ms,                                 // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                            };
                            this.list入力イベント.Add(ev);

                            this.bButtonState[3]  = false;
                            this.bButtonPullUp[3] = true;
                        }
                    }
                    //-----------------------------
                    #endregion
                    #region [ Z軸- ]
                    //-----------------------------
                    if (ButtonState.GetAxis(2) < -0.5)
                    {
                        if (this.bButtonState[4] == false)
                        {
                            STInputEvent ev = new STInputEvent()
                            {
                                nKey       = 4,
                                b押された      = true,
                                nTimeStamp = CSound管理.rc演奏用タイマ.nシステム時刻ms,                                 // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                            };
                            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システム時刻ms,                                 // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                            };
                            this.list入力イベント.Add(ev);

                            this.bButtonState[4]  = false;
                            this.bButtonPullUp[4] = true;
                        }
                    }
                    //-----------------------------
                    #endregion
                    #region [ Z軸+ ]
                    //-----------------------------
                    if (ButtonState.GetAxis(2) > 0.5)
                    {
                        if (this.bButtonState[5] == false)
                        {
                            STInputEvent ev = new STInputEvent()
                            {
                                nKey       = 5,
                                b押された      = true,
                                nTimeStamp = CSound管理.rc演奏用タイマ.nシステム時刻ms,                                 // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                            };
                            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システム時刻ms,                                 // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                            };
                            this.list入力イベント.Add(event15);

                            this.bButtonState[5]  = false;
                            this.bButtonPullUp[5] = true;
                        }
                    }
                    //-----------------------------
                    #endregion
                    #region [ Z軸回転- ]
                    //-----------------------------
                    if (ButtonState.GetAxis(3) < -0.5)
                    {
                        if (this.bButtonState[6] == false)
                        {
                            STInputEvent ev = new STInputEvent()
                            {
                                nKey       = 6,
                                b押された      = true,
                                nTimeStamp = CSound管理.rc演奏用タイマ.nシステム時刻ms,                                 // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                            };
                            this.list入力イベント.Add(ev);

                            this.bButtonState[6]    = true;
                            this.bButtonPushDown[6] = true;
                        }
                    }
                    else
                    {
                        if (this.bButtonState[4] == true)
                        {
                            STInputEvent ev = new STInputEvent()
                            {
                                nKey       = 6,
                                b押された      = false,
                                nTimeStamp = CSound管理.rc演奏用タイマ.nシステム時刻ms,                                 // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                            };
                            this.list入力イベント.Add(ev);

                            this.bButtonState[6]  = false;
                            this.bButtonPullUp[6] = true;
                        }
                    }
                    //-----------------------------
                    #endregion
                    #region [ Z軸回転+ ]
                    //-----------------------------
                    if (ButtonState.GetAxis(3) > 0.5)
                    {
                        if (this.bButtonState[7] == false)
                        {
                            STInputEvent ev = new STInputEvent()
                            {
                                nKey       = 7,
                                b押された      = true,
                                nTimeStamp = CSound管理.rc演奏用タイマ.nシステム時刻ms,                                 // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                            };
                            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システム時刻ms,                                 // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                            };
                            this.list入力イベント.Add(event15);

                            this.bButtonState[7]  = false;
                            this.bButtonPullUp[7] = true;
                        }
                    }
                    //-----------------------------
                    #endregion
                    #region [ Button ]
                    //-----------------------------
                    bool bIsButtonPressedReleased = false;
                    for (int j = 0; j < 128; j++)
                    {
                        if (this.bButtonState[8 + j] == false && ButtonState.IsButtonDown(j))
                        {
                            STInputEvent item = new STInputEvent()
                            {
                                nKey       = 8 + j,
                                b押された      = true,
                                nTimeStamp = CSound管理.rc演奏用タイマ.nシステム時刻ms,                                 // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                            };
                            this.list入力イベント.Add(item);

                            this.bButtonState[8 + j]    = true;
                            this.bButtonPushDown[8 + j] = true;
                            bIsButtonPressedReleased    = true;
                        }
                        else if (this.bButtonState[8 + j] == true && !ButtonState.IsButtonDown(j))
                        {
                            STInputEvent item = new STInputEvent()
                            {
                                nKey       = 8 + j,
                                b押された      = false,
                                nTimeStamp = CSound管理.rc演奏用タイマ.nシステム時刻ms,                                 // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                            };
                            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)]
                    JoystickHatState hatState = ButtonState.GetHat(JoystickHat.Hat0);

                    for (int nWay = 0; nWay < 8; nWay++)
                    {
                        if (hatState.Position == (OpenTK.Input.HatPosition)nWay + 1)
                        {
                            if (this.bButtonState[8 + 128 + nWay] == false)
                            {
                                STInputEvent stevent = new STInputEvent()
                                {
                                    nKey       = 8 + 128 + nWay,
                                    b押された      = true,
                                    nTimeStamp = CSound管理.rc演奏用タイマ.nシステム時刻ms,                                     // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                };
                                this.list入力イベント.Add(stevent);

                                this.bButtonState[stevent.nKey]    = true;
                                this.bButtonPushDown[stevent.nKey] = true;
                            }
                            bIsButtonPressedReleased = true;
                        }
                    }
                    if (bIsButtonPressedReleased == false)                     // #xxxxx 2011.12.3 yyagi 他のボタンが何も押され/離されてない=POVが離された
                    {
                        int nWay = 0;
                        for (int i = 8 + 0x80; i < 8 + 0x80 + 8; i++)
                        {                                                                   // 離されたボタンを調べるために、元々押されていたボタンを探す。
                            if (this.bButtonState[i] == true)                               // DirectInputを直接いじるならこんなことしなくて良いのに、あぁ面倒。
                            {                                                               // この処理が必要なために、POVを1個しかサポートできない。無念。
                                nWay = i;
                                break;
                            }
                        }
                        if (nWay != 0)
                        {
                            STInputEvent stevent = new STInputEvent()
                            {
                                nKey       = nWay,
                                b押された      = false,
                                nTimeStamp = CSound管理.rc演奏用タイマ.nシステム時刻ms,                                 // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                            };
                            this.list入力イベント.Add(stevent);

                            this.bButtonState[nWay]  = false;
                            this.bButtonPullUp[nWay] = true;
                        }
                    }
                    #endregion
                    //-----------------------------
                    #endregion
                }
            }
        }
コード例 #15
0
        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<STInputEvent>( 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システム時刻,                                         // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                        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システム時刻,                                     // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                    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が押されているときは、Enter押下情報を削除する -> 副作用が見つかり削除]
                //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
            }
        }
コード例 #16
0
        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().IsFailure) && !this.devJoystick.Poll().IsFailure)
            {
                // this.list入力イベント = new List<STInputEvent>( 32 );
                this.list入力イベント.Clear();                                                                // #xxxxx 2012.6.11 yyagi; To optimize, I removed new();


                if (bバッファ入力を使用する)
                {
                    #region [ a.バッファ入力 ]
                    //-----------------------------

                    var length = this.devJoystick.GetDeviceData(_rawBufferedDataArray, false);
                    if (!Result.Last.IsSuccess)
                    {
                        return;
                    }
                    for (int i = 0; i < length; i++)
                    {
                        var rawBufferedData = _rawBufferedDataArray[i];

                        switch (rawBufferedData.Offset)
                        {
                        case 0:
                            #region [ X軸- ]
                            //-----------------------------
                            bButtonUpDown(rawBufferedData, rawBufferedData.Data, 0, 1);
                            //-----------------------------
                            #endregion
                            #region [ X軸+ ]
                            //-----------------------------
                            bButtonUpDown(rawBufferedData, rawBufferedData.Data, 1, 0);
                            //-----------------------------
                            #endregion
                            break;

                        case 4:
                            #region [ Y軸- ]
                            //-----------------------------
                            bButtonUpDown(rawBufferedData, rawBufferedData.Data, 2, 3);
                            //-----------------------------
                            #endregion
                            #region [ Y軸+ ]
                            //-----------------------------
                            bButtonUpDown(rawBufferedData, rawBufferedData.Data, 3, 2);
                            #endregion
                            break;

                        case 8:
                            #region [ Z軸- ]
                            //-----------------------------
                            bButtonUpDown(rawBufferedData, rawBufferedData.Data, 4, 5);
                            //-----------------------------
                            #endregion
                            #region [ Z軸+ ]
                            //-----------------------------
                            bButtonUpDown(rawBufferedData, rawBufferedData.Data, 5, 4);
                            #endregion
                            break;

                        case 32:
                            const int p          = 0; // const until we support more than one POV hat
                            int       nPovDegree = rawBufferedData.Data;
                            int       nWay       = (nPovDegree + 2250) / 4500;
                            if (nWay == 8)
                            {
                                nWay = 0;
                            }

                            STInputEvent e = new STInputEvent();
                            if (nPovDegree == -1 || nPovDegree == 0xFFFF)
                            {
                                e.nKey                     = 6 + 128 + this.nPovState[p];
                                this.nPovState[p]          = -1;
                                e.b押された                    = false;
                                this.bButtonState[e.nKey]  = false;
                                this.bButtonPullUp[e.nKey] = true;
                            }
                            else
                            {
                                this.nPovState[p]            = nWay;
                                e.nKey                       = 6 + 128 + nWay;
                                e.b押された                      = true;
                                this.bButtonState[e.nKey]    = true;
                                this.bButtonPushDown[e.nKey] = true;
                            }
                            e.nTimeStamp = CSound管理.rc演奏用タイマ.nサウンドタイマーのシステム時刻msへの変換(rawBufferedData.Timestamp);
                            this.list入力イベント.Add(e);
                            break;

                        default:
                            var buttonIndex = rawBufferedData.Offset - 48;
                            if (-1 < buttonIndex && buttonIndex < 32)
                            {
                                var key        = 6 + buttonIndex;
                                var wasPressed = (rawBufferedData.Data & 128) == 128;

                                STInputEvent item = new STInputEvent()
                                {
                                    nKey       = key,
                                    b押された      = wasPressed,
                                    nTimeStamp = CSound管理.rc演奏用タイマ.nサウンドタイマーのシステム時刻msへの変換(rawBufferedData.Timestamp),
                                };
                                this.list入力イベント.Add(item);

                                this.bButtonState[item.nKey]    = wasPressed;
                                this.bButtonPushDown[item.nKey] = wasPressed;
                                this.bButtonPullUp[item.nKey]   = !wasPressed;
                            }

                            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システム時刻,                                     // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                };
                                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システム時刻,                                     // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                };
                                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システム時刻,                                     // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                };
                                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システム時刻,                                     // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                };
                                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システム時刻,                                     // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                };
                                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システム時刻,                                     // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                };
                                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システム時刻,                                     // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                };
                                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システム時刻,                                     // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                };
                                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システム時刻,                                     // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                };
                                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システム時刻,                                     // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                };
                                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システム時刻,                                     // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                };
                                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システム時刻,                                     // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                };
                                this.list入力イベント.Add(event15);

                                this.bButtonState[5]  = false;
                                this.bButtonPullUp[5] = true;
                            }
                        }
                        //-----------------------------
                        #endregion
                        #region [ ボタン ]
                        //-----------------------------
                        bool   bIsButtonPressedReleased = false;
                        bool[] buttons = currentState.GetButtons();
                        for (int j = 0; (j < buttons.Length) && (j < 128); j++)
                        {
                            if (this.bButtonState[6 + j] == false && buttons[j])
                            {
                                STInputEvent item = new STInputEvent()
                                {
                                    nKey       = 6 + j,
                                    b押された      = true,
                                    nTimeStamp = CSound管理.rc演奏用タイマ.nシステム時刻,                                     // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                };
                                this.list入力イベント.Add(item);

                                this.bButtonState[6 + j]    = true;
                                this.bButtonPushDown[6 + j] = true;
                                bIsButtonPressedReleased    = true;
                            }
                            else if (this.bButtonState[6 + j] == true && !buttons[j])
                            {
                                STInputEvent item = new STInputEvent()
                                {
                                    nKey       = 6 + j,
                                    b押された      = false,
                                    nTimeStamp = CSound管理.rc演奏用タイマ.nシステム時刻,                                     // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                };
                                this.list入力イベント.Add(item);

                                this.bButtonState[6 + j]  = false;
                                this.bButtonPullUp[6 + 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.GetPointOfViewControllers();
                        if (povs != null)
                        {
                            if (povs[0] >= 0)
                            {
                                int nPovDegree = povs[0];
                                int nWay       = (nPovDegree + 2250) / 4500;
                                if (nWay == 8)
                                {
                                    nWay = 0;
                                }

                                if (this.bButtonState[6 + 128 + nWay] == false)
                                {
                                    STInputEvent stevent = new STInputEvent()
                                    {
                                        nKey = 6 + 128 + nWay,
                                        //Debug.WriteLine( "POVS:" + povs[ 0 ].ToString( CultureInfo.CurrentCulture ) + ", " +stevent.nKey );
                                        b押された      = true,
                                        nTimeStamp = CSound管理.rc演奏用タイマ.nシステム時刻,                                         // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                    };
                                    this.list入力イベント.Add(stevent);

                                    this.bButtonState[stevent.nKey]    = true;
                                    this.bButtonPushDown[stevent.nKey] = true;
                                }
                            }
                            else if (bIsButtonPressedReleased == false)                                 // #xxxxx 2011.12.3 yyagi 他のボタンが何も押され/離されてない=POVが離された
                            {
                                int nWay = 0;
                                for (int i = 6 + 0x80; i < 6 + 0x80 + 8; i++)
                                {                                                                               // 離されたボタンを調べるために、元々押されていたボタンを探す。
                                    if (this.bButtonState[i] == true)                                           // DirectInputを直接いじるならこんなことしなくて良いのに、あぁ面倒。
                                    {                                                                           // この処理が必要なために、POVを1個しかサポートできない。無念。
                                        nWay = i;
                                        break;
                                    }
                                }
                                if (nWay != 0)
                                {
                                    STInputEvent stevent = new STInputEvent()
                                    {
                                        nKey       = nWay,
                                        b押された      = false,
                                        nTimeStamp = CSound管理.rc演奏用タイマ.nシステム時刻,                                         // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                    };
                                    this.list入力イベント.Add(stevent);

                                    this.bButtonState[nWay]  = false;
                                    this.bButtonPullUp[nWay] = true;
                                }
                            }
                        }
                        #endregion
                    }
                    //-----------------------------
                    #endregion
                }
            }
        }
コード例 #17
0
        public void tポーリング(bool bWindowがアクティブ中)
        {
            for (int i = 0; i < 256; i++)
            {
                this.bKeyPushDown[i] = false;
                this.bKeyPullUp[i]   = false;
            }

            if (bWindowがアクティブ中)
            {
                //this.list入力イベント = new List<STInputEvent>( 32 );
                this.list入力イベント.Clear();                            // #xxxxx 2012.6.11 yyagi; To optimize, I removed new();
                //string d = DateTime.Now.ToString( "yyyy/MM/dd HH:mm:ss.ffff" );


                #region [ 入力 ]
                //-----------------------------
                OpenTK.Input.KeyboardState currentState = OpenTK.Input.Keyboard.GetState();

                if (currentState.IsConnected)
                {
                    for (int index = 0; index < Enum.GetNames(typeof(OpenTK.Input.Key)).Length; index++)
                    {
                        if (currentState[(OpenTK.Input.Key)index])
                        {
                            var key = DeviceConstantConverter.TKKtoKey((OpenTK.Input.Key)index);
                            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システム時刻,                                         // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                        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システム時刻 );
                                //}
                            }
                        }
                        {
                            // #xxxxx: 2017.5.7: from: DIK (SharpDX.DirectInput.Key) を SlimDX.DirectInput.Key に変換。
                            var key = DeviceConstantConverter.TKKtoKey((OpenTK.Input.Key)index);
                            if (SlimDXKey.Unknown == key)
                            {
                                continue;                                                                             // 未対応キーは無視。
                            }
                            if (this.bKeyState[(int)key] == true && !currentState.IsKeyDown((OpenTK.Input.Key)index)) // 前回は押されているのに今回は押されていない → 離された
                            {
                                var ev = new STInputEvent()
                                {
                                    nKey       = (int)key,
                                    b押された      = false,
                                    b離された      = true,
                                    nTimeStamp = CSound管理.rc演奏用タイマ.nシステム時刻,                                     // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                    nVelocity  = CInput管理.n通常音量,
                                };
                                this.list入力イベント.Add(ev);

                                this.bKeyState[(int)key]  = false;
                                this.bKeyPullUp[(int)key] = true;
                            }
                        }
                    }
                }
                //-----------------------------
                #endregion
            }
        }
コード例 #18
0
        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().IsFailure) && !this.devMouse.Poll().IsFailure)
            {
                // this.list入力イベント = new List<STInputEvent>( 32 );
                this.list入力イベント.Clear();                                        // #xxxxx 2012.6.11 yyagi; To optimize, I removed new();

                if (bバッファ入力を使用する)
                {
                    #region [ a.バッファ入力 ]
                    //-----------------------------

                    var length = this.devMouse.GetDeviceData(_rawBufferedDataArray, false);
                    if (!Result.Last.IsSuccess)
                    {
                        return;
                    }
                    for (int i = 0; i < length; i++)
                    {
                        var rawBufferedData = _rawBufferedDataArray[i];
                        var key             = rawBufferedData.Offset - 12;
                        var wasPressed      = (rawBufferedData.Data & 128) == 128;

                        if (!(-1 < key && key < 8))
                        {
                            continue;
                        }

                        STInputEvent item = new STInputEvent()
                        {
                            nKey       = key,
                            b押された      = wasPressed,
                            nTimeStamp = CSound管理.rc演奏用タイマ.nサウンドタイマーのシステム時刻msへの変換(rawBufferedData.Timestamp),
                        };
                        this.list入力イベント.Add(item);

                        this.bMouseState[item.nKey]    = wasPressed;
                        this.bMousePushDown[item.nKey] = wasPressed;
                        this.bMousePullUp[item.nKey]   = !wasPressed;
                    }

                    //-----------------------------
                    #endregion
                }
                else
                {
                    #region [ b.状態入力 ]
                    //-----------------------------
                    MouseState currentState = this.devMouse.GetCurrentState();
                    if (Result.Last.IsSuccess && currentState != null)
                    {
                        bool[] buttons = currentState.GetButtons();
                        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,
                                    nTimeStamp = CSound管理.rc演奏用タイマ.nシステム時刻,                                     // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                };
                                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,
                                    nTimeStamp = CSound管理.rc演奏用タイマ.nシステム時刻,                                     // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                };
                                this.list入力イベント.Add(ev);

                                this.bMouseState[j]  = false;
                                this.bMousePullUp[j] = true;
                            }
                        }
                    }
                    //-----------------------------
                    #endregion
                }
            }
        }
コード例 #19
0
        public void tポーリング(bool bWindowがアクティブ中, bool bバッファ入力有効)
        {
            for (int i = 0; i < 256; i++)
            {
                this.bKeyPushDown[i] = false;
                this.bKeyPullUp[i]   = false;
            }

            if (bWindowがアクティブ中)
            {
                if (bバッファ入力有効)
                {
                    this.list入力イベント.Clear();

                    for (int i = 0; i < this.listEventBuffer.Count; i++)
                    {
                        if (this.listEventBuffer[i].b押された)
                        {
                            this.bKeyState[this.listEventBuffer[i].nKey]    = true;
                            this.bKeyPushDown[this.listEventBuffer[i].nKey] = true;
                        }
                        else if (this.listEventBuffer[i].b離された)
                        {
                            this.bKeyState[this.listEventBuffer[i].nKey]  = false;
                            this.bKeyPullUp[this.listEventBuffer[i].nKey] = true;
                        }
                        this.list入力イベント.Add(this.listEventBuffer[i]);
                    }

                    this.listEventBuffer.Clear();
                }
                else
                {
                    this.list入力イベント.Clear();                                // #xxxxx 2012.6.11 yyagi; To optimize, I removed new();

                    //-----------------------------
                    KeyboardState currentState = Keyboard.GetState();

                    if (currentState.IsConnected)
                    {
                        for (int index = 0; index < Enum.GetNames(typeof(Key)).Length; index++)
                        {
                            if (currentState[(Key)index])
                            {
                                // #xxxxx: 2017.5.7: from: TKK (OpenTK.Input.Key) を SlimDX.DirectInput.Key に変換。
                                var key = DeviceConstantConverter.TKKtoKey((Key)index);
                                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システム時刻ms,                                             // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                        };
                                        this.list入力イベント.Add(ev);

                                        this.bKeyState[(int)key]    = true;
                                        this.bKeyPushDown[(int)key] = true;
                                    }
                                }
                            }
                            {
                                // #xxxxx: 2017.5.7: from: TKK (OpenTK.Input.Key) を SlimDX.DirectInput.Key に変換。
                                var key = DeviceConstantConverter.TKKtoKey((Key)index);
                                if (SlimDXKey.Unknown == key)
                                {
                                    continue;                                                                // 未対応キーは無視。
                                }
                                if (this.bKeyState[(int)key] == true && !currentState.IsKeyDown((Key)index)) // 前回は押されているのに今回は押されていない → 離された
                                {
                                    var ev = new STInputEvent()
                                    {
                                        nKey       = (int)key,
                                        b押された      = false,
                                        b離された      = true,
                                        nTimeStamp = CSound管理.rc演奏用タイマ.nシステム時刻ms,                                         // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                    };
                                    this.list入力イベント.Add(ev);

                                    this.bKeyState[(int)key]  = false;
                                    this.bKeyPullUp[(int)key] = true;
                                }
                            }
                        }
                    }
                }
                //-----------------------------
            }
        }
コード例 #20
0
        public void tポーリング(bool bWindowがアクティブ中)
        {
            #region [ bButtonフラグ初期化 ]
            for (int i = 0; i < 256; i++)
            {
                this.bButtonPushDown[i] = false;
                this.bButtonPullUp[i]   = false;
            }
            #endregion

            if (bWindowがアクティブ中)
            {
                this.list入力イベント.Clear();

                #region [ 入力 ]

                OpenTK.Input.JoystickState ButtonState = OpenTK.Input.Joystick.GetState(ID);

                if (ButtonState.IsConnected)
                {
                    #region [X軸]
                    if (ButtonState.GetAxis(0) < -0.5)                     //JoystickAxisがない?ので数値指定
                    {
                        if (this.bButtonState[0] == false)
                        {
                            STInputEvent ev = new STInputEvent()
                            {
                                nKey       = 0,
                                b押された      = true,
                                nTimeStamp = CSound管理.rc演奏用タイマ.nシステム時刻,                                 // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                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システム時刻,                                 // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                nVelocity  = CInput管理.n通常音量
                            };
                            this.list入力イベント.Add(ev);

                            this.bButtonState[0]  = false;
                            this.bButtonPullUp[0] = true;
                        }
                    }
                    if (ButtonState.GetAxis(0) > 0.5)
                    {
                        if (this.bButtonState[1] == false)
                        {
                            STInputEvent ev = new STInputEvent()
                            {
                                nKey       = 1,
                                b押された      = true,
                                nTimeStamp = CSound管理.rc演奏用タイマ.nシステム時刻,                                 // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                nVelocity  = CInput管理.n通常音量
                            };
                            this.list入力イベント.Add(ev);

                            this.bButtonState[1]    = true;
                            this.bButtonPushDown[1] = true;
                        }
                    }
                    else
                    {
                        if (this.bButtonState[1] == true)
                        {
                            STInputEvent ev = new STInputEvent()
                            {
                                nKey       = 1,
                                b押された      = false,
                                nTimeStamp = CSound管理.rc演奏用タイマ.nシステム時刻,                                 // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                nVelocity  = CInput管理.n通常音量
                            };
                            this.list入力イベント.Add(ev);

                            this.bButtonState[1]  = false;
                            this.bButtonPullUp[1] = true;
                        }
                    }
                    #endregion

                    #region [Y軸]
                    if (ButtonState.GetAxis(1) < -0.5)                     //JoystickAxisがない?ので数値指定
                    {
                        if (this.bButtonState[2] == false)
                        {
                            STInputEvent ev = new STInputEvent()
                            {
                                nKey       = 2,
                                b押された      = true,
                                nTimeStamp = CSound管理.rc演奏用タイマ.nシステム時刻,                                 // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                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システム時刻,                                 // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                nVelocity  = CInput管理.n通常音量
                            };
                            this.list入力イベント.Add(ev);

                            this.bButtonState[2]  = false;
                            this.bButtonPullUp[2] = true;
                        }
                    }
                    if (ButtonState.GetAxis(1) > 0.5)
                    {
                        if (this.bButtonState[3] == false)
                        {
                            STInputEvent ev = new STInputEvent()
                            {
                                nKey       = 3,
                                b押された      = true,
                                nTimeStamp = CSound管理.rc演奏用タイマ.nシステム時刻,                                 // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                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システム時刻,                                 // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                nVelocity  = CInput管理.n通常音量
                            };
                            this.list入力イベント.Add(ev);

                            this.bButtonState[3]  = false;
                            this.bButtonPullUp[3] = true;
                        }
                    }
                    #endregion

                    #region [Z軸]
                    if (ButtonState.GetAxis(2) < -0.5)                     //JoystickAxisがない?ので数値指定
                    {
                        if (this.bButtonState[4] == false)
                        {
                            STInputEvent ev = new STInputEvent()
                            {
                                nKey       = 4,
                                b押された      = true,
                                nTimeStamp = CSound管理.rc演奏用タイマ.nシステム時刻,                                 // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                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システム時刻,                                 // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                nVelocity  = CInput管理.n通常音量
                            };
                            this.list入力イベント.Add(ev);

                            this.bButtonState[4]  = false;
                            this.bButtonPullUp[4] = true;
                        }
                    }
                    if (ButtonState.GetAxis(2) > 0.5)
                    {
                        if (this.bButtonState[5] == false)
                        {
                            STInputEvent ev = new STInputEvent()
                            {
                                nKey       = 5,
                                b押された      = true,
                                nTimeStamp = CSound管理.rc演奏用タイマ.nシステム時刻,                                 // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                nVelocity  = CInput管理.n通常音量
                            };
                            this.list入力イベント.Add(ev);

                            this.bButtonState[5]    = true;
                            this.bButtonPushDown[5] = true;
                        }
                    }
                    else
                    {
                        if (this.bButtonState[5] == true)
                        {
                            STInputEvent ev = new STInputEvent()
                            {
                                nKey       = 5,
                                b押された      = false,
                                nTimeStamp = CSound管理.rc演奏用タイマ.nシステム時刻,                                 // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                nVelocity  = CInput管理.n通常音量
                            };
                            this.list入力イベント.Add(ev);

                            this.bButtonState[5]  = false;
                            this.bButtonPullUp[5] = true;
                        }
                    }
                    #endregion

                    #region [Z軸回転]
                    if (ButtonState.GetAxis(3) < -0.5)                     //JoystickAxisがない?ので数値指定
                    {
                        if (this.bButtonState[6] == false)
                        {
                            STInputEvent ev = new STInputEvent()
                            {
                                nKey       = 6,
                                b押された      = true,
                                nTimeStamp = CSound管理.rc演奏用タイマ.nシステム時刻,                                 // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                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システム時刻,                                 // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                nVelocity  = CInput管理.n通常音量
                            };
                            this.list入力イベント.Add(ev);

                            this.bButtonState[6]  = false;
                            this.bButtonPullUp[6] = true;
                        }
                    }
                    if (ButtonState.GetAxis(3) > 0.5)
                    {
                        if (this.bButtonState[7] == false)
                        {
                            STInputEvent ev = new STInputEvent()
                            {
                                nKey       = 7,
                                b押された      = true,
                                nTimeStamp = CSound管理.rc演奏用タイマ.nシステム時刻,                                 // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                nVelocity  = CInput管理.n通常音量
                            };
                            this.list入力イベント.Add(ev);

                            this.bButtonState[7]    = true;
                            this.bButtonPushDown[7] = true;
                        }
                    }
                    else
                    {
                        if (this.bButtonState[7] == true)
                        {
                            STInputEvent ev = new STInputEvent()
                            {
                                nKey       = 7,
                                b押された      = false,
                                nTimeStamp = CSound管理.rc演奏用タイマ.nシステム時刻,                                 // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                nVelocity  = CInput管理.n通常音量
                            };
                            this.list入力イベント.Add(ev);

                            this.bButtonState[7]  = false;
                            this.bButtonPullUp[7] = true;
                        }
                    }
                    #endregion

                    #region [POV]
                    OpenTK.Input.JoystickHatState hatState = ButtonState.GetHat(OpenTK.Input.JoystickHat.Hat0);

                    for (int i = 0; i < Enum.GetNames(typeof(OpenTK.Input.HatPosition)).Length; i++)
                    {
                        if (hatState.Position == (OpenTK.Input.HatPosition)i + 1)
                        {
                            if (this.bButtonState[8 + 128 + i] == false)
                            {
                                STInputEvent stevent = new STInputEvent()
                                {
                                    nKey = 8 + 128 + i,
                                    //Debug.WriteLine( "POVS:" + povs[ 0 ].ToString( CultureInfo.CurrentCulture ) + ", " +stevent.nKey );
                                    b押された      = true,
                                    nTimeStamp = CSound管理.rc演奏用タイマ.nシステム時刻,                                     // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                    nVelocity  = CInput管理.n通常音量
                                };
                                this.list入力イベント.Add(stevent);

                                this.bButtonState[stevent.nKey]    = true;
                                this.bButtonPushDown[stevent.nKey] = true;
                            }
                        }
                        else
                        {
                            if (this.bButtonState[8 + 128 + i] == true)
                            {
                                STInputEvent stevent = new STInputEvent()
                                {
                                    nKey       = 8 + 128 + i,
                                    b押された      = false,
                                    nTimeStamp = CSound管理.rc演奏用タイマ.nシステム時刻,                                     // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                    nVelocity  = 0
                                };
                                this.list入力イベント.Add(stevent);

                                this.bButtonState[stevent.nKey]  = false;
                                this.bButtonPullUp[stevent.nKey] = true;
                            }
                        }
                    }

                    #endregion

                    #region [Button]
                    for (int index = 0; index < 128; index++)
                    {
                        if (ButtonState.IsButtonDown(index))
                        {
                            if (this.bButtonState[8 + index] == false)
                            {
                                STInputEvent item = new STInputEvent()
                                {
                                    nKey       = 8 + index,
                                    b押された      = true,
                                    nTimeStamp = CSound管理.rc演奏用タイマ.nシステム時刻,                                     // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                    nVelocity  = CInput管理.n通常音量
                                };
                                this.list入力イベント.Add(item);

                                this.bButtonState[8 + index]    = true;
                                this.bButtonPushDown[8 + index] = true;
                            }
                        }
                        else
                        {
                            if (this.bButtonState[8 + index] == true)
                            {
                                STInputEvent item = new STInputEvent()
                                {
                                    nKey       = 8 + index,
                                    b押された      = false,
                                    nTimeStamp = CSound管理.rc演奏用タイマ.nシステム時刻,                                     // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                    nVelocity  = CInput管理.n通常音量
                                };
                                this.list入力イベント.Add(item);

                                this.bButtonState[8 + index]  = false;
                                this.bButtonPullUp[8 + index] = true;
                            }
                        }
                    }
                    #endregion
                }
                #endregion
            }
        }
コード例 #21
0
        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<STInputEvent>( 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システム時刻,                                     // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                    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システム時刻,                                     // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                    nVelocity  = CInput管理.n通常音量,
                                };
                                this.list入力イベント.Add(ev);

                                this.bMouseState[j]  = false;
                                this.bMousePullUp[j] = true;
                            }
                        }
                    }
                    //-----------------------------
                    #endregion
                }
            }
        }
コード例 #22
0
        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().IsFailure) && !this.devKeyboard.Poll().IsFailure)
            {
                //this.list入力イベント = new List<STInputEvent>( 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 length = this.devKeyboard.GetDeviceData(_rawBufferedDataArray, false);
                    if (!Result.Last.IsSuccess)
                    {
                        return;
                    }
                    for (int i = 0; i < length; i++)
                    {
                        var rawBufferedData = _rawBufferedDataArray[i];
                        var key             = DeviceConstantConverter.DIKtoKey(rawBufferedData.Offset);
                        var wasPressed      = (rawBufferedData.Data & 128) == 128;

                        STInputEvent item = new STInputEvent()
                        {
                            nKey       = (int)key,
                            b押された      = wasPressed,
                            nTimeStamp = CSound管理.rc演奏用タイマ.nサウンドタイマーのシステム時刻msへの変換(rawBufferedData.Timestamp),
                        };
                        this.list入力イベント.Add(item);

                        this.bKeyState[item.nKey]    = wasPressed;
                        this.bKeyPushDown[item.nKey] = wasPressed;
                        this.bKeyPullUp[item.nKey]   = !wasPressed;
                    }

                    //-----------------------------
                    #endregion
                }
                else
                {
                    #region [ b.状態入力 ]
                    //-----------------------------
                    KeyboardState currentState = this.devKeyboard.GetCurrentState();
                    if (Result.Last.IsSuccess && currentState != null)
                    {
                        foreach (Key key in currentState.PressedKeys)
                        {
                            if (this.bKeyState[(int)key] == false)
                            {
                                var ev = new STInputEvent()
                                {
                                    nKey       = (int)key,
                                    b押された      = true,
                                    nTimeStamp = CSound管理.rc演奏用タイマ.nシステム時刻,                                     // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                };
                                this.list入力イベント.Add(ev);

                                this.bKeyState[(int)key]    = true;
                                this.bKeyPushDown[(int)key] = true;

                                //if ( (int) key == (int) SlimDX.DirectInput.Key.Space )
                                //{
                                //    Trace.TraceInformation( "FDK(direct): SPACE key registered. " + ct.nシステム時刻 );
                                //}
                            }
                        }
                        foreach (Key key in currentState.ReleasedKeys)
                        {
                            if (this.bKeyState[(int)key] == true)
                            {
                                var ev = new STInputEvent()
                                {
                                    nKey       = (int)key,
                                    b押された      = false,
                                    nTimeStamp = CSound管理.rc演奏用タイマ.nシステム時刻,                                     // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                };
                                this.list入力イベント.Add(ev);

                                this.bKeyState[(int)key]  = false;
                                this.bKeyPullUp[(int)key] = true;
                            }
                        }
                    }
                    //-----------------------------
                    #endregion
                }
                #region [#23708 2011.4.8 yyagi Altが押されているときは、Enter押下情報を削除する -> 副作用が見つかり削除]
                //if ( this.bKeyState[ (int) SlimDX.DirectInput.Key.RightAlt ] ||
                //     this.bKeyState[ (int) SlimDX.DirectInput.Key.LeftAlt ] )
                //{
                //    int cr = (int) SlimDX.DirectInput.Key.Return;
                //    this.bKeyPushDown[ cr ] = false;
                //    this.bKeyPullUp[ cr ] = false;
                //    this.bKeyState[ cr ] = false;
                //}
                #endregion
            }
        }
コード例 #23
0
        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<STInputEvent>( 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システム時刻,                                     // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                    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システム時刻,                                     // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                    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システム時刻,                                     // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                    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システム時刻,                                     // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                    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システム時刻,                                     // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                    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システム時刻,                                     // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                    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システム時刻,                                     // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                    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システム時刻,                                     // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                    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システム時刻,                                     // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                    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システム時刻,                                     // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                    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システム時刻,                                     // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                    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システム時刻,                                     // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                    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システム時刻,                                     // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                    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システム時刻,                                     // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                    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システム時刻,                                     // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                    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システム時刻,                                     // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                    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システム時刻,                                     // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                    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システム時刻,                                     // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                    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システム時刻,                                         // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                        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 他のボタンが何も押され/離されてない=POVが離された
                            {
                                int nWay = 0;
                                for (int i = 8 + 0x80; i < 8 + 0x80 + 8; i++)
                                {                                                                           // 離されたボタンを調べるために、元々押されていたボタンを探す。
                                    if (this.bButtonState[i] == true)                                       // DirectInputを直接いじるならこんなことしなくて良いのに、あぁ面倒。
                                    {                                                                       // この処理が必要なために、POVを1個しかサポートできない。無念。
                                        nWay = i;
                                        break;
                                    }
                                }
                                if (nWay != 0)
                                {
                                    STInputEvent stevent = new STInputEvent()
                                    {
                                        nKey       = nWay,
                                        b押された      = false,
                                        nTimeStamp = CSound管理.rc演奏用タイマ.nシステム時刻,                                         // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
                                        nVelocity  = 0
                                    };
                                    this.list入力イベント.Add(stevent);

                                    this.bButtonState[nWay]  = false;
                                    this.bButtonPullUp[nWay] = true;
                                }
                            }
                        }
                        #endregion
                    }
                    //-----------------------------
                    #endregion
                }
            }
        }