Subversion Repositories eduke32

Rev

Rev 7986 | Rev 8003 | Go to most recent revision | Show entire file | Regard whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 7986 Rev 7992
Line 27... Line 27...
27
bool CONTROL_JoystickEnabled = false;
27
bool CONTROL_JoystickEnabled = false;
28
28
29
uint64_t CONTROL_ButtonState     = 0;
29
uint64_t CONTROL_ButtonState     = 0;
30
uint64_t CONTROL_ButtonHeldState = 0;
30
uint64_t CONTROL_ButtonHeldState = 0;
31
31
-
 
32
LastSeenInput CONTROL_LastSeenInput;
-
 
33
32
float          CONTROL_MouseSensitivity = DEFAULTMOUSESENSITIVITY;
34
float          CONTROL_MouseSensitivity = DEFAULTMOUSESENSITIVITY;
33
static int32_t CONTROL_NumMouseButtons  = 0;
35
static int32_t CONTROL_NumMouseButtons  = 0;
34
static int32_t CONTROL_NumMouseAxes     = 0;
36
static int32_t CONTROL_NumMouseAxes     = 0;
35
static int32_t CONTROL_NumJoyButtons    = 0;
37
static int32_t CONTROL_NumJoyButtons    = 0;
36
static int32_t CONTROL_NumJoyAxes       = 0;
38
static int32_t CONTROL_NumJoyAxes       = 0;
Line 474... Line 476...
474
476
475
    for (int & i : CONTROL_JoyAxesScale)
477
    for (int & i : CONTROL_JoyAxesScale)
476
        i = NORMALAXISSCALE;
478
        i = NORMALAXISSCALE;
477
}
479
}
478
480
479
static void DoGetDeviceButtons(
481
static int DoGetDeviceButtons(
480
    int32_t buttons, int32_t tm,
482
    int32_t buttons, int32_t tm,
481
    int32_t NumButtons,
483
    int32_t NumButtons,
482
    int32_t *DeviceButtonState,
484
    int32_t *DeviceButtonState,
483
    int32_t *ButtonClickedTime,
485
    int32_t *ButtonClickedTime,
484
    int32_t *ButtonClickedState,
486
    int32_t *ButtonClickedState,
485
    int32_t *ButtonClicked,
487
    int32_t *ButtonClicked,
486
    uint8_t *ButtonClickedCount
488
    uint8_t *ButtonClickedCount
487
)
489
)
488
{
490
{
489
    int32_t i=NumButtons-1;
491
    int32_t i=NumButtons-1;
-
 
492
    int retval = 0;
490
493
491
    for (; i>=0; i--)
494
    for (; i>=0; i--)
492
    {
495
    {
493
        int const bs = (buttons >> i) & 1;
496
        int const bs = (buttons >> i) & 1;
494
497
495
        DeviceButtonState[i]  = bs;
498
        DeviceButtonState[i]  = bs;
496
        ButtonClickedState[i] = FALSE;
499
        ButtonClickedState[i] = FALSE;
497
500
498
        if (bs)
501
        if (bs)
499
        {
502
        {
-
 
503
            retval = 1;
-
 
504
500
            if (ButtonClicked[i] == FALSE)
505
            if (ButtonClicked[i] == FALSE)
501
            {
506
            {
502
                ButtonClicked[i] = TRUE;
507
                ButtonClicked[i] = TRUE;
503
508
504
                if (ButtonClickedCount[i] == 0 || tm > ButtonClickedTime[i])
509
                if (ButtonClickedCount[i] == 0 || tm > ButtonClickedTime[i])
Line 524... Line 529...
524
        if (ButtonClickedCount[i] == 2)
529
        if (ButtonClickedCount[i] == 2)
525
            ButtonClickedCount[i] = 0;
530
            ButtonClickedCount[i] = 0;
526
531
527
        ButtonClicked[i] = FALSE;
532
        ButtonClicked[i] = FALSE;
528
    }
533
    }
-
 
534
-
 
535
    return retval;
529
}
536
}
530
537
531
static void CONTROL_GetDeviceButtons(void)
538
static void CONTROL_GetDeviceButtons(void)
532
{
539
{
533
    int32_t const t = ExtGetTime();
540
    int32_t const t = ExtGetTime();
Line 545... Line 552...
545
        );
552
        );
546
    }
553
    }
547
554
548
    if (CONTROL_JoystickEnabled)
555
    if (CONTROL_JoystickEnabled)
549
    {
556
    {
550
        DoGetDeviceButtons(
557
        int retval = DoGetDeviceButtons(
551
            JOYSTICK_GetButtons(), t,
558
            JOYSTICK_GetButtons(), t,
552
            CONTROL_NumJoyButtons,
559
            CONTROL_NumJoyButtons,
553
            CONTROL_JoyButtonState,
560
            CONTROL_JoyButtonState,
554
            CONTROL_JoyButtonClickedTime,
561
            CONTROL_JoyButtonClickedTime,
555
            CONTROL_JoyButtonClickedState,
562
            CONTROL_JoyButtonClickedState,
556
            CONTROL_JoyButtonClicked,
563
            CONTROL_JoyButtonClicked,
557
            CONTROL_JoyButtonClickedCount
564
            CONTROL_JoyButtonClickedCount
558
        );
565
        );
-
 
566
        if (retval)
-
 
567
            CONTROL_LastSeenInput = LastSeenInput::Joystick;
559
    }
568
    }
560
}
569
}
561
570
562
static void CONTROL_DigitizeAxis(int axis, controldevice device)
571
static int CONTROL_DigitizeAxis(int axis, controldevice device)
563
{
572
{
564
    controlaxistype *set, *lastset;
573
    controlaxistype *set, *lastset;
565
574
566
    switch (device)
575
    switch (device)
567
    {
576
    {
Line 573... Line 582...
573
    case controldevice_joystick:
582
    case controldevice_joystick:
574
        set = CONTROL_JoyAxes;
583
        set = CONTROL_JoyAxes;
575
        lastset = CONTROL_LastJoyAxes;
584
        lastset = CONTROL_LastJoyAxes;
576
        break;
585
        break;
577
586
578
    default: return;
587
    default: return 0;
579
    }
588
    }
580
589
581
    set[axis].digitalClearedN = lastset[axis].digitalClearedN;
590
    set[axis].digitalClearedN = lastset[axis].digitalClearedN;
582
    set[axis].digitalClearedP = lastset[axis].digitalClearedP;
591
    set[axis].digitalClearedP = lastset[axis].digitalClearedP;
583
592
Line 587... Line 596...
587
596
588
        if (set[axis].analog > THRESHOLD || (set[axis].analog > MINTHRESHOLD && lastset[axis].digital == 1))
597
        if (set[axis].analog > THRESHOLD || (set[axis].analog > MINTHRESHOLD && lastset[axis].digital == 1))
589
            set[axis].digital = 1;
598
            set[axis].digital = 1;
590
        else
599
        else
591
            set[axis].digitalClearedP = 0;
600
            set[axis].digitalClearedP = 0;
-
 
601
-
 
602
        return 1;
592
    }
603
    }
593
    else if (set[axis].analog < 0)
604
    else if (set[axis].analog < 0)
594
    {
605
    {
595
        set[axis].digitalClearedP = 0;
606
        set[axis].digitalClearedP = 0;
596
607
597
        if (set[axis].analog < -THRESHOLD || (set[axis].analog < -MINTHRESHOLD && lastset[axis].digital == -1))
608
        if (set[axis].analog < -THRESHOLD || (set[axis].analog < -MINTHRESHOLD && lastset[axis].digital == -1))
598
            set[axis].digital = -1;
609
            set[axis].digital = -1;
599
        else
610
        else
600
            set[axis].digitalClearedN = 0;
611
            set[axis].digitalClearedN = 0;
-
 
612
-
 
613
        return 1;
601
    }
614
    }
602
    else
615
    else
603
    {
616
    {
604
        set[axis].digitalClearedN = 0;
617
        set[axis].digitalClearedN = 0;
605
        set[axis].digitalClearedP = 0;
618
        set[axis].digitalClearedP = 0;
606
    }
619
    }
-
 
620
-
 
621
    return 0;
607
}
622
}
608
623
609
static void CONTROL_ScaleAxis(int axis, controldevice device)
624
static void CONTROL_ScaleAxis(int axis, controldevice device)
610
{
625
{
611
    controlaxistype *set;
626
    controlaxistype *set;
Line 695... Line 710...
695
710
696
        for (int i=joystick.numAxes-1; i>=0; i--)
711
        for (int i=joystick.numAxes-1; i>=0; i--)
697
        {
712
        {
698
            CONTROL_JoyAxes[i].analog = joystick.pAxis[i];
713
            CONTROL_JoyAxes[i].analog = joystick.pAxis[i];
699
714
700
            CONTROL_DigitizeAxis(i, controldevice_joystick);
715
            if (CONTROL_DigitizeAxis(i, controldevice_joystick))
-
 
716
                CONTROL_LastSeenInput = LastSeenInput::Joystick;
701
            CONTROL_ScaleAxis(i, controldevice_joystick);
717
            CONTROL_ScaleAxis(i, controldevice_joystick);
702
            LIMITCONTROL(&CONTROL_JoyAxes[i].analog);
718
            LIMITCONTROL(&CONTROL_JoyAxes[i].analog);
703
            CONTROL_ApplyAxis(i, info, controldevice_joystick);
719
            CONTROL_ApplyAxis(i, info, controldevice_joystick);
704
        }
720
        }
705
    }
721
    }
706
722
707
    CONTROL_GetDeviceButtons();
723
    CONTROL_GetDeviceButtons();
708
}
724
}
709
725
710
static void CONTROL_HandleAxisFunction(int32_t *p1, controlaxistype *axes, controlaxismaptype *axismap, int numAxes)
726
static int CONTROL_HandleAxisFunction(int32_t *p1, controlaxistype *axes, controlaxismaptype *axismap, int numAxes)
711
{
727
{
712
    int axis = numAxes - 1;
728
    int axis = numAxes - 1;
-
 
729
    int retval = 0;
713
730
714
    do
731
    do
715
    {
732
    {
716
        if (!axes[axis].digital)
733
        if (!axes[axis].digital)
717
            continue;
734
            continue;
718
735
719
        int const j = (axes[axis].digital < 0) ? axismap[axis].minmap : axismap[axis].maxmap;
736
        int const j = (axes[axis].digital < 0) ? axismap[axis].minmap : axismap[axis].maxmap;
720
737
721
        if (j != AXISUNDEFINED)
738
        if (j != AXISUNDEFINED)
-
 
739
        {
722
            p1[j] = 1;
740
            p1[j] = 1;
-
 
741
            retval = 1;
-
 
742
        }
723
    }
743
    }
724
    while (axis--);
744
    while (axis--);
-
 
745
-
 
746
    return retval;
725
}
747
}
726
748
727
static void CONTROL_AxisFunctionState(int32_t *p1)
749
static void CONTROL_AxisFunctionState(int32_t *p1)
728
{
750
{
729
    if (CONTROL_NumMouseAxes)
751
    if (CONTROL_NumMouseAxes)
730
        CONTROL_HandleAxisFunction(p1, CONTROL_MouseAxes, CONTROL_MouseAxesMap, CONTROL_NumMouseAxes);
752
        CONTROL_HandleAxisFunction(p1, CONTROL_MouseAxes, CONTROL_MouseAxesMap, CONTROL_NumMouseAxes);
731
753
732
    if (CONTROL_NumJoyAxes)
754
    if (CONTROL_NumJoyAxes)
-
 
755
    {
733
        CONTROL_HandleAxisFunction(p1, CONTROL_JoyAxes, CONTROL_JoyAxesMap, CONTROL_NumJoyAxes);
756
        if (CONTROL_HandleAxisFunction(p1, CONTROL_JoyAxes, CONTROL_JoyAxesMap, CONTROL_NumJoyAxes))
-
 
757
            CONTROL_LastSeenInput = LastSeenInput::Joystick;
-
 
758
    }
734
}
759
}
735
760
736
static void CONTROL_ButtonFunctionState(int32_t *p1)
761
static void CONTROL_ButtonFunctionState(int32_t *p1)
737
{
762
{
738
    if (CONTROL_NumMouseButtons)
763
    if (CONTROL_NumMouseButtons)
Line 766... Line 791...
766
    }
791
    }
767
792
768
    if (CONTROL_NumJoyButtons)
793
    if (CONTROL_NumJoyButtons)
769
    {
794
    {
770
        int i=CONTROL_NumJoyButtons-1, j;
795
        int i=CONTROL_NumJoyButtons-1, j;
-
 
796
        int retval = 0;
771
797
772
        do
798
        do
773
        {
799
        {
774
            j = CONTROL_JoyButtonMapping[i].doubleclicked;
800
            j = CONTROL_JoyButtonMapping[i].doubleclicked;
775
            if (j != KEYUNDEFINED)
801
            if (j != KEYUNDEFINED)
-
 
802
            {
776
                p1[j] |= CONTROL_JoyButtonClickedState[i];
803
                auto const state = CONTROL_JoyButtonClickedState[i];
-
 
804
                p1[j] |= state;
-
 
805
                retval |= state;
-
 
806
            }
777
807
778
            j = CONTROL_JoyButtonMapping[i].singleclicked;
808
            j = CONTROL_JoyButtonMapping[i].singleclicked;
779
            if (j != KEYUNDEFINED)
809
            if (j != KEYUNDEFINED)
-
 
810
            {
780
                p1[j] |= CONTROL_JoyButtonState[i];
811
                auto const state = CONTROL_JoyButtonState[i];
-
 
812
                p1[j] |= state;
-
 
813
                retval |= state;
-
 
814
            }
781
        }
815
        }
782
        while (i--);
816
        while (i--);
-
 
817
-
 
818
        if (retval)
-
 
819
            CONTROL_LastSeenInput = LastSeenInput::Joystick;
783
    }
820
    }
784
}
821
}
785
822
786
void CONTROL_ClearButton(int whichbutton)
823
void CONTROL_ClearButton(int whichbutton)
787
{
824
{
Line 843... Line 880...
843
880
844
    do
881
    do
845
    {
882
    {
846
        if (CONTROL_KeyBinds[i].cmdstr)
883
        if (CONTROL_KeyBinds[i].cmdstr)
847
        {
884
        {
-
 
885
            auto const keyPressed = KB_KeyPressed(i);
-
 
886
848
            if (KB_KeyPressed(i) && (CONTROL_KeyBinds[i].repeat || (CONTROL_KeyBinds[i].laststate == 0)))
887
            if (keyPressed && (CONTROL_KeyBinds[i].repeat || (CONTROL_KeyBinds[i].laststate == 0)))
-
 
888
            {
-
 
889
                CONTROL_LastSeenInput = LastSeenInput::Keyboard;
849
                OSD_Dispatch(CONTROL_KeyBinds[i].cmdstr);
890
                OSD_Dispatch(CONTROL_KeyBinds[i].cmdstr);
-
 
891
            }
850
892
851
            CONTROL_KeyBinds[i].laststate = KB_KeyPressed(i);
893
            CONTROL_KeyBinds[i].laststate = keyPressed;
852
        }
894
        }
853
    }
895
    }
854
    while (i--);
896
    while (i--);
855
}
897
}
856
898