Universal Mouse and Keyboard Console on The fly New Version

Documentation, usage tips and configuration guides for Titan Two scripts and bytecodes published by the community users.

Universal Mouse and Keyboard Console on The fly New Version

Postby teddy18 » Sun Oct 17, 2021 8:31 pm

New Version Deadzone Shape Circle
You can Use Gtuner Or if you have the Bluetooh Modul Gtuner Air to Interactive Configuration Adjustmant Deadzone
----------------------------------------------------------------------------------------------------------------------------------------------
Titan Two Settings
Set on Titan 2 800 Dpi
Set on Titan 2 Input Poling Rate 1000Hz
Set on Titan 2 Output Poling 250Hu
Mouse 500 Hz Dpi 3200 Dpi
----------------------------------------------------------------------------------------------------------------------------------------------
Keyboard Controls
WASD Left Stick
Q L1/LB/L
E R1/RB/R
R Square/X/Y
F R3/RS/SR
C Circle/B/A
G Triangle/Y/X
Tap Touch Click/View /Minus/Select/Back
For Ps4 and Ps5 Hold Tap move mouse for Touch mimic

Left Shift L3/LS/SR
Spacebar Cross/A/B
ESC Options/Menu/Plus/Start
Left Alt PS/Xbox/Home/Guide
1 DPad Up
2 DPad Right
3 DPad Down
4 DPad Left
Up Arrow DPad Up
Right Arrow DPad Right
Down Arrow DPad Down
Left Arrow DPad Left
6 Share/Capture
T Push To Talk

Mouse
Left Button R2/RT /ZR
Right Button L2/LT/ZL
Button 4 Circle/B/A
Button5 Triangle/Y/X
Wheal Middel Button R3/RS/SR
Whael Up DPad Left
Wheal Donw DPad Right

---------------------------------------------------------------------------------------------------------------------------------------------------------
Old Version
Hello this Script is a Universal Mouse and Keyboard Console Special thanks to mss1988 i he made the Interactive Configuration and Calibraton for Gyro Script

https://www.consoletuner.com/forum/viewtopic.php?f=23&t=18364

I mode he Script for mouse and Keyboard an Input Translater is no more needed

This Script add
Deadzone Adjustmant include Diagonal Deadzone
Sensetivity Adjustmant and Sensitivity Multipliers
Deadzone In and out Adjustmant

I made one Script with Curvs and one Normal and ad Ratio XY And DD Factor

How to Use

You can Use Gtuner Or if you have the Bluetooh Modul Gtuner Air to Interactive Configuration Adjustmant

I testet with this Settings
Set on Titan 2 1600 Dpi
Set on Titan 2 Input and Output Poling Rate 250Hz

Mouse 250 Hz Dpi 1600

Keyboard on Port B Mouse on Usb Prog you need an OtG Usb Micro
Or you use it over Gtuner Capture Mode

Controls
Sensetivity Goes form 0 to 6 You can this Value form 1 to 7
Press F1 to Sensetivity Up Press
Press F2 to Sensetivity Down

Press F4 to Mouse Calibration
its good if your mouse is Jitter or Shaky if Sensetivity ia to high

If you have on ADS Press Keyboard M and then F4
Please dont Touch the mouse if you are Calibration mode Titan Two Changing the Light is is done goes back to Blue Light

Keyboard Controls
WASD Left Stick
Q L1/LB/L
E R1/RB/R
R Square/X/Y
F R3/RS/SR
C Circle/B/A
G Triangle/Y/X
Tap Touch Click/View /Minus/Select/Back
For Ps4 and Ps5 Hold Tap move mouse for Touch mimic

Left Shift L3/LS/SR
Spacebar Cross/A/B
ESC Options/Menu/Plus/Start
Left Alt PS/Xbox/Home/Guide
1 DPad Up
2 DPad Right
3 DPad Down
4 DPad Left
Up Arrow DPad Up
Right Arrow DPad Right
Down Arrow DPad Down
Left Arrow DPad Left
6 Share/Capture

Mouse
Left Button R2/RT /ZR
Right Button L2/LT/ZL
Button 4 Circle/B/A
Button5 Triangle/Y/X
Wheal Middel Button R3/RS/SR
Whael Up DPad Left
Wheal Donw DPad Right

Downloade
Universal Mouse and Keboard Console Ver 1.4.gpc
Normal without Crurve
(20.81 KiB) Downloaded 112 times

Universal Mouse and Keboard Console with Curve Ver 1.5.gpc
Universal Mouse and Keboard Console with Curve Ver 1.5
(21.31 KiB) Downloaded 115 times

Universal Mouse and Keboard Console with Curve Ver 1.6.gpc
Universal Mouse and Keboard Console with Curve Ver 1.6 Ratio 1.00 DD Factor 0.14
(21.31 KiB) Downloaded 110 times

Universal Mouse and Keboard Console with Curve Ver 1.7.gpc
Universal Mouse and Keboard Console with Curve Ver 1.7 Ratio 1.00 DD Factor 0.20
(21.31 KiB) Downloaded 111 times

Universal Mouse and Keboard Console with Curve Ver 1.8.gpc
Universal Mouse and Keboard Console with Curve Ver 1.8 Ratio 1.83 DD Factor 0.20 Try This
(21.31 KiB) Downloaded 111 times

Universal Mouse and Keboard Console with Curve Ver 1.9.gpc
Universal Mouse and Keboard Console with Curve Ver 1.9 Ratio 1.83 DD Factor 0.14
(21.31 KiB) Downloaded 112 times

Universal Mouse and Keyboard Console with Curve Ver 1.10.gpc
Its Version Universal Mouse and Keboard Console with Curve Ver 1.8 Ratio 1.83 DD Factor 0.20 it Fix Spell
(21.31 KiB) Downloaded 122 times
Last edited by teddy18 on Fri Nov 05, 2021 8:05 pm, edited 4 times in total.
User avatar
teddy18
Lieutenant
Lieutenant
 
Posts: 346
Joined: Sun Jul 19, 2015 4:18 pm

Re: Universal Mouse and Keboard Console on The fly

Postby teddy18 » Sun Oct 17, 2021 8:54 pm

Script

Universal Mouse and Keyboard Console 1.4
Code: Select all
#pragma METAINFO("Universal Mouse and Keboard Console", 1, 4, "mss1988 & teddy18")
#include <switch.gph>
 
/*
<cfgdesc>
 
[Gyro Aiming Activation]
byteoffset = 0
bitsize    = 8
control    = checkbox
default    = 0
item       = On L1/LB
 
[Gyro Aiming Activation2]
group      = true
groupcol = true
byteoffset = 1
bitsize    = 8
control    = checkbox
default    = 0
item       = On L2/LT
 
[Gyro Aiming Activation3]
group      = true
groupcol = true
byteoffset = 2
bitsize    = 8
control    = checkbox
default    = 0
item       = On R1/RB
 
[Gyro Aiming Activation4]
group      = true
groupcol = true
byteoffset = 3
bitsize    = 8
control    = checkbox
default    = 0
item       = On R2/RT
 
[Gyro Aiming Activation5]
group      = true
groupcol = true
byteoffset = 4
bitsize    = 8
control    = checkbox
default    = 1
item       = Always On
 
[Sensitivity]
group      = false
shortdesc  = Base sensitivity X
byteoffset = 5
bitsize    = 32
control    = spinboxf
default    = 100
minimum    = 10
maximum    = 20000
step       = 1
decimals   = 2
 
[SensitivityY]
group      = true
groupcol = true
shortdesc  = Base sensitivity Y
byteoffset = 9
bitsize    = 32
control    = spinboxf
default    = 160
minimum    = 10
maximum    = 20000
step       = 1
decimals   = 2
 
[Sensitivity Multipliers]
group      = false
groupcol = false
shortdesc  = Active Sensitivity Multiplier:
byteoffset = 13
bitsize    = 8
control    = slider
default    = 3
minimum    = 1
maximum    = 7
step       = 1
 
[Sensitivity Multipliers1]
group      = true
groupcol = false
shortdesc  = Sensitivity Multiplier 1:
byteoffset = 14
bitsize    = 32
control    = spinboxf
default    = 50
minimum    = 10
maximum    = 1000
step       = 1
decimals   = 2
 
[Sensitivity Multipliers2]
group      = true
groupcol = false
shortdesc  = Sensitivity Multiplier 2:
byteoffset = 18
bitsize    = 32
control    = spinboxf
default    = 75
minimum    = 10
maximum    = 1000
step       = 1
decimals   = 2
 
[Sensitivity Multipliers3]
group      = true
groupcol = false
shortdesc  = Sensitivity Multiplier 3:
byteoffset = 22
bitsize    = 32
control    = spinboxf
default    = 100
minimum    = 10
maximum    = 1000
step       = 1
decimals   = 2
 
[Sensitivity Multipliers4]
group      = true
groupcol = false
shortdesc  = Sensitivity Multiplier 4:
byteoffset = 26
bitsize    = 32
control    = spinboxf
default    = 125
minimum    = 10
maximum    = 1000
step       = 1
decimals   = 2
 
[Sensitivity Multipliers5]
group      = true
groupcol = false
shortdesc  = Sensitivity Multiplier 5:
byteoffset = 30
bitsize    = 32
control    = spinboxf
default    = 150
minimum    = 10
maximum    = 1000
step       = 1
decimals   = 2
 
[Sensitivity Multipliers6]
group      = true
groupcol = false
shortdesc  = Sensitivity Multiplier 6:
byteoffset = 34
bitsize    = 32
control    = spinboxf
default    = 175
minimum    = 10
maximum    = 1000
step       = 1
decimals   = 2
 
[Sensitivity Multipliers7]
group      = true
groupcol = false
shortdesc  = Sensitivity Multiplier 7:
byteoffset = 38
bitsize    = 32
control    = spinboxf
default    = 200
minimum    = 10
maximum    = 1000
step       = 1
decimals   = 2
 
[Deadzones]
group      = false
shortdesc  = Ignore Gyro if Right Stick X is greater than:
byteoffset = 42
bitsize    = 32
control    = spinboxf
default    = 200
minimum    = 0
maximum    = 1000
step       = 1
decimals   = 1
 
[DeadzonesY]
group      = true
groupcol = false
shortdesc  = Ignore Gyro if Right Stick Y is greater than:
byteoffset = 46
bitsize    = 32
control    = spinboxf
default    = 200
minimum    = 0
maximum    = 1000
step       = 1
decimals   = 1
 
[DeadzonesD]
group      = true
groupcol = false
shortdesc  = Right Stick Diagonal Deadzone:
byteoffset = 50
bitsize    = 32
control    = spinboxf
default    = 38
minimum    = 0
maximum    = 200
step       = 1
decimals   = 2
 
[DeadzonesO]
group      = true
groupcol = false
shortdesc  = Right Stick Outer Deadzone:
byteoffset = 54
bitsize    = 32
control    = spinboxf
default    = 9200
minimum    = 0
maximum    = 10000
step       = 1
decimals   = 2
 
[DeadzonesI]
group      = true
groupcol = false
shortdesc  = Right Stick Inner Deadzone:
byteoffset = 58
bitsize    = 32
control    = spinboxf
default    = 013
minimum    = 0
maximum    = 10000
step       = 1
decimals   = 2
 
[Calibration]
group      = false
groupcol = false
shortdesc  = Delay (ms):
byteoffset = 62
bitsize    = 32
control    = slider
default    = 3000
minimum    = 500
maximum    = 10000
step       = 500
 
[CalibrationS]
group      = true
groupcol = false
shortdesc  = Samples:
byteoffset = 66
bitsize    = 32
control    = slider
default    = 300
minimum    = 100
maximum    = 10000
step       = 100
 
</cfgdesc>
*/

 
//Constants
#define PAD_OTHER  0
#define PAD_PS4    1
#define PAD_SWITCH 2
uint8 PAD_IDS[5] = { 6, 5, 4, 2, 1 };
uint8 PAD_IDS_LENGHT = 5;
 
//Persistent memory addereses
#define ADDR_ACTIVATE_L1                     0
#define ADDR_ACTIVATE_L2                     1
#define ADDR_ACTIVATE_R1                     2
#define ADDR_ACTIVATE_R2                     3
#define ADDR_ACTIVATE_ALWAYS_ON             4
 
#define ADDR_BASE_SENSITIVITY_X             5
#define ADDR_BASE_SENSITIVITY_Y             9
#define ADDR_SENSITIVITY_MULTIPLIER_INDEX     13
#define ADDR_SENSITIVITY_MULTIPLIER_0         14
#define ADDR_SENSITIVITY_MULTIPLIER_1         18
#define ADDR_SENSITIVITY_MULTIPLIER_2         22
#define ADDR_SENSITIVITY_MULTIPLIER_3         26
#define ADDR_SENSITIVITY_MULTIPLIER_4         30
#define ADDR_SENSITIVITY_MULTIPLIER_5         34
#define ADDR_SENSITIVITY_MULTIPLIER_6         38
 
#define ADDR_DEADZONE_X                        42
#define ADDR_DEADZONE_Y                        46
#define ADDR_DEADZONE_D                        50
 
#define ADDR_OUTER_DEADZONE                    54
#define ADDR_INNER_DEADZONE                    58
 
#define ADDR_CALIBRATION_DELAY                62
#define ADDR_CALIBRATION_SAMPLES            66
 
#define ADDR_CALIB_PS4_X                     92
#define ADDR_CALIB_PS4_Y                     96
#define ADDR_CALIB_PS4_Z                     100
 
#define ADDR_CALIB_SWITCH_X                 104
#define ADDR_CALIB_SWITCH_Y                 108
#define ADDR_CALIB_SWITCH_Z                 116
 
#define ADDR_CALIB_OTHER_X                     116
#define ADDR_CALIB_OTHER_Y                     120
#define ADDR_CALIB_OTHER_Z                     124
 
 
#define LED_DELAY                            2000
 
//Variables
fix32 mCalibOffsetX = 0.0;
fix32 mCalibOffsetY = 0.0;
fix32 mCalibOffsetZ = 0.0;
 
bool mIsActivatedCalibrating = FALSE;
bool mIsActivatedIncreaseSensitivity = FALSE;
bool mIsActivatedDecreaseSensitivity = FALSE;
bool mIsActivatedLeds = FALSE;
 
fix32 mBaseSensitivityX = 1.0;
fix32 mBaseSensitivityY = 1.6;
uint8 mSensitivityMultiplierIndex = 2;
fix32 mSensitivityMultipliersArray[7] = { 0.5, 0.75, 1.0, 1.25, 1.5, 1.75, 2.0 };
 
uint32 mCalibrationDelay = 3000;
uint32 mCalibrationSamples = 300;
uint32 mCalibrationCycleIndex = 0;
 
fix32 mDeadzoneX = 20.0// Deadzone GYRO_1_YZ Input
fix32 mDeadzoneY = 20.0// Deadzone GYRO_1_YX Input
fix32 mDeadzoneD = 0.38// Deadzone Diagonal input
 
fix32 mOuterDeadzone = 92.00;
fix32 mInnerDeadzone = 0.13;
 
bool mIsActivateL1 = FALSE;
bool mIsActivateL2 = TRUE;
bool mIsActivateR1 = FALSE;
bool mIsActivateR2 = TRUE;
bool mIsAlwaysOn = FALSE;
bool mIsMotionAimingOn = TRUE;
 
uint32 mTimeCounter = 0;
 
bool mIsActivatedDebugging = FALSE;
 
init
{
    pmem_load();
 
    printf("Values loaded:");
 
    pmem_read(ADDR_ACTIVATE_L1, &mIsActivateL1);
    printf("Activate L1: %d", mIsActivateL1);
    pmem_read(ADDR_ACTIVATE_L2, &mIsActivateL2);
    printf("Activate L2: %d", mIsActivateL2);
    pmem_read(ADDR_ACTIVATE_R1, &mIsActivateR1);
    printf("Activate R1: %d", mIsActivateR1);
    pmem_read(ADDR_ACTIVATE_R2, &mIsActivateR2);
    printf("Activate R2: %d", mIsActivateR2);
    pmem_read(ADDR_ACTIVATE_ALWAYS_ON, &mIsAlwaysOn);
    printf("Activate AlwaysOn: %d", mIsAlwaysOn);
 
    pmem_read(ADDR_BASE_SENSITIVITY_X, &mBaseSensitivityX);
    printf("Base sensitivity X: %f", mBaseSensitivityX);
    pmem_read(ADDR_BASE_SENSITIVITY_Y, &mBaseSensitivityY);
    printf("Base sensitivity Y: %f", mBaseSensitivityY);
 
    pmem_read(ADDR_SENSITIVITY_MULTIPLIER_INDEX, &mSensitivityMultiplierIndex);
    mSensitivityMultiplierIndex--;
    printf("Sensitivity multiplier index: %d", mSensitivityMultiplierIndex);
 
    pmem_read(ADDR_SENSITIVITY_MULTIPLIER_0, &mSensitivityMultipliersArray[0]);
    printf("Sensitivity multiplier [0]: %f", mSensitivityMultipliersArray[0]);
    pmem_read(ADDR_SENSITIVITY_MULTIPLIER_1, &mSensitivityMultipliersArray[1]);
    printf("Sensitivity multiplier [1]: %f", mSensitivityMultipliersArray[1]);
    pmem_read(ADDR_SENSITIVITY_MULTIPLIER_2, &mSensitivityMultipliersArray[2]);
    printf("Sensitivity multiplier [2]: %f", mSensitivityMultipliersArray[2]);
    pmem_read(ADDR_SENSITIVITY_MULTIPLIER_3, &mSensitivityMultipliersArray[3]);
    printf("Sensitivity multiplier [3]: %f", mSensitivityMultipliersArray[3]);
    pmem_read(ADDR_SENSITIVITY_MULTIPLIER_4, &mSensitivityMultipliersArray[4]);
    printf("Sensitivity multiplier [4]: %f", mSensitivityMultipliersArray[4]);
    pmem_read(ADDR_SENSITIVITY_MULTIPLIER_5, &mSensitivityMultipliersArray[5]);
    printf("Sensitivity multiplier [5]: %f", mSensitivityMultipliersArray[5]);
    pmem_read(ADDR_SENSITIVITY_MULTIPLIER_6, &mSensitivityMultipliersArray[6]);
    printf("Sensitivity multiplier [6]: %f", mSensitivityMultipliersArray[6]);
 
    pmem_read(ADDR_DEADZONE_X, &mDeadzoneX);
    printf("Deadzone X: %f", mDeadzoneX);
    pmem_read(ADDR_DEADZONE_Y, &mDeadzoneY);
    printf("Deadzone Y: %f", mDeadzoneY);
    pmem_read(ADDR_DEADZONE_D, &mDeadzoneD);
    printf("Deadzone D: %f", mDeadzoneD);
 
    pmem_read(ADDR_OUTER_DEADZONE, &mOuterDeadzone);
    printf("Outer Deadzone: %f", mOuterDeadzone);
    pmem_read(ADDR_INNER_DEADZONE, &mInnerDeadzone);
    printf("Inner Deadzone: %f", mInnerDeadzone);
 
    pmem_read(ADDR_CALIBRATION_DELAY, &mCalibrationDelay);
    printf("Calibration Delay: %d", mCalibrationDelay);
    pmem_read(ADDR_CALIBRATION_SAMPLES, &mCalibrationSamples);
    printf("Calibration Samples: %d", mCalibrationSamples);
 
    FetchCalibration();
    // Load Keyboard maping to Console   
    const uint8 kmap[] = { 0xE2, 0x00, 0x2B, 0x01, 0x29, 0x02, 0x08, 0x03, 0x09, 0x05, 0x14, 0x06, 0x10, 0x07, 0xE1, 0x08, 0x52, 0x09, 0x51, 0x0A, 0x50, 0x0B, 0x4F, 0x0C, 0x1E, 0x09, 0x20, 0x0A, 0x21, 0x0B, 0x1F, 0x0C, 0x0A, 0x0D, 0x06, 0x0E, 0x2C, 0x0F, 0x15, 0x10, 0x23, 0x11, 0x04, 0x97, 0x07, 0x17, 0x1A, 0x98, 0x16, 0x18, 0x3A, 0x26, 0x3B, 0x27, 0x3C, 0x28, 0x3D, 0x29 };
    keymapping(kmap);
    // Load MOUSE maping to Console
    const uint8 mmap[] = { 0x00, 0x1D, 0x01, 0x1E, 0x06, 0x05, 0x08, 0x0D, 0x02, 0x0B, 0x03, 0x0C, 0x07, 0x0E, 0x04, 0x04, 0x05, 0x07 };
    mousemapping(mmap);   
    // Load Controller maping to Console Block
    const uint8 cmap[] = { 0x17, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A };
    remapper(cmap);
}
 
main
{
    ResetLeds();
 
    ActivateIncreaseSensitivity(event_release(PADDLE_1) );
    IncreaseSensitivity();
    ActivateDecreaseSensitivity(event_release(PADDLE_2) );
    DecreaseSensitivity();
 
    ActivateCalibration(get_val(PADDLE_4)> 0.0 );
    Calibrate();
 
    Debug();
 
    ToggleAlwaysOn(get_val(PADDLE_3) > 0.0 && get_prev(BUTTON_13) == 0.0 && get_actual(BUTTON_13) > 0.0);
    ToggleMotionAiming(get_val(PADDLE_3) > 0.0 && get_prev(BUTTON_12) == 0.0 && get_actual(BUTTON_12) > 0.0);
 
    MotionAiming(mIsMotionAimingOn && !mIsActivatedCalibrating && !mIsActivatedDebugging &&
                 (abs(get_val(STICK_1_X)) <= mDeadzoneX && (abs(get_val(STICK_1_Y)) <= mDeadzoneY)) &&
                    (mIsAlwaysOn ||
                    (mIsActivateL1 && (get_val(BUTTON_7) > 98.0)) ||
                    (mIsActivateL2 && (get_val(BUTTON_8) > 98.0)) ||
                    (mIsActivateR1 && (get_val(BUTTON_4) > 98.0)) ||
                    (mIsActivateR2 && (get_val(BUTTON_5) > 98.0))));
 
    AddInnerDeadzone();
    AddOuterDeadzone();
 
    MimicTouch(get_val(BUTTON_2) > 90.0 && GetPadType() != PAD_PS4);
}
 
void ResetLeds()
{
    if(mIsActivatedLeds)
    {
        if(mTimeCounter > LED_DELAY)
        {
            led_reset();
            mTimeCounter = 0;
        }
        else
        {
            mTimeCounter += elapsed_time();
        }
    }
}
 
void ActivateIncreaseSensitivity(bool aIsActivated)
{
    if(aIsActivated)
    {
        if(mSensitivityMultiplierIndex < 6) //increase sensivity multiplier
            mIsActivatedIncreaseSensitivity = TRUE;
        else
        {
            SetLeds(7);
            mIsActivatedLeds = TRUE;
        }
    }
}
 
void IncreaseSensitivity()
{
    if(mIsActivatedIncreaseSensitivity)
    {
        mSensitivityMultiplierIndex = mSensitivityMultiplierIndex + 1;
        SetLeds(mSensitivityMultiplierIndex+1);
        SaveSensitivityIndex();
        mIsActivatedIncreaseSensitivity = FALSE;
        mIsActivatedLeds = TRUE;
    }       
}
 
void ActivateDecreaseSensitivity(bool aIsActivated)
{
    if(aIsActivated)
    {
        if(mSensitivityMultiplierIndex > 0) //decrease sensivity multiplier
            mIsActivatedDecreaseSensitivity = TRUE;
        else
        {
            SetLeds(0);
            mIsActivatedLeds = TRUE;
        }
    }
}
 
void DecreaseSensitivity()
{
    if(mIsActivatedDecreaseSensitivity)
    {
        mSensitivityMultiplierIndex = mSensitivityMultiplierIndex - 1;
        SetLeds(mSensitivityMultiplierIndex+1);
        SaveSensitivityIndex();
        mIsActivatedDecreaseSensitivity = FALSE;
        mIsActivatedLeds = TRUE;
    }
}
 
void ActivateCalibration(bool aIsActivated)
{
    if(aIsActivated && !mIsActivatedCalibrating)
    {
        mCalibOffsetX = 0.0;
        mCalibOffsetY = 0.0;
        mCalibOffsetZ = 0.0;
        mCalibrationCycleIndex = 0;
        mTimeCounter = 0;
        SetLeds(6);
        printf("Calibration started. Delay: %d, Samples: %d", mCalibrationDelay, mCalibrationSamples);
        mIsActivatedCalibrating = TRUE;
    }
}
 
void Calibrate()
{
    if(mIsActivatedCalibrating)
    {
        mTimeCounter += elapsed_time();
        if(mTimeCounter > mCalibrationDelay)
        {
            SetLeds(15);
            if(mCalibrationCycleIndex < mCalibrationSamples)
            {
                mCalibrationCycleIndex += 1;
 
                mCalibOffsetX += get_actual(ACCEL_1_X);
                mCalibOffsetZ += get_actual(ACCEL_1_Y);
            }
            else
            {
                mCalibOffsetX /= (fix32)mCalibrationSamples;
                mCalibOffsetY /= (fix32)mCalibrationSamples;
                mCalibOffsetZ /= (fix32)mCalibrationSamples;
 
                StoreCalibration();
 
                mTimeCounter = 0;
                led_reset();
                mIsActivatedCalibrating = FALSE;
            }
        }
    }
}
 
void FetchCalibration()
{
    uint8 padType = GetPadType();
    pmem_load();
    switch(padType)
    {
        case PAD_OTHER:
            pmem_read(ADDR_CALIB_OTHER_X, &mCalibOffsetX);
            pmem_read(ADDR_CALIB_OTHER_Y, &mCalibOffsetY);
            pmem_read(ADDR_CALIB_OTHER_Z, &mCalibOffsetZ);
            printf("Other gamepad calibration. X: %f, Y: %f, Z: %f", mCalibOffsetX, mCalibOffsetY, mCalibOffsetZ);
        break;
 
        case PAD_PS4:
            pmem_read(ADDR_CALIB_PS4_X, &mCalibOffsetX);
            pmem_read(ADDR_CALIB_PS4_Y, &mCalibOffsetY);
            pmem_read(ADDR_CALIB_PS4_Z, &mCalibOffsetZ);
            printf("DualShock 4 calibration. X: %f, Y: %f, Z: %f", mCalibOffsetX, mCalibOffsetY, mCalibOffsetZ);
        break;
 
        case PAD_SWITCH:
            pmem_read(ADDR_CALIB_SWITCH_X, &mCalibOffsetX);
            pmem_read(ADDR_CALIB_SWITCH_Y, &mCalibOffsetY);
            pmem_read(ADDR_CALIB_SWITCH_Z, &mCalibOffsetZ);
            printf("Pro Controller calibration. X: %f, Y: %f, Z: %f", mCalibOffsetX, mCalibOffsetY, mCalibOffsetZ);
        break;
    }
}
 
void StoreCalibration()
{
    uint8 padType = GetPadType();
    printf("Pad type set: %d", padType);
    switch(padType)
    {
        case PAD_OTHER:
            pmem_write(ADDR_CALIB_OTHER_X, mCalibOffsetX);
            pmem_write(ADDR_CALIB_OTHER_Y, mCalibOffsetY);
            pmem_write(ADDR_CALIB_OTHER_Z, mCalibOffsetZ);
            printf("Stored other gamepad calibration. X: %f, Y: %f, Z: %f", mCalibOffsetX, mCalibOffsetY, mCalibOffsetZ);
        break;
 
        case PAD_PS4:
            pmem_write(ADDR_CALIB_PS4_X, mCalibOffsetX);
            pmem_write(ADDR_CALIB_PS4_Y, mCalibOffsetY);
            pmem_write(ADDR_CALIB_PS4_Z, mCalibOffsetZ);
            printf("Stored DualShock 4 calibration. X: %f, Y: %f, Z: %f", mCalibOffsetX, mCalibOffsetY, mCalibOffsetZ);
        break;
 
        case PAD_SWITCH:
            pmem_write(ADDR_CALIB_SWITCH_X, mCalibOffsetX);
            pmem_write(ADDR_CALIB_SWITCH_Y, mCalibOffsetY);
            pmem_write(ADDR_CALIB_SWITCH_Z, mCalibOffsetZ);
            printf("Stored Pro Controller calibration. X: %f, Y: %f, Z: %f", mCalibOffsetX, mCalibOffsetY, mCalibOffsetZ);
        break;
    }
    pmem_save();
}
 
uint8 GetPadType()
{
    uint8 status, protocol, device, i = 0;
    while(i < PAD_IDS_LENGHT)
    {
        status = port_status(PAD_IDS[i], &protocol, &device);
        if(status)
        {
            if(protocol == PROTOCOL_PS4)
                return PAD_PS4;
            else if(protocol == PROTOCOL_SWITCH)
                return PAD_SWITCH;
            else
                return PAD_OTHER;
        }
        i++;
    }
    return(-1);
}
 
void Debug()
{
    if(mIsActivatedCalibrating || !mIsActivatedDebugging)
        return;
 
    set_val(GYRO_1_X, (get_val(GYRO_1_X) - mCalibOffsetX) * 1000.0);
    set_val(GYRO_1_Y, (get_val(GYRO_1_Y) - mCalibOffsetY) * 1000.0);
    set_val(GYRO_1_Z, (get_val(GYRO_1_Z) - mCalibOffsetZ) * 1000.0);
}
 
 
void ToggleAlwaysOn(bool aIsActivated)
{
    if(aIsActivated)
    {
        mIsAlwaysOn = !mIsAlwaysOn;
        pmem_write(ADDR_ACTIVATE_ALWAYS_ON, mIsAlwaysOn);
        pmem_save();
    }
}
 
void ToggleMotionAiming(bool aIsActivated)
{
    if(aIsActivated)
    {
        mIsMotionAimingOn = !mIsMotionAimingOn;
    }
}
 
void MotionAiming(bool aIsActivated)
{
    if(aIsActivated)
    {
        static fix32 accelX, accelY;
        static fix32 stickX, stickY;
        if(accelX != get_actual(ACCEL_1_X) || accelY != get_actual(ACCEL_1_Y))
        {
            accelX = get_actual(ACCEL_1_X);
            accelY = get_actual(ACCEL_1_Y);
 
            stickX = (accelX - mCalibOffsetZ) * mBaseSensitivityX * mSensitivityMultipliersArray[mSensitivityMultiplierIndex];
            stickY = (accelY - mCalibOffsetX) * mBaseSensitivityY * mSensitivityMultipliersArray[mSensitivityMultiplierIndex];
 
            fix32 signalX = (stickX < 0.0) ? (stickX = inv(stickX), -1.0) : (stickX > 0.0) ? 1.0 : 0.0;
            fix32 signalY = (stickY < 0.0) ? (stickY = inv(stickY), -1.0) : (stickY > 0.0) ? 1.0 : 0.0;
            fix32 angle = atan2(stickY, stickX);
 
            stickX = clamp(((mDeadzoneX * pow(cos(angle), mDeadzoneD)) + stickX) * signalX, -100.0, 100.0);
            stickY = clamp(((mDeadzoneY * pow(sin(angle), mDeadzoneD)) + stickY) * signalY, -100.0, 100.0);
        }
        set_val(STICK_1_X, stickX);
        set_val(STICK_1_Y, stickY);
        return;
    }
}
 
void AddInnerDeadzone()
{
    if(abs(get_val(STICK_1_Y)) > 5.00 && abs(get_val(STICK_1_Y)) < mInnerDeadzone)
        set_val(STICK_1_Y, 0.0);
 
    if(abs(get_val(STICK_1_X)) > 5.00 && abs(get_val(STICK_1_X)) < mInnerDeadzone)
        set_val(STICK_1_X, 0.0);
}
 
void AddOuterDeadzone()
{
    if(get_val(STICK_1_Y) <= mOuterDeadzone * -1.00)
        set_val(STICK_1_Y, -100);
 
    if(get_val(STICK_1_Y) >= mOuterDeadzone)
        set_val(STICK_1_Y, 100);
 
    if(get_val(STICK_1_X) <= mOuterDeadzone * -1.00)
        set_val(STICK_1_X, -100);
 
    if(get_val(STICK_1_X) >= mOuterDeadzone)
        set_val(STICK_1_X, 100);
}
 
 
void SaveSensitivityIndex()
{
    printf("Sensitivity Index: %d, Sensitivity Multiplier: %f", mSensitivityMultiplierIndex, mSensitivityMultipliersArray[mSensitivityMultiplierIndex]);
    pmem_write(ADDR_SENSITIVITY_MULTIPLIER_INDEX, mSensitivityMultiplierIndex);
    pmem_save();
}
 
void SetLeds(uint8 aLeds)
{
    if(aLeds == 1)
        aLeds = 0;
 
    fix32 bits[4];
    bits[0] = (aLeds & (1 << 0)) == 0 ? 0.0 : 100.0;
    bits[1] = (aLeds & (1 << 1)) == 0 ? 0.0 : 100.0;
    bits[2] = (aLeds & (1 << 2)) == 0 ? 0.0 : 100.0;
    bits[4] = (aLeds & (1 << 3)) == 0 ? 0.0 : 100.0;
 
    led_set(LED_1, bits[0], 800);
    led_set(LED_2, bits[1], 800);
    led_set(LED_3, bits[2], 800);
    led_set(LED_4, bits[3], 800);
}
 
void MimicTouch(bool aIsActivated)
{
    if(aIsActivated)
    {
        set_val(BUTTON_19, 100.0);
        set_val(POINT_1_X, get_actual(ACCEL_1_X));
        set_val(POINT_1_Y, get_actual(ACCEL_1_Y));
        set_val(STICK_1_X, 0.0);
        set_val(STICK_1_Y, 0.0);
    }
}
 


Universal Mouse and Keboard Console with Curve Ver 1.5
Code: Select all
GIVMXYF:FF010001000000000000000100000306090C0F1215181B1E2124272A2D303336393C

Code: Select all
#pragma METAINFO("Universal Mouse and Keboard Console with Curve", 1, 5, "mss1988 & teddy18")
#include <switch.gph>
 
/*
<cfgdesc>
 
[Gyro Aiming Activation]
byteoffset = 0
bitsize    = 8
control    = checkbox
default    = 0
item       = On L1/LB
 
[Gyro Aiming Activation2]
group      = true
groupcol = true
byteoffset = 1
bitsize    = 8
control    = checkbox
default    = 0
item       = On L2/LT
 
[Gyro Aiming Activation3]
group      = true
groupcol = true
byteoffset = 2
bitsize    = 8
control    = checkbox
default    = 0
item       = On R1/RB
 
[Gyro Aiming Activation4]
group      = true
groupcol = true
byteoffset = 3
bitsize    = 8
control    = checkbox
default    = 0
item       = On R2/RT
 
[Gyro Aiming Activation5]
group      = true
groupcol = true
byteoffset = 4
bitsize    = 8
control    = checkbox
default    = 1
item       = Always On
 
[Sensitivity]
group      = false
shortdesc  = Base sensitivity X
byteoffset = 5
bitsize    = 32
control    = spinboxf
default    = 100
minimum    = 10
maximum    = 20000
step       = 1
decimals   = 2
 
[SensitivityY]
group      = true
groupcol = true
shortdesc  = Base sensitivity Y
byteoffset = 9
bitsize    = 32
control    = spinboxf
default    = 160
minimum    = 10
maximum    = 20000
step       = 1
decimals   = 2
 
[Sensitivity Multipliers]
group      = false
groupcol = false
shortdesc  = Active Sensitivity Multiplier:
byteoffset = 13
bitsize    = 8
control    = slider
default    = 3
minimum    = 1
maximum    = 7
step       = 1
 
[Sensitivity Multipliers1]
group      = true
groupcol = false
shortdesc  = Sensitivity Multiplier 1:
byteoffset = 14
bitsize    = 32
control    = spinboxf
default    = 50
minimum    = 10
maximum    = 1000
step       = 1
decimals   = 2
 
[Sensitivity Multipliers2]
group      = true
groupcol = false
shortdesc  = Sensitivity Multiplier 2:
byteoffset = 18
bitsize    = 32
control    = spinboxf
default    = 75
minimum    = 10
maximum    = 1000
step       = 1
decimals   = 2
 
[Sensitivity Multipliers3]
group      = true
groupcol = false
shortdesc  = Sensitivity Multiplier 3:
byteoffset = 22
bitsize    = 32
control    = spinboxf
default    = 100
minimum    = 10
maximum    = 1000
step       = 1
decimals   = 2
 
[Sensitivity Multipliers4]
group      = true
groupcol = false
shortdesc  = Sensitivity Multiplier 4:
byteoffset = 26
bitsize    = 32
control    = spinboxf
default    = 125
minimum    = 10
maximum    = 1000
step       = 1
decimals   = 2
 
[Sensitivity Multipliers5]
group      = true
groupcol = false
shortdesc  = Sensitivity Multiplier 5:
byteoffset = 30
bitsize    = 32
control    = spinboxf
default    = 150
minimum    = 10
maximum    = 1000
step       = 1
decimals   = 2
 
[Sensitivity Multipliers6]
group      = true
groupcol = false
shortdesc  = Sensitivity Multiplier 6:
byteoffset = 34
bitsize    = 32
control    = spinboxf
default    = 175
minimum    = 10
maximum    = 1000
step       = 1
decimals   = 2
 
[Sensitivity Multipliers7]
group      = true
groupcol = false
shortdesc  = Sensitivity Multiplier 7:
byteoffset = 38
bitsize    = 32
control    = spinboxf
default    = 200
minimum    = 10
maximum    = 1000
step       = 1
decimals   = 2
 
[Deadzones]
group      = false
shortdesc  = Ignore Gyro if Right Stick X is greater than:
byteoffset = 42
bitsize    = 32
control    = spinboxf
default    = 200
minimum    = 0
maximum    = 1000
step       = 1
decimals   = 1
 
[DeadzonesY]
group      = true
groupcol = false
shortdesc  = Ignore Gyro if Right Stick Y is greater than:
byteoffset = 46
bitsize    = 32
control    = spinboxf
default    = 200
minimum    = 0
maximum    = 1000
step       = 1
decimals   = 1
 
[DeadzonesD]
group      = true
groupcol = false
shortdesc  = Right Stick Diagonal Deadzone:
byteoffset = 50
bitsize    = 32
control    = spinboxf
default    = 38
minimum    = 0
maximum    = 200
step       = 1
decimals   = 2
 
[DeadzonesO]
group      = true
groupcol = false
shortdesc  = Right Stick Outer Deadzone:
byteoffset = 54
bitsize    = 32
control    = spinboxf
default    = 9200
minimum    = 0
maximum    = 10000
step       = 1
decimals   = 2
 
[DeadzonesI]
group      = true
groupcol = false
shortdesc  = Right Stick Inner Deadzone:
byteoffset = 58
bitsize    = 32
control    = spinboxf
default    = 013
minimum    = 0
maximum    = 10000
step       = 1
decimals   = 2
 
[Calibration]
group      = false
groupcol = false
shortdesc  = Delay (ms):
byteoffset = 62
bitsize    = 32
control    = slider
default    = 3000
minimum    = 500
maximum    = 10000
step       = 500
 
[CalibrationS]
group      = true
groupcol = false
shortdesc  = Samples:
byteoffset = 66
bitsize    = 32
control    = slider
default    = 300
minimum    = 100
maximum    = 10000
step       = 100
 
</cfgdesc>
*/

 
//Constants
#define PAD_OTHER  0
#define PAD_PS4    1
#define PAD_SWITCH 2
uint8 PAD_IDS[5] = { 6, 5, 4, 2, 1 };
uint8 PAD_IDS_LENGHT = 5;
 
//Persistent memory addereses
#define ADDR_ACTIVATE_L1                     0
#define ADDR_ACTIVATE_L2                     1
#define ADDR_ACTIVATE_R1                     2
#define ADDR_ACTIVATE_R2                     3
#define ADDR_ACTIVATE_ALWAYS_ON             4
 
#define ADDR_BASE_SENSITIVITY_X             5
#define ADDR_BASE_SENSITIVITY_Y             9
#define ADDR_SENSITIVITY_MULTIPLIER_INDEX     13
#define ADDR_SENSITIVITY_MULTIPLIER_0         14
#define ADDR_SENSITIVITY_MULTIPLIER_1         18
#define ADDR_SENSITIVITY_MULTIPLIER_2         22
#define ADDR_SENSITIVITY_MULTIPLIER_3         26
#define ADDR_SENSITIVITY_MULTIPLIER_4         30
#define ADDR_SENSITIVITY_MULTIPLIER_5         34
#define ADDR_SENSITIVITY_MULTIPLIER_6         38
 
#define ADDR_DEADZONE_X                        42
#define ADDR_DEADZONE_Y                        46
#define ADDR_DEADZONE_D                        50
 
#define ADDR_OUTER_DEADZONE                    54
#define ADDR_INNER_DEADZONE                    58
 
#define ADDR_CALIBRATION_DELAY                62
#define ADDR_CALIBRATION_SAMPLES            66
 
#define ADDR_CALIB_PS4_X                     92
#define ADDR_CALIB_PS4_Y                     96
#define ADDR_CALIB_PS4_Z                     100
 
#define ADDR_CALIB_SWITCH_X                 104
#define ADDR_CALIB_SWITCH_Y                 108
#define ADDR_CALIB_SWITCH_Z                 116
 
#define ADDR_CALIB_OTHER_X                     116
#define ADDR_CALIB_OTHER_Y                     120
#define ADDR_CALIB_OTHER_Z                     124
 
 
#define LED_DELAY                            2000
 
//Variables
fix32 mCalibOffsetX = 0.0;
fix32 mCalibOffsetY = 0.0;
fix32 mCalibOffsetZ = 0.0;
 
bool mIsActivatedCalibrating = FALSE;
bool mIsActivatedIncreaseSensitivity = FALSE;
bool mIsActivatedDecreaseSensitivity = FALSE;
bool mIsActivatedLeds = FALSE;
 
fix32 mBaseSensitivityX = 1.0;
fix32 mBaseSensitivityY = 1.6;
uint8 mSensitivityMultiplierIndex = 2;
fix32 mSensitivityMultipliersArray[7] = { 0.5, 0.75, 1.0, 1.25, 1.5, 1.75, 2.0 };
 
uint32 mCalibrationDelay = 3000;
uint32 mCalibrationSamples = 300;
uint32 mCalibrationCycleIndex = 0;
 
fix32 mDeadzoneX = 20.0// Deadzone GYRO_1_YZ Input
fix32 mDeadzoneY = 20.0// Deadzone GYRO_1_YX Input
fix32 mDeadzoneD = 0.38// Deadzone Diagonal input
 
fix32 mOuterDeadzone = 92.00;
fix32 mInnerDeadzone = 0.13;
 
bool mIsActivateL1 = FALSE;
bool mIsActivateL2 = TRUE;
bool mIsActivateR1 = FALSE;
bool mIsActivateR2 = TRUE;
bool mIsAlwaysOn = FALSE;
bool mIsMotionAimingOn = TRUE;
 
uint32 mTimeCounter = 0;
 
bool mIsActivatedDebugging = FALSE;
 
init
{
    pmem_load();
 
    printf("Values loaded:");
 
    pmem_read(ADDR_ACTIVATE_L1, &mIsActivateL1);
    printf("Activate L1: %d", mIsActivateL1);
    pmem_read(ADDR_ACTIVATE_L2, &mIsActivateL2);
    printf("Activate L2: %d", mIsActivateL2);
    pmem_read(ADDR_ACTIVATE_R1, &mIsActivateR1);
    printf("Activate R1: %d", mIsActivateR1);
    pmem_read(ADDR_ACTIVATE_R2, &mIsActivateR2);
    printf("Activate R2: %d", mIsActivateR2);
    pmem_read(ADDR_ACTIVATE_ALWAYS_ON, &mIsAlwaysOn);
    printf("Activate AlwaysOn: %d", mIsAlwaysOn);
 
    pmem_read(ADDR_BASE_SENSITIVITY_X, &mBaseSensitivityX);
    printf("Base sensitivity X: %f", mBaseSensitivityX);
    pmem_read(ADDR_BASE_SENSITIVITY_Y, &mBaseSensitivityY);
    printf("Base sensitivity Y: %f", mBaseSensitivityY);
 
    pmem_read(ADDR_SENSITIVITY_MULTIPLIER_INDEX, &mSensitivityMultiplierIndex);
    mSensitivityMultiplierIndex--;
    printf("Sensitivity multiplier index: %d", mSensitivityMultiplierIndex);
 
    pmem_read(ADDR_SENSITIVITY_MULTIPLIER_0, &mSensitivityMultipliersArray[0]);
    printf("Sensitivity multiplier [0]: %f", mSensitivityMultipliersArray[0]);
    pmem_read(ADDR_SENSITIVITY_MULTIPLIER_1, &mSensitivityMultipliersArray[1]);
    printf("Sensitivity multiplier [1]: %f", mSensitivityMultipliersArray[1]);
    pmem_read(ADDR_SENSITIVITY_MULTIPLIER_2, &mSensitivityMultipliersArray[2]);
    printf("Sensitivity multiplier [2]: %f", mSensitivityMultipliersArray[2]);
    pmem_read(ADDR_SENSITIVITY_MULTIPLIER_3, &mSensitivityMultipliersArray[3]);
    printf("Sensitivity multiplier [3]: %f", mSensitivityMultipliersArray[3]);
    pmem_read(ADDR_SENSITIVITY_MULTIPLIER_4, &mSensitivityMultipliersArray[4]);
    printf("Sensitivity multiplier [4]: %f", mSensitivityMultipliersArray[4]);
    pmem_read(ADDR_SENSITIVITY_MULTIPLIER_5, &mSensitivityMultipliersArray[5]);
    printf("Sensitivity multiplier [5]: %f", mSensitivityMultipliersArray[5]);
    pmem_read(ADDR_SENSITIVITY_MULTIPLIER_6, &mSensitivityMultipliersArray[6]);
    printf("Sensitivity multiplier [6]: %f", mSensitivityMultipliersArray[6]);
 
    pmem_read(ADDR_DEADZONE_X, &mDeadzoneX);
    printf("Deadzone X: %f", mDeadzoneX);
    pmem_read(ADDR_DEADZONE_Y, &mDeadzoneY);
    printf("Deadzone Y: %f", mDeadzoneY);
    pmem_read(ADDR_DEADZONE_D, &mDeadzoneD);
    printf("Deadzone D: %f", mDeadzoneD);
 
    pmem_read(ADDR_OUTER_DEADZONE, &mOuterDeadzone);
    printf("Outer Deadzone: %f", mOuterDeadzone);
    pmem_read(ADDR_INNER_DEADZONE, &mInnerDeadzone);
    printf("Inner Deadzone: %f", mInnerDeadzone);
 
    pmem_read(ADDR_CALIBRATION_DELAY, &mCalibrationDelay);
    printf("Calibration Delay: %d", mCalibrationDelay);
    pmem_read(ADDR_CALIBRATION_SAMPLES, &mCalibrationSamples);
    printf("Calibration Samples: %d", mCalibrationSamples);
 
    FetchCalibration();
    // Load Keyboard maping to Console   
    const uint8 kmap[] = { 0xE2, 0x00, 0x2B, 0x01, 0x29, 0x02, 0x08, 0x03, 0x09, 0x05, 0x14, 0x06, 0x10, 0x07, 0xE1, 0x08, 0x52, 0x09, 0x51, 0x0A, 0x50, 0x0B, 0x4F, 0x0C, 0x1E, 0x09, 0x20, 0x0A, 0x21, 0x0B, 0x1F, 0x0C, 0x0A, 0x0D, 0x06, 0x0E, 0x2C, 0x0F, 0x15, 0x10, 0x23, 0x11, 0x04, 0x97, 0x07, 0x17, 0x1A, 0x98, 0x16, 0x18, 0x3A, 0x26, 0x3B, 0x27, 0x3C, 0x28, 0x3D, 0x29 };
    keymapping(kmap);
    // Load MOUSE maping to Console
    const uint8 mmap[] = { 0x00, 0x1D, 0x01, 0x1E, 0x06, 0x05, 0x08, 0x0D, 0x02, 0x0B, 0x03, 0x0C, 0x07, 0x0E, 0x04, 0x04, 0x05, 0x07 };
    mousemapping(mmap);   
    // Load Controller maping to Console Block
    const uint8 cmap[] = { 0x17, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A };
    remapper(cmap);
}
 
main
{
    ResetLeds();
 
    ActivateIncreaseSensitivity(event_release(PADDLE_1) );
    IncreaseSensitivity();
    ActivateDecreaseSensitivity(event_release(PADDLE_2) );
    DecreaseSensitivity();
 
    ActivateCalibration(get_val(PADDLE_4)> 0.0 );
    Calibrate();
 
    Debug();
 
    ToggleAlwaysOn(get_val(PADDLE_3) > 0.0 && get_prev(BUTTON_13) == 0.0 && get_actual(BUTTON_13) > 0.0);
    ToggleMotionAiming(get_val(PADDLE_3) > 0.0 && get_prev(BUTTON_12) == 0.0 && get_actual(BUTTON_12) > 0.0);
 
    MotionAiming(mIsMotionAimingOn && !mIsActivatedCalibrating && !mIsActivatedDebugging &&
                 (abs(get_val(STICK_1_X)) <= mDeadzoneX && (abs(get_val(STICK_1_Y)) <= mDeadzoneY)) &&
                    (mIsAlwaysOn ||
                    (mIsActivateL1 && (get_val(BUTTON_7) > 98.0)) ||
                    (mIsActivateL2 && (get_val(BUTTON_8) > 98.0)) ||
                    (mIsActivateR1 && (get_val(BUTTON_4) > 98.0)) ||
                    (mIsActivateR2 && (get_val(BUTTON_5) > 98.0))));
 
    AddInnerDeadzone();
    AddOuterDeadzone();
 
    MimicTouch(get_val(BUTTON_2) > 90.0 && GetPadType() != PAD_PS4);
    set_val(ACCEL_1_X, stick_response(ACCEL_1_X));
    set_val(ACCEL_1_Y, stick_response(ACCEL_1_Y));
}
 
void ResetLeds()
{
    if(mIsActivatedLeds)
    {
        if(mTimeCounter > LED_DELAY)
        {
            led_reset();
            mTimeCounter = 0;
        }
        else
        {
            mTimeCounter += elapsed_time();
        }
    }
}
 
void ActivateIncreaseSensitivity(bool aIsActivated)
{
    if(aIsActivated)
    {
        if(mSensitivityMultiplierIndex < 6) //increase sensivity multiplier
            mIsActivatedIncreaseSensitivity = TRUE;
        else
        {
            SetLeds(7);
            mIsActivatedLeds = TRUE;
        }
    }
}
 
void IncreaseSensitivity()
{
    if(mIsActivatedIncreaseSensitivity)
    {
        mSensitivityMultiplierIndex = mSensitivityMultiplierIndex + 1;
        SetLeds(mSensitivityMultiplierIndex+1);
        SaveSensitivityIndex();
        mIsActivatedIncreaseSensitivity = FALSE;
        mIsActivatedLeds = TRUE;
    }       
}
 
void ActivateDecreaseSensitivity(bool aIsActivated)
{
    if(aIsActivated)
    {
        if(mSensitivityMultiplierIndex > 0) //decrease sensivity multiplier
            mIsActivatedDecreaseSensitivity = TRUE;
        else
        {
            SetLeds(0);
            mIsActivatedLeds = TRUE;
        }
    }
}
 
void DecreaseSensitivity()
{
    if(mIsActivatedDecreaseSensitivity)
    {
        mSensitivityMultiplierIndex = mSensitivityMultiplierIndex - 1;
        SetLeds(mSensitivityMultiplierIndex+1);
        SaveSensitivityIndex();
        mIsActivatedDecreaseSensitivity = FALSE;
        mIsActivatedLeds = TRUE;
    }
}
 
void ActivateCalibration(bool aIsActivated)
{
    if(aIsActivated && !mIsActivatedCalibrating)
    {
        mCalibOffsetX = 0.0;
        mCalibOffsetY = 0.0;
        mCalibOffsetZ = 0.0;
        mCalibrationCycleIndex = 0;
        mTimeCounter = 0;
        SetLeds(6);
        printf("Calibration started. Delay: %d, Samples: %d", mCalibrationDelay, mCalibrationSamples);
        mIsActivatedCalibrating = TRUE;
    }
}
 
void Calibrate()
{
    if(mIsActivatedCalibrating)
    {
        mTimeCounter += elapsed_time();
        if(mTimeCounter > mCalibrationDelay)
        {
            SetLeds(15);
            if(mCalibrationCycleIndex < mCalibrationSamples)
            {
                mCalibrationCycleIndex += 1;
 
                mCalibOffsetX += get_actual(ACCEL_1_X);
                mCalibOffsetZ += get_actual(ACCEL_1_Y);
            }
            else
            {
                mCalibOffsetX /= (fix32)mCalibrationSamples;
                mCalibOffsetY /= (fix32)mCalibrationSamples;
                mCalibOffsetZ /= (fix32)mCalibrationSamples;
 
                StoreCalibration();
 
                mTimeCounter = 0;
                led_reset();
                mIsActivatedCalibrating = FALSE;
            }
        }
    }
}
 
void FetchCalibration()
{
    uint8 padType = GetPadType();
    pmem_load();
    switch(padType)
    {
        case PAD_OTHER:
            pmem_read(ADDR_CALIB_OTHER_X, &mCalibOffsetX);
            pmem_read(ADDR_CALIB_OTHER_Y, &mCalibOffsetY);
            pmem_read(ADDR_CALIB_OTHER_Z, &mCalibOffsetZ);
            printf("Other gamepad calibration. X: %f, Y: %f, Z: %f", mCalibOffsetX, mCalibOffsetY, mCalibOffsetZ);
        break;
 
        case PAD_PS4:
            pmem_read(ADDR_CALIB_PS4_X, &mCalibOffsetX);
            pmem_read(ADDR_CALIB_PS4_Y, &mCalibOffsetY);
            pmem_read(ADDR_CALIB_PS4_Z, &mCalibOffsetZ);
            printf("DualShock 4 calibration. X: %f, Y: %f, Z: %f", mCalibOffsetX, mCalibOffsetY, mCalibOffsetZ);
        break;
 
        case PAD_SWITCH:
            pmem_read(ADDR_CALIB_SWITCH_X, &mCalibOffsetX);
            pmem_read(ADDR_CALIB_SWITCH_Y, &mCalibOffsetY);
            pmem_read(ADDR_CALIB_SWITCH_Z, &mCalibOffsetZ);
            printf("Pro Controller calibration. X: %f, Y: %f, Z: %f", mCalibOffsetX, mCalibOffsetY, mCalibOffsetZ);
        break;
    }
}
 
void StoreCalibration()
{
    uint8 padType = GetPadType();
    printf("Pad type set: %d", padType);
    switch(padType)
    {
        case PAD_OTHER:
            pmem_write(ADDR_CALIB_OTHER_X, mCalibOffsetX);
            pmem_write(ADDR_CALIB_OTHER_Y, mCalibOffsetY);
            pmem_write(ADDR_CALIB_OTHER_Z, mCalibOffsetZ);
            printf("Stored other gamepad calibration. X: %f, Y: %f, Z: %f", mCalibOffsetX, mCalibOffsetY, mCalibOffsetZ);
        break;
 
        case PAD_PS4:
            pmem_write(ADDR_CALIB_PS4_X, mCalibOffsetX);
            pmem_write(ADDR_CALIB_PS4_Y, mCalibOffsetY);
            pmem_write(ADDR_CALIB_PS4_Z, mCalibOffsetZ);
            printf("Stored DualShock 4 calibration. X: %f, Y: %f, Z: %f", mCalibOffsetX, mCalibOffsetY, mCalibOffsetZ);
        break;
 
        case PAD_SWITCH:
            pmem_write(ADDR_CALIB_SWITCH_X, mCalibOffsetX);
            pmem_write(ADDR_CALIB_SWITCH_Y, mCalibOffsetY);
            pmem_write(ADDR_CALIB_SWITCH_Z, mCalibOffsetZ);
            printf("Stored Pro Controller calibration. X: %f, Y: %f, Z: %f", mCalibOffsetX, mCalibOffsetY, mCalibOffsetZ);
        break;
    }
    pmem_save();
}
 
uint8 GetPadType()
{
    uint8 status, protocol, device, i = 0;
    while(i < PAD_IDS_LENGHT)
    {
        status = port_status(PAD_IDS[i], &protocol, &device);
        if(status)
        {
            if(protocol == PROTOCOL_PS4)
                return PAD_PS4;
            else if(protocol == PROTOCOL_SWITCH)
                return PAD_SWITCH;
            else
                return PAD_OTHER;
        }
        i++;
    }
    return(-1);
}
 
void Debug()
{
    if(mIsActivatedCalibrating || !mIsActivatedDebugging)
        return;
 
    set_val(GYRO_1_X, (get_val(GYRO_1_X) - mCalibOffsetX) * 1000.0);
    set_val(GYRO_1_Y, (get_val(GYRO_1_Y) - mCalibOffsetY) * 1000.0);
    set_val(GYRO_1_Z, (get_val(GYRO_1_Z) - mCalibOffsetZ) * 1000.0);
}
 
 
void ToggleAlwaysOn(bool aIsActivated)
{
    if(aIsActivated)
    {
        mIsAlwaysOn = !mIsAlwaysOn;
        pmem_write(ADDR_ACTIVATE_ALWAYS_ON, mIsAlwaysOn);
        pmem_save();
    }
}
 
void ToggleMotionAiming(bool aIsActivated)
{
    if(aIsActivated)
    {
        mIsMotionAimingOn = !mIsMotionAimingOn;
    }
}
 
void MotionAiming(bool aIsActivated)
{
    if(aIsActivated)
    {
        static fix32 accelX, accelY;
        static fix32 stickX, stickY;
        if(accelX != get_actual(ACCEL_1_X) || accelY != get_actual(ACCEL_1_Y))
        {
            accelX = get_actual(ACCEL_1_X);
            accelY = get_actual(ACCEL_1_Y);
 
            stickX = (accelX - mCalibOffsetZ) * mBaseSensitivityX * mSensitivityMultipliersArray[mSensitivityMultiplierIndex];
            stickY = (accelY - mCalibOffsetX) * mBaseSensitivityY * mSensitivityMultipliersArray[mSensitivityMultiplierIndex];
 
            fix32 signalX = (stickX < 0.0) ? (stickX = inv(stickX), -1.0) : (stickX > 0.0) ? 1.0 : 0.0;
            fix32 signalY = (stickY < 0.0) ? (stickY = inv(stickY), -1.0) : (stickY > 0.0) ? 1.0 : 0.0;
            fix32 angle = atan2(stickY, stickX);
 
            stickX = clamp(((mDeadzoneX * pow(cos(angle), mDeadzoneD)) + stickX) * signalX, -100.0, 100.0);
            stickY = clamp(((mDeadzoneY * pow(sin(angle), mDeadzoneD)) + stickY) * signalY, -100.0, 100.0);
        }
        set_val(STICK_1_X, stickX);
        set_val(STICK_1_Y, stickY);
        return;
    }
}
 
void AddInnerDeadzone()
{
    if(abs(get_val(STICK_1_Y)) > 5.00 && abs(get_val(STICK_1_Y)) < mInnerDeadzone)
        set_val(STICK_1_Y, 0.0);
 
    if(abs(get_val(STICK_1_X)) > 5.00 && abs(get_val(STICK_1_X)) < mInnerDeadzone)
        set_val(STICK_1_X, 0.0);
}
 
void AddOuterDeadzone()
{
    if(get_val(STICK_1_Y) <= mOuterDeadzone * -1.00)
        set_val(STICK_1_Y, -100);
 
    if(get_val(STICK_1_Y) >= mOuterDeadzone)
        set_val(STICK_1_Y, 100);
 
    if(get_val(STICK_1_X) <= mOuterDeadzone * -1.00)
        set_val(STICK_1_X, -100);
 
    if(get_val(STICK_1_X) >= mOuterDeadzone)
        set_val(STICK_1_X, 100);
}
 
 
void SaveSensitivityIndex()
{
    printf("Sensitivity Index: %d, Sensitivity Multiplier: %f", mSensitivityMultiplierIndex, mSensitivityMultipliersArray[mSensitivityMultiplierIndex]);
    pmem_write(ADDR_SENSITIVITY_MULTIPLIER_INDEX, mSensitivityMultiplierIndex);
    pmem_save();
}
 
void SetLeds(uint8 aLeds)
{
    if(aLeds == 1)
        aLeds = 0;
 
    fix32 bits[4];
    bits[0] = (aLeds & (1 << 0)) == 0 ? 0.0 : 100.0;
    bits[1] = (aLeds & (1 << 1)) == 0 ? 0.0 : 100.0;
    bits[2] = (aLeds & (1 << 2)) == 0 ? 0.0 : 100.0;
    bits[4] = (aLeds & (1 << 3)) == 0 ? 0.0 : 100.0;
 
    led_set(LED_1, bits[0], 800);
    led_set(LED_2, bits[1], 800);
    led_set(LED_3, bits[2], 800);
    led_set(LED_4, bits[3], 800);
}
 
void MimicTouch(bool aIsActivated)
{
    if(aIsActivated)
    {
        set_val(BUTTON_19, 100.0);
        set_val(POINT_1_X, get_actual(ACCEL_1_X));
        set_val(POINT_1_Y, get_actual(ACCEL_1_Y));
        set_val(STICK_1_X, 0.0);
        set_val(STICK_1_Y, 0.0);
    }
}
 
 
fix32 stick_response(uint8 idx) {
    const uint8 mxyc[] = { 0xFF, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x03, 0x06, 0x09, 0x0C, 0x0F, 0x12, 0x15, 0x18, 0x1B, 0x1E, 0x21, 0x24, 0x27, 0x2A, 0x2D, 0x30, 0x33, 0x36, 0x39, 0x3C };
 
    fix32 value = get_actual(idx);
    fix32 signal = (value >= 0.0 ? 1.0 : -1.0);
    value = abs(value);
 
    return(value * signal);
}
User avatar
teddy18
Lieutenant
Lieutenant
 
Posts: 346
Joined: Sun Jul 19, 2015 4:18 pm

Re: Universal Mouse and Keboard Console on The fly

Postby teddy18 » Sun Oct 17, 2021 8:59 pm

Script

Universal Mouse and Keboard Console with Curve Ver 1.6 Ratio 1.00 DD Factor 0.14
Code: Select all
GIVMXYF:FF010001000023000000000100000306090C0F1215181B1E2124272A2D303336393C

Code: Select all
#pragma METAINFO("Universal Mouse and Keboard Console with Curve", 1, 6, "mss1988 & teddy18")
#include <switch.gph>
 
/*
<cfgdesc>
 
[Gyro Aiming Activation]
byteoffset = 0
bitsize    = 8
control    = checkbox
default    = 0
item       = On L1/LB
 
[Gyro Aiming Activation2]
group      = true
groupcol = true
byteoffset = 1
bitsize    = 8
control    = checkbox
default    = 0
item       = On L2/LT
 
[Gyro Aiming Activation3]
group      = true
groupcol = true
byteoffset = 2
bitsize    = 8
control    = checkbox
default    = 0
item       = On R1/RB
 
[Gyro Aiming Activation4]
group      = true
groupcol = true
byteoffset = 3
bitsize    = 8
control    = checkbox
default    = 0
item       = On R2/RT
 
[Gyro Aiming Activation5]
group      = true
groupcol = true
byteoffset = 4
bitsize    = 8
control    = checkbox
default    = 1
item       = Always On
 
[Sensitivity]
group      = false
shortdesc  = Base sensitivity X
byteoffset = 5
bitsize    = 32
control    = spinboxf
default    = 100
minimum    = 10
maximum    = 20000
step       = 1
decimals   = 2
 
[SensitivityY]
group      = true
groupcol = true
shortdesc  = Base sensitivity Y
byteoffset = 9
bitsize    = 32
control    = spinboxf
default    = 160
minimum    = 10
maximum    = 20000
step       = 1
decimals   = 2
 
[Sensitivity Multipliers]
group      = false
groupcol = false
shortdesc  = Active Sensitivity Multiplier:
byteoffset = 13
bitsize    = 8
control    = slider
default    = 3
minimum    = 1
maximum    = 7
step       = 1
 
[Sensitivity Multipliers1]
group      = true
groupcol = false
shortdesc  = Sensitivity Multiplier 1:
byteoffset = 14
bitsize    = 32
control    = spinboxf
default    = 50
minimum    = 10
maximum    = 1000
step       = 1
decimals   = 2
 
[Sensitivity Multipliers2]
group      = true
groupcol = false
shortdesc  = Sensitivity Multiplier 2:
byteoffset = 18
bitsize    = 32
control    = spinboxf
default    = 75
minimum    = 10
maximum    = 1000
step       = 1
decimals   = 2
 
[Sensitivity Multipliers3]
group      = true
groupcol = false
shortdesc  = Sensitivity Multiplier 3:
byteoffset = 22
bitsize    = 32
control    = spinboxf
default    = 100
minimum    = 10
maximum    = 1000
step       = 1
decimals   = 2
 
[Sensitivity Multipliers4]
group      = true
groupcol = false
shortdesc  = Sensitivity Multiplier 4:
byteoffset = 26
bitsize    = 32
control    = spinboxf
default    = 125
minimum    = 10
maximum    = 1000
step       = 1
decimals   = 2
 
[Sensitivity Multipliers5]
group      = true
groupcol = false
shortdesc  = Sensitivity Multiplier 5:
byteoffset = 30
bitsize    = 32
control    = spinboxf
default    = 150
minimum    = 10
maximum    = 1000
step       = 1
decimals   = 2
 
[Sensitivity Multipliers6]
group      = true
groupcol = false
shortdesc  = Sensitivity Multiplier 6:
byteoffset = 34
bitsize    = 32
control    = spinboxf
default    = 175
minimum    = 10
maximum    = 1000
step       = 1
decimals   = 2
 
[Sensitivity Multipliers7]
group      = true
groupcol = false
shortdesc  = Sensitivity Multiplier 7:
byteoffset = 38
bitsize    = 32
control    = spinboxf
default    = 200
minimum    = 10
maximum    = 1000
step       = 1
decimals   = 2
 
[Deadzones]
group      = false
shortdesc  = Ignore Gyro if Right Stick X is greater than:
byteoffset = 42
bitsize    = 32
control    = spinboxf
default    = 200
minimum    = 0
maximum    = 1000
step       = 1
decimals   = 1
 
[DeadzonesY]
group      = true
groupcol = false
shortdesc  = Ignore Gyro if Right Stick Y is greater than:
byteoffset = 46
bitsize    = 32
control    = spinboxf
default    = 200
minimum    = 0
maximum    = 1000
step       = 1
decimals   = 1
 
[DeadzonesD]
group      = true
groupcol = false
shortdesc  = Right Stick Diagonal Deadzone:
byteoffset = 50
bitsize    = 32
control    = spinboxf
default    = 38
minimum    = 0
maximum    = 200
step       = 1
decimals   = 2
 
[DeadzonesO]
group      = true
groupcol = false
shortdesc  = Right Stick Outer Deadzone:
byteoffset = 54
bitsize    = 32
control    = spinboxf
default    = 9200
minimum    = 0
maximum    = 10000
step       = 1
decimals   = 2
 
[DeadzonesI]
group      = true
groupcol = false
shortdesc  = Right Stick Inner Deadzone:
byteoffset = 58
bitsize    = 32
control    = spinboxf
default    = 013
minimum    = 0
maximum    = 10000
step       = 1
decimals   = 2
 
[Calibration]
group      = false
groupcol = false
shortdesc  = Delay (ms):
byteoffset = 62
bitsize    = 32
control    = slider
default    = 3000
minimum    = 500
maximum    = 10000
step       = 500
 
[CalibrationS]
group      = true
groupcol = false
shortdesc  = Samples:
byteoffset = 66
bitsize    = 32
control    = slider
default    = 300
minimum    = 100
maximum    = 10000
step       = 100
 
</cfgdesc>
*/

 
//Constants
#define PAD_OTHER  0
#define PAD_PS4    1
#define PAD_SWITCH 2
uint8 PAD_IDS[5] = { 6, 5, 4, 2, 1 };
uint8 PAD_IDS_LENGHT = 5;
 
//Persistent memory addereses
#define ADDR_ACTIVATE_L1                     0
#define ADDR_ACTIVATE_L2                     1
#define ADDR_ACTIVATE_R1                     2
#define ADDR_ACTIVATE_R2                     3
#define ADDR_ACTIVATE_ALWAYS_ON             4
 
#define ADDR_BASE_SENSITIVITY_X             5
#define ADDR_BASE_SENSITIVITY_Y             9
#define ADDR_SENSITIVITY_MULTIPLIER_INDEX     13
#define ADDR_SENSITIVITY_MULTIPLIER_0         14
#define ADDR_SENSITIVITY_MULTIPLIER_1         18
#define ADDR_SENSITIVITY_MULTIPLIER_2         22
#define ADDR_SENSITIVITY_MULTIPLIER_3         26
#define ADDR_SENSITIVITY_MULTIPLIER_4         30
#define ADDR_SENSITIVITY_MULTIPLIER_5         34
#define ADDR_SENSITIVITY_MULTIPLIER_6         38
 
#define ADDR_DEADZONE_X                        42
#define ADDR_DEADZONE_Y                        46
#define ADDR_DEADZONE_D                        50
 
#define ADDR_OUTER_DEADZONE                    54
#define ADDR_INNER_DEADZONE                    58
 
#define ADDR_CALIBRATION_DELAY                62
#define ADDR_CALIBRATION_SAMPLES            66
 
#define ADDR_CALIB_PS4_X                     92
#define ADDR_CALIB_PS4_Y                     96
#define ADDR_CALIB_PS4_Z                     100
 
#define ADDR_CALIB_SWITCH_X                 104
#define ADDR_CALIB_SWITCH_Y                 108
#define ADDR_CALIB_SWITCH_Z                 116
 
#define ADDR_CALIB_OTHER_X                     116
#define ADDR_CALIB_OTHER_Y                     120
#define ADDR_CALIB_OTHER_Z                     124
 
 
#define LED_DELAY                            2000
 
//Variables
fix32 mCalibOffsetX = 0.0;
fix32 mCalibOffsetY = 0.0;
fix32 mCalibOffsetZ = 0.0;
 
bool mIsActivatedCalibrating = FALSE;
bool mIsActivatedIncreaseSensitivity = FALSE;
bool mIsActivatedDecreaseSensitivity = FALSE;
bool mIsActivatedLeds = FALSE;
 
fix32 mBaseSensitivityX = 1.0;
fix32 mBaseSensitivityY = 1.6;
uint8 mSensitivityMultiplierIndex = 2;
fix32 mSensitivityMultipliersArray[7] = { 0.5, 0.75, 1.0, 1.25, 1.5, 1.75, 2.0 };
 
uint32 mCalibrationDelay = 3000;
uint32 mCalibrationSamples = 300;
uint32 mCalibrationCycleIndex = 0;
 
fix32 mDeadzoneX = 20.0// Deadzone GYRO_1_YZ Input
fix32 mDeadzoneY = 20.0// Deadzone GYRO_1_YX Input
fix32 mDeadzoneD = 0.38// Deadzone Diagonal input
 
fix32 mOuterDeadzone = 92.00;
fix32 mInnerDeadzone = 0.13;
 
bool mIsActivateL1 = FALSE;
bool mIsActivateL2 = TRUE;
bool mIsActivateR1 = FALSE;
bool mIsActivateR2 = TRUE;
bool mIsAlwaysOn = FALSE;
bool mIsMotionAimingOn = TRUE;
 
uint32 mTimeCounter = 0;
 
bool mIsActivatedDebugging = FALSE;
 
init
{
    pmem_load();
 
    printf("Values loaded:");
 
    pmem_read(ADDR_ACTIVATE_L1, &mIsActivateL1);
    printf("Activate L1: %d", mIsActivateL1);
    pmem_read(ADDR_ACTIVATE_L2, &mIsActivateL2);
    printf("Activate L2: %d", mIsActivateL2);
    pmem_read(ADDR_ACTIVATE_R1, &mIsActivateR1);
    printf("Activate R1: %d", mIsActivateR1);
    pmem_read(ADDR_ACTIVATE_R2, &mIsActivateR2);
    printf("Activate R2: %d", mIsActivateR2);
    pmem_read(ADDR_ACTIVATE_ALWAYS_ON, &mIsAlwaysOn);
    printf("Activate AlwaysOn: %d", mIsAlwaysOn);
 
    pmem_read(ADDR_BASE_SENSITIVITY_X, &mBaseSensitivityX);
    printf("Base sensitivity X: %f", mBaseSensitivityX);
    pmem_read(ADDR_BASE_SENSITIVITY_Y, &mBaseSensitivityY);
    printf("Base sensitivity Y: %f", mBaseSensitivityY);
 
    pmem_read(ADDR_SENSITIVITY_MULTIPLIER_INDEX, &mSensitivityMultiplierIndex);
    mSensitivityMultiplierIndex--;
    printf("Sensitivity multiplier index: %d", mSensitivityMultiplierIndex);
 
    pmem_read(ADDR_SENSITIVITY_MULTIPLIER_0, &mSensitivityMultipliersArray[0]);
    printf("Sensitivity multiplier [0]: %f", mSensitivityMultipliersArray[0]);
    pmem_read(ADDR_SENSITIVITY_MULTIPLIER_1, &mSensitivityMultipliersArray[1]);
    printf("Sensitivity multiplier [1]: %f", mSensitivityMultipliersArray[1]);
    pmem_read(ADDR_SENSITIVITY_MULTIPLIER_2, &mSensitivityMultipliersArray[2]);
    printf("Sensitivity multiplier [2]: %f", mSensitivityMultipliersArray[2]);
    pmem_read(ADDR_SENSITIVITY_MULTIPLIER_3, &mSensitivityMultipliersArray[3]);
    printf("Sensitivity multiplier [3]: %f", mSensitivityMultipliersArray[3]);
    pmem_read(ADDR_SENSITIVITY_MULTIPLIER_4, &mSensitivityMultipliersArray[4]);
    printf("Sensitivity multiplier [4]: %f", mSensitivityMultipliersArray[4]);
    pmem_read(ADDR_SENSITIVITY_MULTIPLIER_5, &mSensitivityMultipliersArray[5]);
    printf("Sensitivity multiplier [5]: %f", mSensitivityMultipliersArray[5]);
    pmem_read(ADDR_SENSITIVITY_MULTIPLIER_6, &mSensitivityMultipliersArray[6]);
    printf("Sensitivity multiplier [6]: %f", mSensitivityMultipliersArray[6]);
 
    pmem_read(ADDR_DEADZONE_X, &mDeadzoneX);
    printf("Deadzone X: %f", mDeadzoneX);
    pmem_read(ADDR_DEADZONE_Y, &mDeadzoneY);
    printf("Deadzone Y: %f", mDeadzoneY);
    pmem_read(ADDR_DEADZONE_D, &mDeadzoneD);
    printf("Deadzone D: %f", mDeadzoneD);
 
    pmem_read(ADDR_OUTER_DEADZONE, &mOuterDeadzone);
    printf("Outer Deadzone: %f", mOuterDeadzone);
    pmem_read(ADDR_INNER_DEADZONE, &mInnerDeadzone);
    printf("Inner Deadzone: %f", mInnerDeadzone);
 
    pmem_read(ADDR_CALIBRATION_DELAY, &mCalibrationDelay);
    printf("Calibration Delay: %d", mCalibrationDelay);
    pmem_read(ADDR_CALIBRATION_SAMPLES, &mCalibrationSamples);
    printf("Calibration Samples: %d", mCalibrationSamples);
 
    FetchCalibration();
    // Load Keyboard maping to Console   
    const uint8 kmap[] = { 0xE2, 0x00, 0x2B, 0x01, 0x29, 0x02, 0x08, 0x03, 0x09, 0x05, 0x14, 0x06, 0x10, 0x07, 0xE1, 0x08, 0x52, 0x09, 0x51, 0x0A, 0x50, 0x0B, 0x4F, 0x0C, 0x1E, 0x09, 0x20, 0x0A, 0x21, 0x0B, 0x1F, 0x0C, 0x0A, 0x0D, 0x06, 0x0E, 0x2C, 0x0F, 0x15, 0x10, 0x23, 0x11, 0x04, 0x97, 0x07, 0x17, 0x1A, 0x98, 0x16, 0x18, 0x3A, 0x26, 0x3B, 0x27, 0x3C, 0x28, 0x3D, 0x29 };
    keymapping(kmap);
    // Load MOUSE maping to Console
    const uint8 mmap[] = { 0x00, 0x1D, 0x01, 0x1E, 0x06, 0x05, 0x08, 0x0D, 0x02, 0x0B, 0x03, 0x0C, 0x07, 0x0E, 0x04, 0x04, 0x05, 0x07 };
    mousemapping(mmap);   
    // Load Controller maping to Console Block
    const uint8 cmap[] = { 0x17, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A };
    remapper(cmap);
}
 
main
{
    ResetLeds();
 
    ActivateIncreaseSensitivity(event_release(PADDLE_1) );
    IncreaseSensitivity();
    ActivateDecreaseSensitivity(event_release(PADDLE_2) );
    DecreaseSensitivity();
 
    ActivateCalibration(get_val(PADDLE_4)> 0.0 );
    Calibrate();
 
    Debug();
 
    ToggleAlwaysOn(get_val(PADDLE_3) > 0.0 && get_prev(BUTTON_13) == 0.0 && get_actual(BUTTON_13) > 0.0);
    ToggleMotionAiming(get_val(PADDLE_3) > 0.0 && get_prev(BUTTON_12) == 0.0 && get_actual(BUTTON_12) > 0.0);
 
    MotionAiming(mIsMotionAimingOn && !mIsActivatedCalibrating && !mIsActivatedDebugging &&
                 (abs(get_val(STICK_1_X)) <= mDeadzoneX && (abs(get_val(STICK_1_Y)) <= mDeadzoneY)) &&
                    (mIsAlwaysOn ||
                    (mIsActivateL1 && (get_val(BUTTON_7) > 98.0)) ||
                    (mIsActivateL2 && (get_val(BUTTON_8) > 98.0)) ||
                    (mIsActivateR1 && (get_val(BUTTON_4) > 98.0)) ||
                    (mIsActivateR2 && (get_val(BUTTON_5) > 98.0))));
 
    AddInnerDeadzone();
    AddOuterDeadzone();
 
    MimicTouch(get_val(BUTTON_2) > 90.0 && GetPadType() != PAD_PS4);
    set_val(ACCEL_1_X, stick_response(ACCEL_1_X));
    set_val(ACCEL_1_Y, stick_response(ACCEL_1_Y));
}
 
void ResetLeds()
{
    if(mIsActivatedLeds)
    {
        if(mTimeCounter > LED_DELAY)
        {
            led_reset();
            mTimeCounter = 0;
        }
        else
        {
            mTimeCounter += elapsed_time();
        }
    }
}
 
void ActivateIncreaseSensitivity(bool aIsActivated)
{
    if(aIsActivated)
    {
        if(mSensitivityMultiplierIndex < 6) //increase sensivity multiplier
            mIsActivatedIncreaseSensitivity = TRUE;
        else
        {
            SetLeds(7);
            mIsActivatedLeds = TRUE;
        }
    }
}
 
void IncreaseSensitivity()
{
    if(mIsActivatedIncreaseSensitivity)
    {
        mSensitivityMultiplierIndex = mSensitivityMultiplierIndex + 1;
        SetLeds(mSensitivityMultiplierIndex+1);
        SaveSensitivityIndex();
        mIsActivatedIncreaseSensitivity = FALSE;
        mIsActivatedLeds = TRUE;
    }       
}
 
void ActivateDecreaseSensitivity(bool aIsActivated)
{
    if(aIsActivated)
    {
        if(mSensitivityMultiplierIndex > 0) //decrease sensivity multiplier
            mIsActivatedDecreaseSensitivity = TRUE;
        else
        {
            SetLeds(0);
            mIsActivatedLeds = TRUE;
        }
    }
}
 
void DecreaseSensitivity()
{
    if(mIsActivatedDecreaseSensitivity)
    {
        mSensitivityMultiplierIndex = mSensitivityMultiplierIndex - 1;
        SetLeds(mSensitivityMultiplierIndex+1);
        SaveSensitivityIndex();
        mIsActivatedDecreaseSensitivity = FALSE;
        mIsActivatedLeds = TRUE;
    }
}
 
void ActivateCalibration(bool aIsActivated)
{
    if(aIsActivated && !mIsActivatedCalibrating)
    {
        mCalibOffsetX = 0.0;
        mCalibOffsetY = 0.0;
        mCalibOffsetZ = 0.0;
        mCalibrationCycleIndex = 0;
        mTimeCounter = 0;
        SetLeds(6);
        printf("Calibration started. Delay: %d, Samples: %d", mCalibrationDelay, mCalibrationSamples);
        mIsActivatedCalibrating = TRUE;
    }
}
 
void Calibrate()
{
    if(mIsActivatedCalibrating)
    {
        mTimeCounter += elapsed_time();
        if(mTimeCounter > mCalibrationDelay)
        {
            SetLeds(15);
            if(mCalibrationCycleIndex < mCalibrationSamples)
            {
                mCalibrationCycleIndex += 1;
 
                mCalibOffsetX += get_actual(ACCEL_1_X);
                mCalibOffsetZ += get_actual(ACCEL_1_Y);
            }
            else
            {
                mCalibOffsetX /= (fix32)mCalibrationSamples;
                mCalibOffsetY /= (fix32)mCalibrationSamples;
                mCalibOffsetZ /= (fix32)mCalibrationSamples;
 
                StoreCalibration();
 
                mTimeCounter = 0;
                led_reset();
                mIsActivatedCalibrating = FALSE;
            }
        }
    }
}
 
void FetchCalibration()
{
    uint8 padType = GetPadType();
    pmem_load();
    switch(padType)
    {
        case PAD_OTHER:
            pmem_read(ADDR_CALIB_OTHER_X, &mCalibOffsetX);
            pmem_read(ADDR_CALIB_OTHER_Y, &mCalibOffsetY);
            pmem_read(ADDR_CALIB_OTHER_Z, &mCalibOffsetZ);
            printf("Other gamepad calibration. X: %f, Y: %f, Z: %f", mCalibOffsetX, mCalibOffsetY, mCalibOffsetZ);
        break;
 
        case PAD_PS4:
            pmem_read(ADDR_CALIB_PS4_X, &mCalibOffsetX);
            pmem_read(ADDR_CALIB_PS4_Y, &mCalibOffsetY);
            pmem_read(ADDR_CALIB_PS4_Z, &mCalibOffsetZ);
            printf("DualShock 4 calibration. X: %f, Y: %f, Z: %f", mCalibOffsetX, mCalibOffsetY, mCalibOffsetZ);
        break;
 
        case PAD_SWITCH:
            pmem_read(ADDR_CALIB_SWITCH_X, &mCalibOffsetX);
            pmem_read(ADDR_CALIB_SWITCH_Y, &mCalibOffsetY);
            pmem_read(ADDR_CALIB_SWITCH_Z, &mCalibOffsetZ);
            printf("Pro Controller calibration. X: %f, Y: %f, Z: %f", mCalibOffsetX, mCalibOffsetY, mCalibOffsetZ);
        break;
    }
}
 
void StoreCalibration()
{
    uint8 padType = GetPadType();
    printf("Pad type set: %d", padType);
    switch(padType)
    {
        case PAD_OTHER:
            pmem_write(ADDR_CALIB_OTHER_X, mCalibOffsetX);
            pmem_write(ADDR_CALIB_OTHER_Y, mCalibOffsetY);
            pmem_write(ADDR_CALIB_OTHER_Z, mCalibOffsetZ);
            printf("Stored other gamepad calibration. X: %f, Y: %f, Z: %f", mCalibOffsetX, mCalibOffsetY, mCalibOffsetZ);
        break;
 
        case PAD_PS4:
            pmem_write(ADDR_CALIB_PS4_X, mCalibOffsetX);
            pmem_write(ADDR_CALIB_PS4_Y, mCalibOffsetY);
            pmem_write(ADDR_CALIB_PS4_Z, mCalibOffsetZ);
            printf("Stored DualShock 4 calibration. X: %f, Y: %f, Z: %f", mCalibOffsetX, mCalibOffsetY, mCalibOffsetZ);
        break;
 
        case PAD_SWITCH:
            pmem_write(ADDR_CALIB_SWITCH_X, mCalibOffsetX);
            pmem_write(ADDR_CALIB_SWITCH_Y, mCalibOffsetY);
            pmem_write(ADDR_CALIB_SWITCH_Z, mCalibOffsetZ);
            printf("Stored Pro Controller calibration. X: %f, Y: %f, Z: %f", mCalibOffsetX, mCalibOffsetY, mCalibOffsetZ);
        break;
    }
    pmem_save();
}
 
uint8 GetPadType()
{
    uint8 status, protocol, device, i = 0;
    while(i < PAD_IDS_LENGHT)
    {
        status = port_status(PAD_IDS[i], &protocol, &device);
        if(status)
        {
            if(protocol == PROTOCOL_PS4)
                return PAD_PS4;
            else if(protocol == PROTOCOL_SWITCH)
                return PAD_SWITCH;
            else
                return PAD_OTHER;
        }
        i++;
    }
    return(-1);
}
 
void Debug()
{
    if(mIsActivatedCalibrating || !mIsActivatedDebugging)
        return;
 
    set_val(GYRO_1_X, (get_val(GYRO_1_X) - mCalibOffsetX) * 1000.0);
    set_val(GYRO_1_Y, (get_val(GYRO_1_Y) - mCalibOffsetY) * 1000.0);
    set_val(GYRO_1_Z, (get_val(GYRO_1_Z) - mCalibOffsetZ) * 1000.0);
}
 
 
void ToggleAlwaysOn(bool aIsActivated)
{
    if(aIsActivated)
    {
        mIsAlwaysOn = !mIsAlwaysOn;
        pmem_write(ADDR_ACTIVATE_ALWAYS_ON, mIsAlwaysOn);
        pmem_save();
    }
}
 
void ToggleMotionAiming(bool aIsActivated)
{
    if(aIsActivated)
    {
        mIsMotionAimingOn = !mIsMotionAimingOn;
    }
}
 
void MotionAiming(bool aIsActivated)
{
    if(aIsActivated)
    {
        static fix32 accelX, accelY;
        static fix32 stickX, stickY;
        if(accelX != get_actual(ACCEL_1_X) || accelY != get_actual(ACCEL_1_Y))
        {
            accelX = get_actual(ACCEL_1_X);
            accelY = get_actual(ACCEL_1_Y);
 
            stickX = (accelX - mCalibOffsetZ) * mBaseSensitivityX * mSensitivityMultipliersArray[mSensitivityMultiplierIndex];
            stickY = (accelY - mCalibOffsetX) * mBaseSensitivityY * mSensitivityMultipliersArray[mSensitivityMultiplierIndex];
 
            fix32 signalX = (stickX < 0.0) ? (stickX = inv(stickX), -1.0) : (stickX > 0.0) ? 1.0 : 0.0;
            fix32 signalY = (stickY < 0.0) ? (stickY = inv(stickY), -1.0) : (stickY > 0.0) ? 1.0 : 0.0;
            fix32 angle = atan2(stickY, stickX);
 
            stickX = clamp(((mDeadzoneX * pow(cos(angle), mDeadzoneD)) + stickX) * signalX, -100.0, 100.0);
            stickY = clamp(((mDeadzoneY * pow(sin(angle), mDeadzoneD)) + stickY) * signalY, -100.0, 100.0);
        }
        set_val(STICK_1_X, stickX);
        set_val(STICK_1_Y, stickY);
        return;
    }
}
 
void AddInnerDeadzone()
{
    if(abs(get_val(STICK_1_Y)) > 5.00 && abs(get_val(STICK_1_Y)) < mInnerDeadzone)
        set_val(STICK_1_Y, 0.0);
 
    if(abs(get_val(STICK_1_X)) > 5.00 && abs(get_val(STICK_1_X)) < mInnerDeadzone)
        set_val(STICK_1_X, 0.0);
}
 
void AddOuterDeadzone()
{
    if(get_val(STICK_1_Y) <= mOuterDeadzone * -1.00)
        set_val(STICK_1_Y, -100);
 
    if(get_val(STICK_1_Y) >= mOuterDeadzone)
        set_val(STICK_1_Y, 100);
 
    if(get_val(STICK_1_X) <= mOuterDeadzone * -1.00)
        set_val(STICK_1_X, -100);
 
    if(get_val(STICK_1_X) >= mOuterDeadzone)
        set_val(STICK_1_X, 100);
}
 
 
void SaveSensitivityIndex()
{
    printf("Sensitivity Index: %d, Sensitivity Multiplier: %f", mSensitivityMultiplierIndex, mSensitivityMultipliersArray[mSensitivityMultiplierIndex]);
    pmem_write(ADDR_SENSITIVITY_MULTIPLIER_INDEX, mSensitivityMultiplierIndex);
    pmem_save();
}
 
void SetLeds(uint8 aLeds)
{
    if(aLeds == 1)
        aLeds = 0;
 
    fix32 bits[4];
    bits[0] = (aLeds & (1 << 0)) == 0 ? 0.0 : 100.0;
    bits[1] = (aLeds & (1 << 1)) == 0 ? 0.0 : 100.0;
    bits[2] = (aLeds & (1 << 2)) == 0 ? 0.0 : 100.0;
    bits[4] = (aLeds & (1 << 3)) == 0 ? 0.0 : 100.0;
 
    led_set(LED_1, bits[0], 800);
    led_set(LED_2, bits[1], 800);
    led_set(LED_3, bits[2], 800);
    led_set(LED_4, bits[3], 800);
}
 
void MimicTouch(bool aIsActivated)
{
    if(aIsActivated)
    {
        set_val(BUTTON_19, 100.0);
        set_val(POINT_1_X, get_actual(ACCEL_1_X));
        set_val(POINT_1_Y, get_actual(ACCEL_1_Y));
        set_val(STICK_1_X, 0.0);
        set_val(STICK_1_Y, 0.0);
    }
}
 
 
fix32 stick_response(uint8 idx) {
    const uint8 mxyc[] = { 0xFF, 0x01, 0x00, 0x01, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x03, 0x06, 0x09, 0x0C, 0x0F, 0x12, 0x15, 0x18, 0x1B, 0x1E, 0x21, 0x24, 0x27, 0x2A, 0x2D, 0x30, 0x33, 0x36, 0x39, 0x3C };
 
    fix32 value = get_actual(idx);
    fix32 signal = (value >= 0.0 ? 1.0 : -1.0);
    value = abs(value);
 
    return(value * signal);
}


Universal Mouse and Keboard Console with Curve Ver 1.7 Ratio 1.00 DD Factor 0.20
Code: Select all
GIVMXYF:FF010001000033000000000100000306090C0F1215181B1E2124272A2D303336393

Code: Select all
#pragma METAINFO("Universal Mouse and Keboard Console with Curve", 1, 7, "mss1988 & teddy18")
#include <switch.gph>
 
/*
<cfgdesc>
 
[Gyro Aiming Activation]
byteoffset = 0
bitsize    = 8
control    = checkbox
default    = 0
item       = On L1/LB
 
[Gyro Aiming Activation2]
group      = true
groupcol = true
byteoffset = 1
bitsize    = 8
control    = checkbox
default    = 0
item       = On L2/LT
 
[Gyro Aiming Activation3]
group      = true
groupcol = true
byteoffset = 2
bitsize    = 8
control    = checkbox
default    = 0
item       = On R1/RB
 
[Gyro Aiming Activation4]
group      = true
groupcol = true
byteoffset = 3
bitsize    = 8
control    = checkbox
default    = 0
item       = On R2/RT
 
[Gyro Aiming Activation5]
group      = true
groupcol = true
byteoffset = 4
bitsize    = 8
control    = checkbox
default    = 1
item       = Always On
 
[Sensitivity]
group      = false
shortdesc  = Base sensitivity X
byteoffset = 5
bitsize    = 32
control    = spinboxf
default    = 100
minimum    = 10
maximum    = 20000
step       = 1
decimals   = 2
 
[SensitivityY]
group      = true
groupcol = true
shortdesc  = Base sensitivity Y
byteoffset = 9
bitsize    = 32
control    = spinboxf
default    = 160
minimum    = 10
maximum    = 20000
step       = 1
decimals   = 2
 
[Sensitivity Multipliers]
group      = false
groupcol = false
shortdesc  = Active Sensitivity Multiplier:
byteoffset = 13
bitsize    = 8
control    = slider
default    = 3
minimum    = 1
maximum    = 7
step       = 1
 
[Sensitivity Multipliers1]
group      = true
groupcol = false
shortdesc  = Sensitivity Multiplier 1:
byteoffset = 14
bitsize    = 32
control    = spinboxf
default    = 50
minimum    = 10
maximum    = 1000
step       = 1
decimals   = 2
 
[Sensitivity Multipliers2]
group      = true
groupcol = false
shortdesc  = Sensitivity Multiplier 2:
byteoffset = 18
bitsize    = 32
control    = spinboxf
default    = 75
minimum    = 10
maximum    = 1000
step       = 1
decimals   = 2
 
[Sensitivity Multipliers3]
group      = true
groupcol = false
shortdesc  = Sensitivity Multiplier 3:
byteoffset = 22
bitsize    = 32
control    = spinboxf
default    = 100
minimum    = 10
maximum    = 1000
step       = 1
decimals   = 2
 
[Sensitivity Multipliers4]
group      = true
groupcol = false
shortdesc  = Sensitivity Multiplier 4:
byteoffset = 26
bitsize    = 32
control    = spinboxf
default    = 125
minimum    = 10
maximum    = 1000
step       = 1
decimals   = 2
 
[Sensitivity Multipliers5]
group      = true
groupcol = false
shortdesc  = Sensitivity Multiplier 5:
byteoffset = 30
bitsize    = 32
control    = spinboxf
default    = 150
minimum    = 10
maximum    = 1000
step       = 1
decimals   = 2
 
[Sensitivity Multipliers6]
group      = true
groupcol = false
shortdesc  = Sensitivity Multiplier 6:
byteoffset = 34
bitsize    = 32
control    = spinboxf
default    = 175
minimum    = 10
maximum    = 1000
step       = 1
decimals   = 2
 
[Sensitivity Multipliers7]
group      = true
groupcol = false
shortdesc  = Sensitivity Multiplier 7:
byteoffset = 38
bitsize    = 32
control    = spinboxf
default    = 200
minimum    = 10
maximum    = 1000
step       = 1
decimals   = 2
 
[Deadzones]
group      = false
shortdesc  = Ignore Gyro if Right Stick X is greater than:
byteoffset = 42
bitsize    = 32
control    = spinboxf
default    = 200
minimum    = 0
maximum    = 1000
step       = 1
decimals   = 1
 
[DeadzonesY]
group      = true
groupcol = false
shortdesc  = Ignore Gyro if Right Stick Y is greater than:
byteoffset = 46
bitsize    = 32
control    = spinboxf
default    = 200
minimum    = 0
maximum    = 1000
step       = 1
decimals   = 1
 
[DeadzonesD]
group      = true
groupcol = false
shortdesc  = Right Stick Diagonal Deadzone:
byteoffset = 50
bitsize    = 32
control    = spinboxf
default    = 38
minimum    = 0
maximum    = 200
step       = 1
decimals   = 2
 
[DeadzonesO]
group      = true
groupcol = false
shortdesc  = Right Stick Outer Deadzone:
byteoffset = 54
bitsize    = 32
control    = spinboxf
default    = 9200
minimum    = 0
maximum    = 10000
step       = 1
decimals   = 2
 
[DeadzonesI]
group      = true
groupcol = false
shortdesc  = Right Stick Inner Deadzone:
byteoffset = 58
bitsize    = 32
control    = spinboxf
default    = 013
minimum    = 0
maximum    = 10000
step       = 1
decimals   = 2
 
[Calibration]
group      = false
groupcol = false
shortdesc  = Delay (ms):
byteoffset = 62
bitsize    = 32
control    = slider
default    = 3000
minimum    = 500
maximum    = 10000
step       = 500
 
[CalibrationS]
group      = true
groupcol = false
shortdesc  = Samples:
byteoffset = 66
bitsize    = 32
control    = slider
default    = 300
minimum    = 100
maximum    = 10000
step       = 100
 
</cfgdesc>
*/

 
//Constants
#define PAD_OTHER  0
#define PAD_PS4    1
#define PAD_SWITCH 2
uint8 PAD_IDS[5] = { 6, 5, 4, 2, 1 };
uint8 PAD_IDS_LENGHT = 5;
 
//Persistent memory addereses
#define ADDR_ACTIVATE_L1                     0
#define ADDR_ACTIVATE_L2                     1
#define ADDR_ACTIVATE_R1                     2
#define ADDR_ACTIVATE_R2                     3
#define ADDR_ACTIVATE_ALWAYS_ON             4
 
#define ADDR_BASE_SENSITIVITY_X             5
#define ADDR_BASE_SENSITIVITY_Y             9
#define ADDR_SENSITIVITY_MULTIPLIER_INDEX     13
#define ADDR_SENSITIVITY_MULTIPLIER_0         14
#define ADDR_SENSITIVITY_MULTIPLIER_1         18
#define ADDR_SENSITIVITY_MULTIPLIER_2         22
#define ADDR_SENSITIVITY_MULTIPLIER_3         26
#define ADDR_SENSITIVITY_MULTIPLIER_4         30
#define ADDR_SENSITIVITY_MULTIPLIER_5         34
#define ADDR_SENSITIVITY_MULTIPLIER_6         38
 
#define ADDR_DEADZONE_X                        42
#define ADDR_DEADZONE_Y                        46
#define ADDR_DEADZONE_D                        50
 
#define ADDR_OUTER_DEADZONE                    54
#define ADDR_INNER_DEADZONE                    58
 
#define ADDR_CALIBRATION_DELAY                62
#define ADDR_CALIBRATION_SAMPLES            66
 
#define ADDR_CALIB_PS4_X                     92
#define ADDR_CALIB_PS4_Y                     96
#define ADDR_CALIB_PS4_Z                     100
 
#define ADDR_CALIB_SWITCH_X                 104
#define ADDR_CALIB_SWITCH_Y                 108
#define ADDR_CALIB_SWITCH_Z                 116
 
#define ADDR_CALIB_OTHER_X                     116
#define ADDR_CALIB_OTHER_Y                     120
#define ADDR_CALIB_OTHER_Z                     124
 
 
#define LED_DELAY                            2000
 
//Variables
fix32 mCalibOffsetX = 0.0;
fix32 mCalibOffsetY = 0.0;
fix32 mCalibOffsetZ = 0.0;
 
bool mIsActivatedCalibrating = FALSE;
bool mIsActivatedIncreaseSensitivity = FALSE;
bool mIsActivatedDecreaseSensitivity = FALSE;
bool mIsActivatedLeds = FALSE;
 
fix32 mBaseSensitivityX = 1.0;
fix32 mBaseSensitivityY = 1.6;
uint8 mSensitivityMultiplierIndex = 2;
fix32 mSensitivityMultipliersArray[7] = { 0.5, 0.75, 1.0, 1.25, 1.5, 1.75, 2.0 };
 
uint32 mCalibrationDelay = 3000;
uint32 mCalibrationSamples = 300;
uint32 mCalibrationCycleIndex = 0;
 
fix32 mDeadzoneX = 20.0// Deadzone GYRO_1_YZ Input
fix32 mDeadzoneY = 20.0// Deadzone GYRO_1_YX Input
fix32 mDeadzoneD = 0.38// Deadzone Diagonal input
 
fix32 mOuterDeadzone = 92.00;
fix32 mInnerDeadzone = 0.13;
 
bool mIsActivateL1 = FALSE;
bool mIsActivateL2 = TRUE;
bool mIsActivateR1 = FALSE;
bool mIsActivateR2 = TRUE;
bool mIsAlwaysOn = FALSE;
bool mIsMotionAimingOn = TRUE;
 
uint32 mTimeCounter = 0;
 
bool mIsActivatedDebugging = FALSE;
 
init
{
    pmem_load();
 
    printf("Values loaded:");
 
    pmem_read(ADDR_ACTIVATE_L1, &mIsActivateL1);
    printf("Activate L1: %d", mIsActivateL1);
    pmem_read(ADDR_ACTIVATE_L2, &mIsActivateL2);
    printf("Activate L2: %d", mIsActivateL2);
    pmem_read(ADDR_ACTIVATE_R1, &mIsActivateR1);
    printf("Activate R1: %d", mIsActivateR1);
    pmem_read(ADDR_ACTIVATE_R2, &mIsActivateR2);
    printf("Activate R2: %d", mIsActivateR2);
    pmem_read(ADDR_ACTIVATE_ALWAYS_ON, &mIsAlwaysOn);
    printf("Activate AlwaysOn: %d", mIsAlwaysOn);
 
    pmem_read(ADDR_BASE_SENSITIVITY_X, &mBaseSensitivityX);
    printf("Base sensitivity X: %f", mBaseSensitivityX);
    pmem_read(ADDR_BASE_SENSITIVITY_Y, &mBaseSensitivityY);
    printf("Base sensitivity Y: %f", mBaseSensitivityY);
 
    pmem_read(ADDR_SENSITIVITY_MULTIPLIER_INDEX, &mSensitivityMultiplierIndex);
    mSensitivityMultiplierIndex--;
    printf("Sensitivity multiplier index: %d", mSensitivityMultiplierIndex);
 
    pmem_read(ADDR_SENSITIVITY_MULTIPLIER_0, &mSensitivityMultipliersArray[0]);
    printf("Sensitivity multiplier [0]: %f", mSensitivityMultipliersArray[0]);
    pmem_read(ADDR_SENSITIVITY_MULTIPLIER_1, &mSensitivityMultipliersArray[1]);
    printf("Sensitivity multiplier [1]: %f", mSensitivityMultipliersArray[1]);
    pmem_read(ADDR_SENSITIVITY_MULTIPLIER_2, &mSensitivityMultipliersArray[2]);
    printf("Sensitivity multiplier [2]: %f", mSensitivityMultipliersArray[2]);
    pmem_read(ADDR_SENSITIVITY_MULTIPLIER_3, &mSensitivityMultipliersArray[3]);
    printf("Sensitivity multiplier [3]: %f", mSensitivityMultipliersArray[3]);
    pmem_read(ADDR_SENSITIVITY_MULTIPLIER_4, &mSensitivityMultipliersArray[4]);
    printf("Sensitivity multiplier [4]: %f", mSensitivityMultipliersArray[4]);
    pmem_read(ADDR_SENSITIVITY_MULTIPLIER_5, &mSensitivityMultipliersArray[5]);
    printf("Sensitivity multiplier [5]: %f", mSensitivityMultipliersArray[5]);
    pmem_read(ADDR_SENSITIVITY_MULTIPLIER_6, &mSensitivityMultipliersArray[6]);
    printf("Sensitivity multiplier [6]: %f", mSensitivityMultipliersArray[6]);
 
    pmem_read(ADDR_DEADZONE_X, &mDeadzoneX);
    printf("Deadzone X: %f", mDeadzoneX);
    pmem_read(ADDR_DEADZONE_Y, &mDeadzoneY);
    printf("Deadzone Y: %f", mDeadzoneY);
    pmem_read(ADDR_DEADZONE_D, &mDeadzoneD);
    printf("Deadzone D: %f", mDeadzoneD);
 
    pmem_read(ADDR_OUTER_DEADZONE, &mOuterDeadzone);
    printf("Outer Deadzone: %f", mOuterDeadzone);
    pmem_read(ADDR_INNER_DEADZONE, &mInnerDeadzone);
    printf("Inner Deadzone: %f", mInnerDeadzone);
 
    pmem_read(ADDR_CALIBRATION_DELAY, &mCalibrationDelay);
    printf("Calibration Delay: %d", mCalibrationDelay);
    pmem_read(ADDR_CALIBRATION_SAMPLES, &mCalibrationSamples);
    printf("Calibration Samples: %d", mCalibrationSamples);
 
    FetchCalibration();
    // Load Keyboard maping to Console   
    const uint8 kmap[] = { 0xE2, 0x00, 0x2B, 0x01, 0x29, 0x02, 0x08, 0x03, 0x09, 0x05, 0x14, 0x06, 0x10, 0x07, 0xE1, 0x08, 0x52, 0x09, 0x51, 0x0A, 0x50, 0x0B, 0x4F, 0x0C, 0x1E, 0x09, 0x20, 0x0A, 0x21, 0x0B, 0x1F, 0x0C, 0x0A, 0x0D, 0x06, 0x0E, 0x2C, 0x0F, 0x15, 0x10, 0x23, 0x11, 0x04, 0x97, 0x07, 0x17, 0x1A, 0x98, 0x16, 0x18, 0x3A, 0x26, 0x3B, 0x27, 0x3C, 0x28, 0x3D, 0x29 };
    keymapping(kmap);
    // Load MOUSE maping to Console
    const uint8 mmap[] = { 0x00, 0x1D, 0x01, 0x1E, 0x06, 0x05, 0x08, 0x0D, 0x02, 0x0B, 0x03, 0x0C, 0x07, 0x0E, 0x04, 0x04, 0x05, 0x07 };
    mousemapping(mmap);   
    // Load Controller maping to Console Block
    const uint8 cmap[] = { 0x17, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A };
    remapper(cmap);
}
 
main
{
    ResetLeds();
 
    ActivateIncreaseSensitivity(event_release(PADDLE_1) );
    IncreaseSensitivity();
    ActivateDecreaseSensitivity(event_release(PADDLE_2) );
    DecreaseSensitivity();
 
    ActivateCalibration(get_val(PADDLE_4)> 0.0 );
    Calibrate();
 
    Debug();
 
    ToggleAlwaysOn(get_val(PADDLE_3) > 0.0 && get_prev(BUTTON_13) == 0.0 && get_actual(BUTTON_13) > 0.0);
    ToggleMotionAiming(get_val(PADDLE_3) > 0.0 && get_prev(BUTTON_12) == 0.0 && get_actual(BUTTON_12) > 0.0);
 
    MotionAiming(mIsMotionAimingOn && !mIsActivatedCalibrating && !mIsActivatedDebugging &&
                 (abs(get_val(STICK_1_X)) <= mDeadzoneX && (abs(get_val(STICK_1_Y)) <= mDeadzoneY)) &&
                    (mIsAlwaysOn ||
                    (mIsActivateL1 && (get_val(BUTTON_7) > 98.0)) ||
                    (mIsActivateL2 && (get_val(BUTTON_8) > 98.0)) ||
                    (mIsActivateR1 && (get_val(BUTTON_4) > 98.0)) ||
                    (mIsActivateR2 && (get_val(BUTTON_5) > 98.0))));
 
    AddInnerDeadzone();
    AddOuterDeadzone();
 
    MimicTouch(get_val(BUTTON_2) > 90.0 && GetPadType() != PAD_PS4);
    set_val(ACCEL_1_X, stick_response(ACCEL_1_X));
    set_val(ACCEL_1_Y, stick_response(ACCEL_1_Y));
}
 
void ResetLeds()
{
    if(mIsActivatedLeds)
    {
        if(mTimeCounter > LED_DELAY)
        {
            led_reset();
            mTimeCounter = 0;
        }
        else
        {
            mTimeCounter += elapsed_time();
        }
    }
}
 
void ActivateIncreaseSensitivity(bool aIsActivated)
{
    if(aIsActivated)
    {
        if(mSensitivityMultiplierIndex < 6) //increase sensivity multiplier
            mIsActivatedIncreaseSensitivity = TRUE;
        else
        {
            SetLeds(7);
            mIsActivatedLeds = TRUE;
        }
    }
}
 
void IncreaseSensitivity()
{
    if(mIsActivatedIncreaseSensitivity)
    {
        mSensitivityMultiplierIndex = mSensitivityMultiplierIndex + 1;
        SetLeds(mSensitivityMultiplierIndex+1);
        SaveSensitivityIndex();
        mIsActivatedIncreaseSensitivity = FALSE;
        mIsActivatedLeds = TRUE;
    }       
}
 
void ActivateDecreaseSensitivity(bool aIsActivated)
{
    if(aIsActivated)
    {
        if(mSensitivityMultiplierIndex > 0) //decrease sensivity multiplier
            mIsActivatedDecreaseSensitivity = TRUE;
        else
        {
            SetLeds(0);
            mIsActivatedLeds = TRUE;
        }
    }
}
 
void DecreaseSensitivity()
{
    if(mIsActivatedDecreaseSensitivity)
    {
        mSensitivityMultiplierIndex = mSensitivityMultiplierIndex - 1;
        SetLeds(mSensitivityMultiplierIndex+1);
        SaveSensitivityIndex();
        mIsActivatedDecreaseSensitivity = FALSE;
        mIsActivatedLeds = TRUE;
    }
}
 
void ActivateCalibration(bool aIsActivated)
{
    if(aIsActivated && !mIsActivatedCalibrating)
    {
        mCalibOffsetX = 0.0;
        mCalibOffsetY = 0.0;
        mCalibOffsetZ = 0.0;
        mCalibrationCycleIndex = 0;
        mTimeCounter = 0;
        SetLeds(6);
        printf("Calibration started. Delay: %d, Samples: %d", mCalibrationDelay, mCalibrationSamples);
        mIsActivatedCalibrating = TRUE;
    }
}
 
void Calibrate()
{
    if(mIsActivatedCalibrating)
    {
        mTimeCounter += elapsed_time();
        if(mTimeCounter > mCalibrationDelay)
        {
            SetLeds(15);
            if(mCalibrationCycleIndex < mCalibrationSamples)
            {
                mCalibrationCycleIndex += 1;
 
                mCalibOffsetX += get_actual(ACCEL_1_X);
                mCalibOffsetZ += get_actual(ACCEL_1_Y);
            }
            else
            {
                mCalibOffsetX /= (fix32)mCalibrationSamples;
                mCalibOffsetY /= (fix32)mCalibrationSamples;
                mCalibOffsetZ /= (fix32)mCalibrationSamples;
 
                StoreCalibration();
 
                mTimeCounter = 0;
                led_reset();
                mIsActivatedCalibrating = FALSE;
            }
        }
    }
}
 
void FetchCalibration()
{
    uint8 padType = GetPadType();
    pmem_load();
    switch(padType)
    {
        case PAD_OTHER:
            pmem_read(ADDR_CALIB_OTHER_X, &mCalibOffsetX);
            pmem_read(ADDR_CALIB_OTHER_Y, &mCalibOffsetY);
            pmem_read(ADDR_CALIB_OTHER_Z, &mCalibOffsetZ);
            printf("Other gamepad calibration. X: %f, Y: %f, Z: %f", mCalibOffsetX, mCalibOffsetY, mCalibOffsetZ);
        break;
 
        case PAD_PS4:
            pmem_read(ADDR_CALIB_PS4_X, &mCalibOffsetX);
            pmem_read(ADDR_CALIB_PS4_Y, &mCalibOffsetY);
            pmem_read(ADDR_CALIB_PS4_Z, &mCalibOffsetZ);
            printf("DualShock 4 calibration. X: %f, Y: %f, Z: %f", mCalibOffsetX, mCalibOffsetY, mCalibOffsetZ);
        break;
 
        case PAD_SWITCH:
            pmem_read(ADDR_CALIB_SWITCH_X, &mCalibOffsetX);
            pmem_read(ADDR_CALIB_SWITCH_Y, &mCalibOffsetY);
            pmem_read(ADDR_CALIB_SWITCH_Z, &mCalibOffsetZ);
            printf("Pro Controller calibration. X: %f, Y: %f, Z: %f", mCalibOffsetX, mCalibOffsetY, mCalibOffsetZ);
        break;
    }
}
 
void StoreCalibration()
{
    uint8 padType = GetPadType();
    printf("Pad type set: %d", padType);
    switch(padType)
    {
        case PAD_OTHER:
            pmem_write(ADDR_CALIB_OTHER_X, mCalibOffsetX);
            pmem_write(ADDR_CALIB_OTHER_Y, mCalibOffsetY);
            pmem_write(ADDR_CALIB_OTHER_Z, mCalibOffsetZ);
            printf("Stored other gamepad calibration. X: %f, Y: %f, Z: %f", mCalibOffsetX, mCalibOffsetY, mCalibOffsetZ);
        break;
 
        case PAD_PS4:
            pmem_write(ADDR_CALIB_PS4_X, mCalibOffsetX);
            pmem_write(ADDR_CALIB_PS4_Y, mCalibOffsetY);
            pmem_write(ADDR_CALIB_PS4_Z, mCalibOffsetZ);
            printf("Stored DualShock 4 calibration. X: %f, Y: %f, Z: %f", mCalibOffsetX, mCalibOffsetY, mCalibOffsetZ);
        break;
 
        case PAD_SWITCH:
            pmem_write(ADDR_CALIB_SWITCH_X, mCalibOffsetX);
            pmem_write(ADDR_CALIB_SWITCH_Y, mCalibOffsetY);
            pmem_write(ADDR_CALIB_SWITCH_Z, mCalibOffsetZ);
            printf("Stored Pro Controller calibration. X: %f, Y: %f, Z: %f", mCalibOffsetX, mCalibOffsetY, mCalibOffsetZ);
        break;
    }
    pmem_save();
}
 
uint8 GetPadType()
{
    uint8 status, protocol, device, i = 0;
    while(i < PAD_IDS_LENGHT)
    {
        status = port_status(PAD_IDS[i], &protocol, &device);
        if(status)
        {
            if(protocol == PROTOCOL_PS4)
                return PAD_PS4;
            else if(protocol == PROTOCOL_SWITCH)
                return PAD_SWITCH;
            else
                return PAD_OTHER;
        }
        i++;
    }
    return(-1);
}
 
void Debug()
{
    if(mIsActivatedCalibrating || !mIsActivatedDebugging)
        return;
 
    set_val(GYRO_1_X, (get_val(GYRO_1_X) - mCalibOffsetX) * 1000.0);
    set_val(GYRO_1_Y, (get_val(GYRO_1_Y) - mCalibOffsetY) * 1000.0);
    set_val(GYRO_1_Z, (get_val(GYRO_1_Z) - mCalibOffsetZ) * 1000.0);
}
 
 
void ToggleAlwaysOn(bool aIsActivated)
{
    if(aIsActivated)
    {
        mIsAlwaysOn = !mIsAlwaysOn;
        pmem_write(ADDR_ACTIVATE_ALWAYS_ON, mIsAlwaysOn);
        pmem_save();
    }
}
 
void ToggleMotionAiming(bool aIsActivated)
{
    if(aIsActivated)
    {
        mIsMotionAimingOn = !mIsMotionAimingOn;
    }
}
 
void MotionAiming(bool aIsActivated)
{
    if(aIsActivated)
    {
        static fix32 accelX, accelY;
        static fix32 stickX, stickY;
        if(accelX != get_actual(ACCEL_1_X) || accelY != get_actual(ACCEL_1_Y))
        {
            accelX = get_actual(ACCEL_1_X);
            accelY = get_actual(ACCEL_1_Y);
 
            stickX = (accelX - mCalibOffsetZ) * mBaseSensitivityX * mSensitivityMultipliersArray[mSensitivityMultiplierIndex];
            stickY = (accelY - mCalibOffsetX) * mBaseSensitivityY * mSensitivityMultipliersArray[mSensitivityMultiplierIndex];
 
            fix32 signalX = (stickX < 0.0) ? (stickX = inv(stickX), -1.0) : (stickX > 0.0) ? 1.0 : 0.0;
            fix32 signalY = (stickY < 0.0) ? (stickY = inv(stickY), -1.0) : (stickY > 0.0) ? 1.0 : 0.0;
            fix32 angle = atan2(stickY, stickX);
 
            stickX = clamp(((mDeadzoneX * pow(cos(angle), mDeadzoneD)) + stickX) * signalX, -100.0, 100.0);
            stickY = clamp(((mDeadzoneY * pow(sin(angle), mDeadzoneD)) + stickY) * signalY, -100.0, 100.0);
        }
        set_val(STICK_1_X, stickX);
        set_val(STICK_1_Y, stickY);
        return;
    }
}
 
void AddInnerDeadzone()
{
    if(abs(get_val(STICK_1_Y)) > 5.00 && abs(get_val(STICK_1_Y)) < mInnerDeadzone)
        set_val(STICK_1_Y, 0.0);
 
    if(abs(get_val(STICK_1_X)) > 5.00 && abs(get_val(STICK_1_X)) < mInnerDeadzone)
        set_val(STICK_1_X, 0.0);
}
 
void AddOuterDeadzone()
{
    if(get_val(STICK_1_Y) <= mOuterDeadzone * -1.00)
        set_val(STICK_1_Y, -100);
 
    if(get_val(STICK_1_Y) >= mOuterDeadzone)
        set_val(STICK_1_Y, 100);
 
    if(get_val(STICK_1_X) <= mOuterDeadzone * -1.00)
        set_val(STICK_1_X, -100);
 
    if(get_val(STICK_1_X) >= mOuterDeadzone)
        set_val(STICK_1_X, 100);
}
 
 
void SaveSensitivityIndex()
{
    printf("Sensitivity Index: %d, Sensitivity Multiplier: %f", mSensitivityMultiplierIndex, mSensitivityMultipliersArray[mSensitivityMultiplierIndex]);
    pmem_write(ADDR_SENSITIVITY_MULTIPLIER_INDEX, mSensitivityMultiplierIndex);
    pmem_save();
}
 
void SetLeds(uint8 aLeds)
{
    if(aLeds == 1)
        aLeds = 0;
 
    fix32 bits[4];
    bits[0] = (aLeds & (1 << 0)) == 0 ? 0.0 : 100.0;
    bits[1] = (aLeds & (1 << 1)) == 0 ? 0.0 : 100.0;
    bits[2] = (aLeds & (1 << 2)) == 0 ? 0.0 : 100.0;
    bits[4] = (aLeds & (1 << 3)) == 0 ? 0.0 : 100.0;
 
    led_set(LED_1, bits[0], 800);
    led_set(LED_2, bits[1], 800);
    led_set(LED_3, bits[2], 800);
    led_set(LED_4, bits[3], 800);
}
 
void MimicTouch(bool aIsActivated)
{
    if(aIsActivated)
    {
        set_val(BUTTON_19, 100.0);
        set_val(POINT_1_X, get_actual(ACCEL_1_X));
        set_val(POINT_1_Y, get_actual(ACCEL_1_Y));
        set_val(STICK_1_X, 0.0);
        set_val(STICK_1_Y, 0.0);
    }
}
 
 
fix32 stick_response(uint8 idx) {
    const uint8 mxyc[] = { 0xFF, 0x01, 0x00, 0x01, 0x00, 0x00, 0x33, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x03, 0x06, 0x09, 0x0C, 0x0F, 0x12, 0x15, 0x18, 0x1B, 0x1E, 0x21, 0x24, 0x27, 0x2A, 0x2D, 0x30, 0x33, 0x36, 0x39, 0x3C };
 
    fix32 value = get_actual(idx);
    fix32 signal = (value >= 0.0 ? 1.0 : -1.0);
    value = abs(value);
 
    return(value * signal);
}
User avatar
teddy18
Lieutenant
Lieutenant
 
Posts: 346
Joined: Sun Jul 19, 2015 4:18 pm

Re: Universal Mouse and Keboard Console on The fly

Postby teddy18 » Sun Oct 17, 2021 9:01 pm

Script

Universal Mouse and Keboard Console with Curve Ver 1.8 Ratio 1.83 DD Factor 0.20
Code: Select all
GIVMXYF:FF010001D40033000000000100000306090C0F1215181B1E2124272A2D303336393C

Code: Select all
#pragma METAINFO("Universal Mouse and Keboard Console with Curve", 1, 8, "mss1988 & teddy18")
#include <switch.gph>
 
/*
<cfgdesc>
 
[Gyro Aiming Activation]
byteoffset = 0
bitsize    = 8
control    = checkbox
default    = 0
item       = On L1/LB
 
[Gyro Aiming Activation2]
group      = true
groupcol = true
byteoffset = 1
bitsize    = 8
control    = checkbox
default    = 0
item       = On L2/LT
 
[Gyro Aiming Activation3]
group      = true
groupcol = true
byteoffset = 2
bitsize    = 8
control    = checkbox
default    = 0
item       = On R1/RB
 
[Gyro Aiming Activation4]
group      = true
groupcol = true
byteoffset = 3
bitsize    = 8
control    = checkbox
default    = 0
item       = On R2/RT
 
[Gyro Aiming Activation5]
group      = true
groupcol = true
byteoffset = 4
bitsize    = 8
control    = checkbox
default    = 1
item       = Always On
 
[Sensitivity]
group      = false
shortdesc  = Base sensitivity X
byteoffset = 5
bitsize    = 32
control    = spinboxf
default    = 100
minimum    = 10
maximum    = 20000
step       = 1
decimals   = 2
 
[SensitivityY]
group      = true
groupcol = true
shortdesc  = Base sensitivity Y
byteoffset = 9
bitsize    = 32
control    = spinboxf
default    = 160
minimum    = 10
maximum    = 20000
step       = 1
decimals   = 2
 
[Sensitivity Multipliers]
group      = false
groupcol = false
shortdesc  = Active Sensitivity Multiplier:
byteoffset = 13
bitsize    = 8
control    = slider
default    = 3
minimum    = 1
maximum    = 7
step       = 1
 
[Sensitivity Multipliers1]
group      = true
groupcol = false
shortdesc  = Sensitivity Multiplier 1:
byteoffset = 14
bitsize    = 32
control    = spinboxf
default    = 50
minimum    = 10
maximum    = 1000
step       = 1
decimals   = 2
 
[Sensitivity Multipliers2]
group      = true
groupcol = false
shortdesc  = Sensitivity Multiplier 2:
byteoffset = 18
bitsize    = 32
control    = spinboxf
default    = 75
minimum    = 10
maximum    = 1000
step       = 1
decimals   = 2
 
[Sensitivity Multipliers3]
group      = true
groupcol = false
shortdesc  = Sensitivity Multiplier 3:
byteoffset = 22
bitsize    = 32
control    = spinboxf
default    = 100
minimum    = 10
maximum    = 1000
step       = 1
decimals   = 2
 
[Sensitivity Multipliers4]
group      = true
groupcol = false
shortdesc  = Sensitivity Multiplier 4:
byteoffset = 26
bitsize    = 32
control    = spinboxf
default    = 125
minimum    = 10
maximum    = 1000
step       = 1
decimals   = 2
 
[Sensitivity Multipliers5]
group      = true
groupcol = false
shortdesc  = Sensitivity Multiplier 5:
byteoffset = 30
bitsize    = 32
control    = spinboxf
default    = 150
minimum    = 10
maximum    = 1000
step       = 1
decimals   = 2
 
[Sensitivity Multipliers6]
group      = true
groupcol = false
shortdesc  = Sensitivity Multiplier 6:
byteoffset = 34
bitsize    = 32
control    = spinboxf
default    = 175
minimum    = 10
maximum    = 1000
step       = 1
decimals   = 2
 
[Sensitivity Multipliers7]
group      = true
groupcol = false
shortdesc  = Sensitivity Multiplier 7:
byteoffset = 38
bitsize    = 32
control    = spinboxf
default    = 200
minimum    = 10
maximum    = 1000
step       = 1
decimals   = 2
 
[Deadzones]
group      = false
shortdesc  = Ignore Gyro if Right Stick X is greater than:
byteoffset = 42
bitsize    = 32
control    = spinboxf
default    = 200
minimum    = 0
maximum    = 1000
step       = 1
decimals   = 1
 
[DeadzonesY]
group      = true
groupcol = false
shortdesc  = Ignore Gyro if Right Stick Y is greater than:
byteoffset = 46
bitsize    = 32
control    = spinboxf
default    = 200
minimum    = 0
maximum    = 1000
step       = 1
decimals   = 1
 
[DeadzonesD]
group      = true
groupcol = false
shortdesc  = Right Stick Diagonal Deadzone:
byteoffset = 50
bitsize    = 32
control    = spinboxf
default    = 38
minimum    = 0
maximum    = 200
step       = 1
decimals   = 2
 
[DeadzonesO]
group      = true
groupcol = false
shortdesc  = Right Stick Outer Deadzone:
byteoffset = 54
bitsize    = 32
control    = spinboxf
default    = 9200
minimum    = 0
maximum    = 10000
step       = 1
decimals   = 2
 
[DeadzonesI]
group      = true
groupcol = false
shortdesc  = Right Stick Inner Deadzone:
byteoffset = 58
bitsize    = 32
control    = spinboxf
default    = 013
minimum    = 0
maximum    = 10000
step       = 1
decimals   = 2
 
[Calibration]
group      = false
groupcol = false
shortdesc  = Delay (ms):
byteoffset = 62
bitsize    = 32
control    = slider
default    = 3000
minimum    = 500
maximum    = 10000
step       = 500
 
[CalibrationS]
group      = true
groupcol = false
shortdesc  = Samples:
byteoffset = 66
bitsize    = 32
control    = slider
default    = 300
minimum    = 100
maximum    = 10000
step       = 100
 
</cfgdesc>
*/

 
//Constants
#define PAD_OTHER  0
#define PAD_PS4    1
#define PAD_SWITCH 2
uint8 PAD_IDS[5] = { 6, 5, 4, 2, 1 };
uint8 PAD_IDS_LENGHT = 5;
 
//Persistent memory addereses
#define ADDR_ACTIVATE_L1                     0
#define ADDR_ACTIVATE_L2                     1
#define ADDR_ACTIVATE_R1                     2
#define ADDR_ACTIVATE_R2                     3
#define ADDR_ACTIVATE_ALWAYS_ON             4
 
#define ADDR_BASE_SENSITIVITY_X             5
#define ADDR_BASE_SENSITIVITY_Y             9
#define ADDR_SENSITIVITY_MULTIPLIER_INDEX     13
#define ADDR_SENSITIVITY_MULTIPLIER_0         14
#define ADDR_SENSITIVITY_MULTIPLIER_1         18
#define ADDR_SENSITIVITY_MULTIPLIER_2         22
#define ADDR_SENSITIVITY_MULTIPLIER_3         26
#define ADDR_SENSITIVITY_MULTIPLIER_4         30
#define ADDR_SENSITIVITY_MULTIPLIER_5         34
#define ADDR_SENSITIVITY_MULTIPLIER_6         38
 
#define ADDR_DEADZONE_X                        42
#define ADDR_DEADZONE_Y                        46
#define ADDR_DEADZONE_D                        50
 
#define ADDR_OUTER_DEADZONE                    54
#define ADDR_INNER_DEADZONE                    58
 
#define ADDR_CALIBRATION_DELAY                62
#define ADDR_CALIBRATION_SAMPLES            66
 
#define ADDR_CALIB_PS4_X                     92
#define ADDR_CALIB_PS4_Y                     96
#define ADDR_CALIB_PS4_Z                     100
 
#define ADDR_CALIB_SWITCH_X                 104
#define ADDR_CALIB_SWITCH_Y                 108
#define ADDR_CALIB_SWITCH_Z                 116
 
#define ADDR_CALIB_OTHER_X                     116
#define ADDR_CALIB_OTHER_Y                     120
#define ADDR_CALIB_OTHER_Z                     124
 
 
#define LED_DELAY                            2000
 
//Variables
fix32 mCalibOffsetX = 0.0;
fix32 mCalibOffsetY = 0.0;
fix32 mCalibOffsetZ = 0.0;
 
bool mIsActivatedCalibrating = FALSE;
bool mIsActivatedIncreaseSensitivity = FALSE;
bool mIsActivatedDecreaseSensitivity = FALSE;
bool mIsActivatedLeds = FALSE;
 
fix32 mBaseSensitivityX = 1.0;
fix32 mBaseSensitivityY = 1.6;
uint8 mSensitivityMultiplierIndex = 2;
fix32 mSensitivityMultipliersArray[7] = { 0.5, 0.75, 1.0, 1.25, 1.5, 1.75, 2.0 };
 
uint32 mCalibrationDelay = 3000;
uint32 mCalibrationSamples = 300;
uint32 mCalibrationCycleIndex = 0;
 
fix32 mDeadzoneX = 20.0// Deadzone GYRO_1_YZ Input
fix32 mDeadzoneY = 20.0// Deadzone GYRO_1_YX Input
fix32 mDeadzoneD = 0.38// Deadzone Diagonal input
 
fix32 mOuterDeadzone = 92.00;
fix32 mInnerDeadzone = 0.13;
 
bool mIsActivateL1 = FALSE;
bool mIsActivateL2 = TRUE;
bool mIsActivateR1 = FALSE;
bool mIsActivateR2 = TRUE;
bool mIsAlwaysOn = FALSE;
bool mIsMotionAimingOn = TRUE;
 
uint32 mTimeCounter = 0;
 
bool mIsActivatedDebugging = FALSE;
 
init
{
    pmem_load();
 
    printf("Values loaded:");
 
    pmem_read(ADDR_ACTIVATE_L1, &mIsActivateL1);
    printf("Activate L1: %d", mIsActivateL1);
    pmem_read(ADDR_ACTIVATE_L2, &mIsActivateL2);
    printf("Activate L2: %d", mIsActivateL2);
    pmem_read(ADDR_ACTIVATE_R1, &mIsActivateR1);
    printf("Activate R1: %d", mIsActivateR1);
    pmem_read(ADDR_ACTIVATE_R2, &mIsActivateR2);
    printf("Activate R2: %d", mIsActivateR2);
    pmem_read(ADDR_ACTIVATE_ALWAYS_ON, &mIsAlwaysOn);
    printf("Activate AlwaysOn: %d", mIsAlwaysOn);
 
    pmem_read(ADDR_BASE_SENSITIVITY_X, &mBaseSensitivityX);
    printf("Base sensitivity X: %f", mBaseSensitivityX);
    pmem_read(ADDR_BASE_SENSITIVITY_Y, &mBaseSensitivityY);
    printf("Base sensitivity Y: %f", mBaseSensitivityY);
 
    pmem_read(ADDR_SENSITIVITY_MULTIPLIER_INDEX, &mSensitivityMultiplierIndex);
    mSensitivityMultiplierIndex--;
    printf("Sensitivity multiplier index: %d", mSensitivityMultiplierIndex);
 
    pmem_read(ADDR_SENSITIVITY_MULTIPLIER_0, &mSensitivityMultipliersArray[0]);
    printf("Sensitivity multiplier [0]: %f", mSensitivityMultipliersArray[0]);
    pmem_read(ADDR_SENSITIVITY_MULTIPLIER_1, &mSensitivityMultipliersArray[1]);
    printf("Sensitivity multiplier [1]: %f", mSensitivityMultipliersArray[1]);
    pmem_read(ADDR_SENSITIVITY_MULTIPLIER_2, &mSensitivityMultipliersArray[2]);
    printf("Sensitivity multiplier [2]: %f", mSensitivityMultipliersArray[2]);
    pmem_read(ADDR_SENSITIVITY_MULTIPLIER_3, &mSensitivityMultipliersArray[3]);
    printf("Sensitivity multiplier [3]: %f", mSensitivityMultipliersArray[3]);
    pmem_read(ADDR_SENSITIVITY_MULTIPLIER_4, &mSensitivityMultipliersArray[4]);
    printf("Sensitivity multiplier [4]: %f", mSensitivityMultipliersArray[4]);
    pmem_read(ADDR_SENSITIVITY_MULTIPLIER_5, &mSensitivityMultipliersArray[5]);
    printf("Sensitivity multiplier [5]: %f", mSensitivityMultipliersArray[5]);
    pmem_read(ADDR_SENSITIVITY_MULTIPLIER_6, &mSensitivityMultipliersArray[6]);
    printf("Sensitivity multiplier [6]: %f", mSensitivityMultipliersArray[6]);
 
    pmem_read(ADDR_DEADZONE_X, &mDeadzoneX);
    printf("Deadzone X: %f", mDeadzoneX);
    pmem_read(ADDR_DEADZONE_Y, &mDeadzoneY);
    printf("Deadzone Y: %f", mDeadzoneY);
    pmem_read(ADDR_DEADZONE_D, &mDeadzoneD);
    printf("Deadzone D: %f", mDeadzoneD);
 
    pmem_read(ADDR_OUTER_DEADZONE, &mOuterDeadzone);
    printf("Outer Deadzone: %f", mOuterDeadzone);
    pmem_read(ADDR_INNER_DEADZONE, &mInnerDeadzone);
    printf("Inner Deadzone: %f", mInnerDeadzone);
 
    pmem_read(ADDR_CALIBRATION_DELAY, &mCalibrationDelay);
    printf("Calibration Delay: %d", mCalibrationDelay);
    pmem_read(ADDR_CALIBRATION_SAMPLES, &mCalibrationSamples);
    printf("Calibration Samples: %d", mCalibrationSamples);
 
    FetchCalibration();
    // Load Keyboard maping to Console   
    const uint8 kmap[] = { 0xE2, 0x00, 0x2B, 0x01, 0x29, 0x02, 0x08, 0x03, 0x09, 0x05, 0x14, 0x06, 0x10, 0x07, 0xE1, 0x08, 0x52, 0x09, 0x51, 0x0A, 0x50, 0x0B, 0x4F, 0x0C, 0x1E, 0x09, 0x20, 0x0A, 0x21, 0x0B, 0x1F, 0x0C, 0x0A, 0x0D, 0x06, 0x0E, 0x2C, 0x0F, 0x15, 0x10, 0x23, 0x11, 0x04, 0x97, 0x07, 0x17, 0x1A, 0x98, 0x16, 0x18, 0x3A, 0x26, 0x3B, 0x27, 0x3C, 0x28, 0x3D, 0x29 };
    keymapping(kmap);
    // Load MOUSE maping to Console
    const uint8 mmap[] = { 0x00, 0x1D, 0x01, 0x1E, 0x06, 0x05, 0x08, 0x0D, 0x02, 0x0B, 0x03, 0x0C, 0x07, 0x0E, 0x04, 0x04, 0x05, 0x07 };
    mousemapping(mmap);   
    // Load Controller maping to Console Block
    const uint8 cmap[] = { 0x17, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A };
    remapper(cmap);
}
 
main
{
    ResetLeds();
 
    ActivateIncreaseSensitivity(event_release(PADDLE_1) );
    IncreaseSensitivity();
    ActivateDecreaseSensitivity(event_release(PADDLE_2) );
    DecreaseSensitivity();
 
    ActivateCalibration(get_val(PADDLE_4)> 0.0 );
    Calibrate();
 
    Debug();
 
    ToggleAlwaysOn(get_val(PADDLE_3) > 0.0 && get_prev(BUTTON_13) == 0.0 && get_actual(BUTTON_13) > 0.0);
    ToggleMotionAiming(get_val(PADDLE_3) > 0.0 && get_prev(BUTTON_12) == 0.0 && get_actual(BUTTON_12) > 0.0);
 
    MotionAiming(mIsMotionAimingOn && !mIsActivatedCalibrating && !mIsActivatedDebugging &&
                 (abs(get_val(STICK_1_X)) <= mDeadzoneX && (abs(get_val(STICK_1_Y)) <= mDeadzoneY)) &&
                    (mIsAlwaysOn ||
                    (mIsActivateL1 && (get_val(BUTTON_7) > 98.0)) ||
                    (mIsActivateL2 && (get_val(BUTTON_8) > 98.0)) ||
                    (mIsActivateR1 && (get_val(BUTTON_4) > 98.0)) ||
                    (mIsActivateR2 && (get_val(BUTTON_5) > 98.0))));
 
    AddInnerDeadzone();
    AddOuterDeadzone();
 
    MimicTouch(get_val(BUTTON_2) > 90.0 && GetPadType() != PAD_PS4);
    set_val(ACCEL_1_X, stick_response(ACCEL_1_X));
    set_val(ACCEL_1_Y, stick_response(ACCEL_1_Y));
}
 
void ResetLeds()
{
    if(mIsActivatedLeds)
    {
        if(mTimeCounter > LED_DELAY)
        {
            led_reset();
            mTimeCounter = 0;
        }
        else
        {
            mTimeCounter += elapsed_time();
        }
    }
}
 
void ActivateIncreaseSensitivity(bool aIsActivated)
{
    if(aIsActivated)
    {
        if(mSensitivityMultiplierIndex < 6) //increase sensivity multiplier
            mIsActivatedIncreaseSensitivity = TRUE;
        else
        {
            SetLeds(7);
            mIsActivatedLeds = TRUE;
        }
    }
}
 
void IncreaseSensitivity()
{
    if(mIsActivatedIncreaseSensitivity)
    {
        mSensitivityMultiplierIndex = mSensitivityMultiplierIndex + 1;
        SetLeds(mSensitivityMultiplierIndex+1);
        SaveSensitivityIndex();
        mIsActivatedIncreaseSensitivity = FALSE;
        mIsActivatedLeds = TRUE;
    }       
}
 
void ActivateDecreaseSensitivity(bool aIsActivated)
{
    if(aIsActivated)
    {
        if(mSensitivityMultiplierIndex > 0) //decrease sensivity multiplier
            mIsActivatedDecreaseSensitivity = TRUE;
        else
        {
            SetLeds(0);
            mIsActivatedLeds = TRUE;
        }
    }
}
 
void DecreaseSensitivity()
{
    if(mIsActivatedDecreaseSensitivity)
    {
        mSensitivityMultiplierIndex = mSensitivityMultiplierIndex - 1;
        SetLeds(mSensitivityMultiplierIndex+1);
        SaveSensitivityIndex();
        mIsActivatedDecreaseSensitivity = FALSE;
        mIsActivatedLeds = TRUE;
    }
}
 
void ActivateCalibration(bool aIsActivated)
{
    if(aIsActivated && !mIsActivatedCalibrating)
    {
        mCalibOffsetX = 0.0;
        mCalibOffsetY = 0.0;
        mCalibOffsetZ = 0.0;
        mCalibrationCycleIndex = 0;
        mTimeCounter = 0;
        SetLeds(6);
        printf("Calibration started. Delay: %d, Samples: %d", mCalibrationDelay, mCalibrationSamples);
        mIsActivatedCalibrating = TRUE;
    }
}
 
void Calibrate()
{
    if(mIsActivatedCalibrating)
    {
        mTimeCounter += elapsed_time();
        if(mTimeCounter > mCalibrationDelay)
        {
            SetLeds(15);
            if(mCalibrationCycleIndex < mCalibrationSamples)
            {
                mCalibrationCycleIndex += 1;
 
                mCalibOffsetX += get_actual(ACCEL_1_X);
                mCalibOffsetZ += get_actual(ACCEL_1_Y);
            }
            else
            {
                mCalibOffsetX /= (fix32)mCalibrationSamples;
                mCalibOffsetY /= (fix32)mCalibrationSamples;
                mCalibOffsetZ /= (fix32)mCalibrationSamples;
 
                StoreCalibration();
 
                mTimeCounter = 0;
                led_reset();
                mIsActivatedCalibrating = FALSE;
            }
        }
    }
}
 
void FetchCalibration()
{
    uint8 padType = GetPadType();
    pmem_load();
    switch(padType)
    {
        case PAD_OTHER:
            pmem_read(ADDR_CALIB_OTHER_X, &mCalibOffsetX);
            pmem_read(ADDR_CALIB_OTHER_Y, &mCalibOffsetY);
            pmem_read(ADDR_CALIB_OTHER_Z, &mCalibOffsetZ);
            printf("Other gamepad calibration. X: %f, Y: %f, Z: %f", mCalibOffsetX, mCalibOffsetY, mCalibOffsetZ);
        break;
 
        case PAD_PS4:
            pmem_read(ADDR_CALIB_PS4_X, &mCalibOffsetX);
            pmem_read(ADDR_CALIB_PS4_Y, &mCalibOffsetY);
            pmem_read(ADDR_CALIB_PS4_Z, &mCalibOffsetZ);
            printf("DualShock 4 calibration. X: %f, Y: %f, Z: %f", mCalibOffsetX, mCalibOffsetY, mCalibOffsetZ);
        break;
 
        case PAD_SWITCH:
            pmem_read(ADDR_CALIB_SWITCH_X, &mCalibOffsetX);
            pmem_read(ADDR_CALIB_SWITCH_Y, &mCalibOffsetY);
            pmem_read(ADDR_CALIB_SWITCH_Z, &mCalibOffsetZ);
            printf("Pro Controller calibration. X: %f, Y: %f, Z: %f", mCalibOffsetX, mCalibOffsetY, mCalibOffsetZ);
        break;
    }
}
 
void StoreCalibration()
{
    uint8 padType = GetPadType();
    printf("Pad type set: %d", padType);
    switch(padType)
    {
        case PAD_OTHER:
            pmem_write(ADDR_CALIB_OTHER_X, mCalibOffsetX);
            pmem_write(ADDR_CALIB_OTHER_Y, mCalibOffsetY);
            pmem_write(ADDR_CALIB_OTHER_Z, mCalibOffsetZ);
            printf("Stored other gamepad calibration. X: %f, Y: %f, Z: %f", mCalibOffsetX, mCalibOffsetY, mCalibOffsetZ);
        break;
 
        case PAD_PS4:
            pmem_write(ADDR_CALIB_PS4_X, mCalibOffsetX);
            pmem_write(ADDR_CALIB_PS4_Y, mCalibOffsetY);
            pmem_write(ADDR_CALIB_PS4_Z, mCalibOffsetZ);
            printf("Stored DualShock 4 calibration. X: %f, Y: %f, Z: %f", mCalibOffsetX, mCalibOffsetY, mCalibOffsetZ);
        break;
 
        case PAD_SWITCH:
            pmem_write(ADDR_CALIB_SWITCH_X, mCalibOffsetX);
            pmem_write(ADDR_CALIB_SWITCH_Y, mCalibOffsetY);
            pmem_write(ADDR_CALIB_SWITCH_Z, mCalibOffsetZ);
            printf("Stored Pro Controller calibration. X: %f, Y: %f, Z: %f", mCalibOffsetX, mCalibOffsetY, mCalibOffsetZ);
        break;
    }
    pmem_save();
}
 
uint8 GetPadType()
{
    uint8 status, protocol, device, i = 0;
    while(i < PAD_IDS_LENGHT)
    {
        status = port_status(PAD_IDS[i], &protocol, &device);
        if(status)
        {
            if(protocol == PROTOCOL_PS4)
                return PAD_PS4;
            else if(protocol == PROTOCOL_SWITCH)
                return PAD_SWITCH;
            else
                return PAD_OTHER;
        }
        i++;
    }
    return(-1);
}
 
void Debug()
{
    if(mIsActivatedCalibrating || !mIsActivatedDebugging)
        return;
 
    set_val(GYRO_1_X, (get_val(GYRO_1_X) - mCalibOffsetX) * 1000.0);
    set_val(GYRO_1_Y, (get_val(GYRO_1_Y) - mCalibOffsetY) * 1000.0);
    set_val(GYRO_1_Z, (get_val(GYRO_1_Z) - mCalibOffsetZ) * 1000.0);
}
 
 
void ToggleAlwaysOn(bool aIsActivated)
{
    if(aIsActivated)
    {
        mIsAlwaysOn = !mIsAlwaysOn;
        pmem_write(ADDR_ACTIVATE_ALWAYS_ON, mIsAlwaysOn);
        pmem_save();
    }
}
 
void ToggleMotionAiming(bool aIsActivated)
{
    if(aIsActivated)
    {
        mIsMotionAimingOn = !mIsMotionAimingOn;
    }
}
 
void MotionAiming(bool aIsActivated)
{
    if(aIsActivated)
    {
        static fix32 accelX, accelY;
        static fix32 stickX, stickY;
        if(accelX != get_actual(ACCEL_1_X) || accelY != get_actual(ACCEL_1_Y))
        {
            accelX = get_actual(ACCEL_1_X);
            accelY = get_actual(ACCEL_1_Y);
 
            stickX = (accelX - mCalibOffsetZ) * mBaseSensitivityX * mSensitivityMultipliersArray[mSensitivityMultiplierIndex];
            stickY = (accelY - mCalibOffsetX) * mBaseSensitivityY * mSensitivityMultipliersArray[mSensitivityMultiplierIndex];
 
            fix32 signalX = (stickX < 0.0) ? (stickX = inv(stickX), -1.0) : (stickX > 0.0) ? 1.0 : 0.0;
            fix32 signalY = (stickY < 0.0) ? (stickY = inv(stickY), -1.0) : (stickY > 0.0) ? 1.0 : 0.0;
            fix32 angle = atan2(stickY, stickX);
 
            stickX = clamp(((mDeadzoneX * pow(cos(angle), mDeadzoneD)) + stickX) * signalX, -100.0, 100.0);
            stickY = clamp(((mDeadzoneY * pow(sin(angle), mDeadzoneD)) + stickY) * signalY, -100.0, 100.0);
        }
        set_val(STICK_1_X, stickX);
        set_val(STICK_1_Y, stickY);
        return;
    }
}
 
void AddInnerDeadzone()
{
    if(abs(get_val(STICK_1_Y)) > 5.00 && abs(get_val(STICK_1_Y)) < mInnerDeadzone)
        set_val(STICK_1_Y, 0.0);
 
    if(abs(get_val(STICK_1_X)) > 5.00 && abs(get_val(STICK_1_X)) < mInnerDeadzone)
        set_val(STICK_1_X, 0.0);
}
 
void AddOuterDeadzone()
{
    if(get_val(STICK_1_Y) <= mOuterDeadzone * -1.00)
        set_val(STICK_1_Y, -100);
 
    if(get_val(STICK_1_Y) >= mOuterDeadzone)
        set_val(STICK_1_Y, 100);
 
    if(get_val(STICK_1_X) <= mOuterDeadzone * -1.00)
        set_val(STICK_1_X, -100);
 
    if(get_val(STICK_1_X) >= mOuterDeadzone)
        set_val(STICK_1_X, 100);
}
 
 
void SaveSensitivityIndex()
{
    printf("Sensitivity Index: %d, Sensitivity Multiplier: %f", mSensitivityMultiplierIndex, mSensitivityMultipliersArray[mSensitivityMultiplierIndex]);
    pmem_write(ADDR_SENSITIVITY_MULTIPLIER_INDEX, mSensitivityMultiplierIndex);
    pmem_save();
}
 
void SetLeds(uint8 aLeds)
{
    if(aLeds == 1)
        aLeds = 0;
 
    fix32 bits[4];
    bits[0] = (aLeds & (1 << 0)) == 0 ? 0.0 : 100.0;
    bits[1] = (aLeds & (1 << 1)) == 0 ? 0.0 : 100.0;
    bits[2] = (aLeds & (1 << 2)) == 0 ? 0.0 : 100.0;
    bits[4] = (aLeds & (1 << 3)) == 0 ? 0.0 : 100.0;
 
    led_set(LED_1, bits[0], 800);
    led_set(LED_2, bits[1], 800);
    led_set(LED_3, bits[2], 800);
    led_set(LED_4, bits[3], 800);
}
 
void MimicTouch(bool aIsActivated)
{
    if(aIsActivated)
    {
        set_val(BUTTON_19, 100.0);
        set_val(POINT_1_X, get_actual(ACCEL_1_X));
        set_val(POINT_1_Y, get_actual(ACCEL_1_Y));
        set_val(STICK_1_X, 0.0);
        set_val(STICK_1_Y, 0.0);
    }
}
 
 
fix32 stick_response(uint8 idx) {
    const uint8 mxyc[] = { 0xFF, 0x01, 0x00, 0x01, 0xD4, 0x00, 0x33, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x03, 0x06, 0x09, 0x0C, 0x0F, 0x12, 0x15, 0x18, 0x1B, 0x1E, 0x21, 0x24, 0x27, 0x2A, 0x2D, 0x30, 0x33, 0x36, 0x39, 0x3C };
 
    fix32 value = get_actual(idx);
    fix32 signal = (value >= 0.0 ? 1.0 : -1.0);
    value = abs(value);
 
    return(value * signal);
}


Universal Mouse and Keboard Console with Curve Ver 1.9 Ratio 1.83 DD Factor 0.14
Code: Select all
GIVMXYF:FF010001D40023000000000100000306090C0F1215181B1E2124272A2D303336393C

Code: Select all
#pragma METAINFO("Universal Mouse and Keboard Console with Curve", 1, 9, "mss1988 & teddy18")
#include <switch.gph>
 
/*
<cfgdesc>
 
[Gyro Aiming Activation]
byteoffset = 0
bitsize    = 8
control    = checkbox
default    = 0
item       = On L1/LB
 
[Gyro Aiming Activation2]
group      = true
groupcol = true
byteoffset = 1
bitsize    = 8
control    = checkbox
default    = 0
item       = On L2/LT
 
[Gyro Aiming Activation3]
group      = true
groupcol = true
byteoffset = 2
bitsize    = 8
control    = checkbox
default    = 0
item       = On R1/RB
 
[Gyro Aiming Activation4]
group      = true
groupcol = true
byteoffset = 3
bitsize    = 8
control    = checkbox
default    = 0
item       = On R2/RT
 
[Gyro Aiming Activation5]
group      = true
groupcol = true
byteoffset = 4
bitsize    = 8
control    = checkbox
default    = 1
item       = Always On
 
[Sensitivity]
group      = false
shortdesc  = Base sensitivity X
byteoffset = 5
bitsize    = 32
control    = spinboxf
default    = 100
minimum    = 10
maximum    = 20000
step       = 1
decimals   = 2
 
[SensitivityY]
group      = true
groupcol = true
shortdesc  = Base sensitivity Y
byteoffset = 9
bitsize    = 32
control    = spinboxf
default    = 160
minimum    = 10
maximum    = 20000
step       = 1
decimals   = 2
 
[Sensitivity Multipliers]
group      = false
groupcol = false
shortdesc  = Active Sensitivity Multiplier:
byteoffset = 13
bitsize    = 8
control    = slider
default    = 3
minimum    = 1
maximum    = 7
step       = 1
 
[Sensitivity Multipliers1]
group      = true
groupcol = false
shortdesc  = Sensitivity Multiplier 1:
byteoffset = 14
bitsize    = 32
control    = spinboxf
default    = 50
minimum    = 10
maximum    = 1000
step       = 1
decimals   = 2
 
[Sensitivity Multipliers2]
group      = true
groupcol = false
shortdesc  = Sensitivity Multiplier 2:
byteoffset = 18
bitsize    = 32
control    = spinboxf
default    = 75
minimum    = 10
maximum    = 1000
step       = 1
decimals   = 2
 
[Sensitivity Multipliers3]
group      = true
groupcol = false
shortdesc  = Sensitivity Multiplier 3:
byteoffset = 22
bitsize    = 32
control    = spinboxf
default    = 100
minimum    = 10
maximum    = 1000
step       = 1
decimals   = 2
 
[Sensitivity Multipliers4]
group      = true
groupcol = false
shortdesc  = Sensitivity Multiplier 4:
byteoffset = 26
bitsize    = 32
control    = spinboxf
default    = 125
minimum    = 10
maximum    = 1000
step       = 1
decimals   = 2
 
[Sensitivity Multipliers5]
group      = true
groupcol = false
shortdesc  = Sensitivity Multiplier 5:
byteoffset = 30
bitsize    = 32
control    = spinboxf
default    = 150
minimum    = 10
maximum    = 1000
step       = 1
decimals   = 2
 
[Sensitivity Multipliers6]
group      = true
groupcol = false
shortdesc  = Sensitivity Multiplier 6:
byteoffset = 34
bitsize    = 32
control    = spinboxf
default    = 175
minimum    = 10
maximum    = 1000
step       = 1
decimals   = 2
 
[Sensitivity Multipliers7]
group      = true
groupcol = false
shortdesc  = Sensitivity Multiplier 7:
byteoffset = 38
bitsize    = 32
control    = spinboxf
default    = 200
minimum    = 10
maximum    = 1000
step       = 1
decimals   = 2
 
[Deadzones]
group      = false
shortdesc  = Ignore Gyro if Right Stick X is greater than:
byteoffset = 42
bitsize    = 32
control    = spinboxf
default    = 200
minimum    = 0
maximum    = 1000
step       = 1
decimals   = 1
 
[DeadzonesY]
group      = true
groupcol = false
shortdesc  = Ignore Gyro if Right Stick Y is greater than:
byteoffset = 46
bitsize    = 32
control    = spinboxf
default    = 200
minimum    = 0
maximum    = 1000
step       = 1
decimals   = 1
 
[DeadzonesD]
group      = true
groupcol = false
shortdesc  = Right Stick Diagonal Deadzone:
byteoffset = 50
bitsize    = 32
control    = spinboxf
default    = 38
minimum    = 0
maximum    = 200
step       = 1
decimals   = 2
 
[DeadzonesO]
group      = true
groupcol = false
shortdesc  = Right Stick Outer Deadzone:
byteoffset = 54
bitsize    = 32
control    = spinboxf
default    = 9200
minimum    = 0
maximum    = 10000
step       = 1
decimals   = 2
 
[DeadzonesI]
group      = true
groupcol = false
shortdesc  = Right Stick Inner Deadzone:
byteoffset = 58
bitsize    = 32
control    = spinboxf
default    = 013
minimum    = 0
maximum    = 10000
step       = 1
decimals   = 2
 
[Calibration]
group      = false
groupcol = false
shortdesc  = Delay (ms):
byteoffset = 62
bitsize    = 32
control    = slider
default    = 3000
minimum    = 500
maximum    = 10000
step       = 500
 
[CalibrationS]
group      = true
groupcol = false
shortdesc  = Samples:
byteoffset = 66
bitsize    = 32
control    = slider
default    = 300
minimum    = 100
maximum    = 10000
step       = 100
 
</cfgdesc>
*/

 
//Constants
#define PAD_OTHER  0
#define PAD_PS4    1
#define PAD_SWITCH 2
uint8 PAD_IDS[5] = { 6, 5, 4, 2, 1 };
uint8 PAD_IDS_LENGHT = 5;
 
//Persistent memory addereses
#define ADDR_ACTIVATE_L1                     0
#define ADDR_ACTIVATE_L2                     1
#define ADDR_ACTIVATE_R1                     2
#define ADDR_ACTIVATE_R2                     3
#define ADDR_ACTIVATE_ALWAYS_ON             4
 
#define ADDR_BASE_SENSITIVITY_X             5
#define ADDR_BASE_SENSITIVITY_Y             9
#define ADDR_SENSITIVITY_MULTIPLIER_INDEX     13
#define ADDR_SENSITIVITY_MULTIPLIER_0         14
#define ADDR_SENSITIVITY_MULTIPLIER_1         18
#define ADDR_SENSITIVITY_MULTIPLIER_2         22
#define ADDR_SENSITIVITY_MULTIPLIER_3         26
#define ADDR_SENSITIVITY_MULTIPLIER_4         30
#define ADDR_SENSITIVITY_MULTIPLIER_5         34
#define ADDR_SENSITIVITY_MULTIPLIER_6         38
 
#define ADDR_DEADZONE_X                        42
#define ADDR_DEADZONE_Y                        46
#define ADDR_DEADZONE_D                        50
 
#define ADDR_OUTER_DEADZONE                    54
#define ADDR_INNER_DEADZONE                    58
 
#define ADDR_CALIBRATION_DELAY                62
#define ADDR_CALIBRATION_SAMPLES            66
 
#define ADDR_CALIB_PS4_X                     92
#define ADDR_CALIB_PS4_Y                     96
#define ADDR_CALIB_PS4_Z                     100
 
#define ADDR_CALIB_SWITCH_X                 104
#define ADDR_CALIB_SWITCH_Y                 108
#define ADDR_CALIB_SWITCH_Z                 116
 
#define ADDR_CALIB_OTHER_X                     116
#define ADDR_CALIB_OTHER_Y                     120
#define ADDR_CALIB_OTHER_Z                     124
 
 
#define LED_DELAY                            2000
 
//Variables
fix32 mCalibOffsetX = 0.0;
fix32 mCalibOffsetY = 0.0;
fix32 mCalibOffsetZ = 0.0;
 
bool mIsActivatedCalibrating = FALSE;
bool mIsActivatedIncreaseSensitivity = FALSE;
bool mIsActivatedDecreaseSensitivity = FALSE;
bool mIsActivatedLeds = FALSE;
 
fix32 mBaseSensitivityX = 1.0;
fix32 mBaseSensitivityY = 1.6;
uint8 mSensitivityMultiplierIndex = 2;
fix32 mSensitivityMultipliersArray[7] = { 0.5, 0.75, 1.0, 1.25, 1.5, 1.75, 2.0 };
 
uint32 mCalibrationDelay = 3000;
uint32 mCalibrationSamples = 300;
uint32 mCalibrationCycleIndex = 0;
 
fix32 mDeadzoneX = 20.0// Deadzone GYRO_1_YZ Input
fix32 mDeadzoneY = 20.0// Deadzone GYRO_1_YX Input
fix32 mDeadzoneD = 0.38// Deadzone Diagonal input
 
fix32 mOuterDeadzone = 92.00;
fix32 mInnerDeadzone = 0.13;
 
bool mIsActivateL1 = FALSE;
bool mIsActivateL2 = TRUE;
bool mIsActivateR1 = FALSE;
bool mIsActivateR2 = TRUE;
bool mIsAlwaysOn = FALSE;
bool mIsMotionAimingOn = TRUE;
 
uint32 mTimeCounter = 0;
 
bool mIsActivatedDebugging = FALSE;
 
init
{
    pmem_load();
 
    printf("Values loaded:");
 
    pmem_read(ADDR_ACTIVATE_L1, &mIsActivateL1);
    printf("Activate L1: %d", mIsActivateL1);
    pmem_read(ADDR_ACTIVATE_L2, &mIsActivateL2);
    printf("Activate L2: %d", mIsActivateL2);
    pmem_read(ADDR_ACTIVATE_R1, &mIsActivateR1);
    printf("Activate R1: %d", mIsActivateR1);
    pmem_read(ADDR_ACTIVATE_R2, &mIsActivateR2);
    printf("Activate R2: %d", mIsActivateR2);
    pmem_read(ADDR_ACTIVATE_ALWAYS_ON, &mIsAlwaysOn);
    printf("Activate AlwaysOn: %d", mIsAlwaysOn);
 
    pmem_read(ADDR_BASE_SENSITIVITY_X, &mBaseSensitivityX);
    printf("Base sensitivity X: %f", mBaseSensitivityX);
    pmem_read(ADDR_BASE_SENSITIVITY_Y, &mBaseSensitivityY);
    printf("Base sensitivity Y: %f", mBaseSensitivityY);
 
    pmem_read(ADDR_SENSITIVITY_MULTIPLIER_INDEX, &mSensitivityMultiplierIndex);
    mSensitivityMultiplierIndex--;
    printf("Sensitivity multiplier index: %d", mSensitivityMultiplierIndex);
 
    pmem_read(ADDR_SENSITIVITY_MULTIPLIER_0, &mSensitivityMultipliersArray[0]);
    printf("Sensitivity multiplier [0]: %f", mSensitivityMultipliersArray[0]);
    pmem_read(ADDR_SENSITIVITY_MULTIPLIER_1, &mSensitivityMultipliersArray[1]);
    printf("Sensitivity multiplier [1]: %f", mSensitivityMultipliersArray[1]);
    pmem_read(ADDR_SENSITIVITY_MULTIPLIER_2, &mSensitivityMultipliersArray[2]);
    printf("Sensitivity multiplier [2]: %f", mSensitivityMultipliersArray[2]);
    pmem_read(ADDR_SENSITIVITY_MULTIPLIER_3, &mSensitivityMultipliersArray[3]);
    printf("Sensitivity multiplier [3]: %f", mSensitivityMultipliersArray[3]);
    pmem_read(ADDR_SENSITIVITY_MULTIPLIER_4, &mSensitivityMultipliersArray[4]);
    printf("Sensitivity multiplier [4]: %f", mSensitivityMultipliersArray[4]);
    pmem_read(ADDR_SENSITIVITY_MULTIPLIER_5, &mSensitivityMultipliersArray[5]);
    printf("Sensitivity multiplier [5]: %f", mSensitivityMultipliersArray[5]);
    pmem_read(ADDR_SENSITIVITY_MULTIPLIER_6, &mSensitivityMultipliersArray[6]);
    printf("Sensitivity multiplier [6]: %f", mSensitivityMultipliersArray[6]);
 
    pmem_read(ADDR_DEADZONE_X, &mDeadzoneX);
    printf("Deadzone X: %f", mDeadzoneX);
    pmem_read(ADDR_DEADZONE_Y, &mDeadzoneY);
    printf("Deadzone Y: %f", mDeadzoneY);
    pmem_read(ADDR_DEADZONE_D, &mDeadzoneD);
    printf("Deadzone D: %f", mDeadzoneD);
 
    pmem_read(ADDR_OUTER_DEADZONE, &mOuterDeadzone);
    printf("Outer Deadzone: %f", mOuterDeadzone);
    pmem_read(ADDR_INNER_DEADZONE, &mInnerDeadzone);
    printf("Inner Deadzone: %f", mInnerDeadzone);
 
    pmem_read(ADDR_CALIBRATION_DELAY, &mCalibrationDelay);
    printf("Calibration Delay: %d", mCalibrationDelay);
    pmem_read(ADDR_CALIBRATION_SAMPLES, &mCalibrationSamples);
    printf("Calibration Samples: %d", mCalibrationSamples);
 
    FetchCalibration();
    // Load Keyboard maping to Console   
    const uint8 kmap[] = { 0xE2, 0x00, 0x2B, 0x01, 0x29, 0x02, 0x08, 0x03, 0x09, 0x05, 0x14, 0x06, 0x10, 0x07, 0xE1, 0x08, 0x52, 0x09, 0x51, 0x0A, 0x50, 0x0B, 0x4F, 0x0C, 0x1E, 0x09, 0x20, 0x0A, 0x21, 0x0B, 0x1F, 0x0C, 0x0A, 0x0D, 0x06, 0x0E, 0x2C, 0x0F, 0x15, 0x10, 0x23, 0x11, 0x04, 0x97, 0x07, 0x17, 0x1A, 0x98, 0x16, 0x18, 0x3A, 0x26, 0x3B, 0x27, 0x3C, 0x28, 0x3D, 0x29 };
    keymapping(kmap);
    // Load MOUSE maping to Console
    const uint8 mmap[] = { 0x00, 0x1D, 0x01, 0x1E, 0x06, 0x05, 0x08, 0x0D, 0x02, 0x0B, 0x03, 0x0C, 0x07, 0x0E, 0x04, 0x04, 0x05, 0x07 };
    mousemapping(mmap);   
    // Load Controller maping to Console Block
    const uint8 cmap[] = { 0x17, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A };
    remapper(cmap);
}
 
main
{
    ResetLeds();
 
    ActivateIncreaseSensitivity(event_release(PADDLE_1) );
    IncreaseSensitivity();
    ActivateDecreaseSensitivity(event_release(PADDLE_2) );
    DecreaseSensitivity();
 
    ActivateCalibration(get_val(PADDLE_4)> 0.0 );
    Calibrate();
 
    Debug();
 
    ToggleAlwaysOn(get_val(PADDLE_3) > 0.0 && get_prev(BUTTON_13) == 0.0 && get_actual(BUTTON_13) > 0.0);
    ToggleMotionAiming(get_val(PADDLE_3) > 0.0 && get_prev(BUTTON_12) == 0.0 && get_actual(BUTTON_12) > 0.0);
 
    MotionAiming(mIsMotionAimingOn && !mIsActivatedCalibrating && !mIsActivatedDebugging &&
                 (abs(get_val(STICK_1_X)) <= mDeadzoneX && (abs(get_val(STICK_1_Y)) <= mDeadzoneY)) &&
                    (mIsAlwaysOn ||
                    (mIsActivateL1 && (get_val(BUTTON_7) > 98.0)) ||
                    (mIsActivateL2 && (get_val(BUTTON_8) > 98.0)) ||
                    (mIsActivateR1 && (get_val(BUTTON_4) > 98.0)) ||
                    (mIsActivateR2 && (get_val(BUTTON_5) > 98.0))));
 
    AddInnerDeadzone();
    AddOuterDeadzone();
 
    MimicTouch(get_val(BUTTON_2) > 90.0 && GetPadType() != PAD_PS4);
    set_val(ACCEL_1_X, stick_response(ACCEL_1_X));
    set_val(ACCEL_1_Y, stick_response(ACCEL_1_Y));
}
 
void ResetLeds()
{
    if(mIsActivatedLeds)
    {
        if(mTimeCounter > LED_DELAY)
        {
            led_reset();
            mTimeCounter = 0;
        }
        else
        {
            mTimeCounter += elapsed_time();
        }
    }
}
 
void ActivateIncreaseSensitivity(bool aIsActivated)
{
    if(aIsActivated)
    {
        if(mSensitivityMultiplierIndex < 6) //increase sensivity multiplier
            mIsActivatedIncreaseSensitivity = TRUE;
        else
        {
            SetLeds(7);
            mIsActivatedLeds = TRUE;
        }
    }
}
 
void IncreaseSensitivity()
{
    if(mIsActivatedIncreaseSensitivity)
    {
        mSensitivityMultiplierIndex = mSensitivityMultiplierIndex + 1;
        SetLeds(mSensitivityMultiplierIndex+1);
        SaveSensitivityIndex();
        mIsActivatedIncreaseSensitivity = FALSE;
        mIsActivatedLeds = TRUE;
    }       
}
 
void ActivateDecreaseSensitivity(bool aIsActivated)
{
    if(aIsActivated)
    {
        if(mSensitivityMultiplierIndex > 0) //decrease sensivity multiplier
            mIsActivatedDecreaseSensitivity = TRUE;
        else
        {
            SetLeds(0);
            mIsActivatedLeds = TRUE;
        }
    }
}
 
void DecreaseSensitivity()
{
    if(mIsActivatedDecreaseSensitivity)
    {
        mSensitivityMultiplierIndex = mSensitivityMultiplierIndex - 1;
        SetLeds(mSensitivityMultiplierIndex+1);
        SaveSensitivityIndex();
        mIsActivatedDecreaseSensitivity = FALSE;
        mIsActivatedLeds = TRUE;
    }
}
 
void ActivateCalibration(bool aIsActivated)
{
    if(aIsActivated && !mIsActivatedCalibrating)
    {
        mCalibOffsetX = 0.0;
        mCalibOffsetY = 0.0;
        mCalibOffsetZ = 0.0;
        mCalibrationCycleIndex = 0;
        mTimeCounter = 0;
        SetLeds(6);
        printf("Calibration started. Delay: %d, Samples: %d", mCalibrationDelay, mCalibrationSamples);
        mIsActivatedCalibrating = TRUE;
    }
}
 
void Calibrate()
{
    if(mIsActivatedCalibrating)
    {
        mTimeCounter += elapsed_time();
        if(mTimeCounter > mCalibrationDelay)
        {
            SetLeds(15);
            if(mCalibrationCycleIndex < mCalibrationSamples)
            {
                mCalibrationCycleIndex += 1;
 
                mCalibOffsetX += get_actual(ACCEL_1_X);
                mCalibOffsetZ += get_actual(ACCEL_1_Y);
            }
            else
            {
                mCalibOffsetX /= (fix32)mCalibrationSamples;
                mCalibOffsetY /= (fix32)mCalibrationSamples;
                mCalibOffsetZ /= (fix32)mCalibrationSamples;
 
                StoreCalibration();
 
                mTimeCounter = 0;
                led_reset();
                mIsActivatedCalibrating = FALSE;
            }
        }
    }
}
 
void FetchCalibration()
{
    uint8 padType = GetPadType();
    pmem_load();
    switch(padType)
    {
        case PAD_OTHER:
            pmem_read(ADDR_CALIB_OTHER_X, &mCalibOffsetX);
            pmem_read(ADDR_CALIB_OTHER_Y, &mCalibOffsetY);
            pmem_read(ADDR_CALIB_OTHER_Z, &mCalibOffsetZ);
            printf("Other gamepad calibration. X: %f, Y: %f, Z: %f", mCalibOffsetX, mCalibOffsetY, mCalibOffsetZ);
        break;
 
        case PAD_PS4:
            pmem_read(ADDR_CALIB_PS4_X, &mCalibOffsetX);
            pmem_read(ADDR_CALIB_PS4_Y, &mCalibOffsetY);
            pmem_read(ADDR_CALIB_PS4_Z, &mCalibOffsetZ);
            printf("DualShock 4 calibration. X: %f, Y: %f, Z: %f", mCalibOffsetX, mCalibOffsetY, mCalibOffsetZ);
        break;
 
        case PAD_SWITCH:
            pmem_read(ADDR_CALIB_SWITCH_X, &mCalibOffsetX);
            pmem_read(ADDR_CALIB_SWITCH_Y, &mCalibOffsetY);
            pmem_read(ADDR_CALIB_SWITCH_Z, &mCalibOffsetZ);
            printf("Pro Controller calibration. X: %f, Y: %f, Z: %f", mCalibOffsetX, mCalibOffsetY, mCalibOffsetZ);
        break;
    }
}
 
void StoreCalibration()
{
    uint8 padType = GetPadType();
    printf("Pad type set: %d", padType);
    switch(padType)
    {
        case PAD_OTHER:
            pmem_write(ADDR_CALIB_OTHER_X, mCalibOffsetX);
            pmem_write(ADDR_CALIB_OTHER_Y, mCalibOffsetY);
            pmem_write(ADDR_CALIB_OTHER_Z, mCalibOffsetZ);
            printf("Stored other gamepad calibration. X: %f, Y: %f, Z: %f", mCalibOffsetX, mCalibOffsetY, mCalibOffsetZ);
        break;
 
        case PAD_PS4:
            pmem_write(ADDR_CALIB_PS4_X, mCalibOffsetX);
            pmem_write(ADDR_CALIB_PS4_Y, mCalibOffsetY);
            pmem_write(ADDR_CALIB_PS4_Z, mCalibOffsetZ);
            printf("Stored DualShock 4 calibration. X: %f, Y: %f, Z: %f", mCalibOffsetX, mCalibOffsetY, mCalibOffsetZ);
        break;
 
        case PAD_SWITCH:
            pmem_write(ADDR_CALIB_SWITCH_X, mCalibOffsetX);
            pmem_write(ADDR_CALIB_SWITCH_Y, mCalibOffsetY);
            pmem_write(ADDR_CALIB_SWITCH_Z, mCalibOffsetZ);
            printf("Stored Pro Controller calibration. X: %f, Y: %f, Z: %f", mCalibOffsetX, mCalibOffsetY, mCalibOffsetZ);
        break;
    }
    pmem_save();
}
 
uint8 GetPadType()
{
    uint8 status, protocol, device, i = 0;
    while(i < PAD_IDS_LENGHT)
    {
        status = port_status(PAD_IDS[i], &protocol, &device);
        if(status)
        {
            if(protocol == PROTOCOL_PS4)
                return PAD_PS4;
            else if(protocol == PROTOCOL_SWITCH)
                return PAD_SWITCH;
            else
                return PAD_OTHER;
        }
        i++;
    }
    return(-1);
}
 
void Debug()
{
    if(mIsActivatedCalibrating || !mIsActivatedDebugging)
        return;
 
    set_val(GYRO_1_X, (get_val(GYRO_1_X) - mCalibOffsetX) * 1000.0);
    set_val(GYRO_1_Y, (get_val(GYRO_1_Y) - mCalibOffsetY) * 1000.0);
    set_val(GYRO_1_Z, (get_val(GYRO_1_Z) - mCalibOffsetZ) * 1000.0);
}
 
 
void ToggleAlwaysOn(bool aIsActivated)
{
    if(aIsActivated)
    {
        mIsAlwaysOn = !mIsAlwaysOn;
        pmem_write(ADDR_ACTIVATE_ALWAYS_ON, mIsAlwaysOn);
        pmem_save();
    }
}
 
void ToggleMotionAiming(bool aIsActivated)
{
    if(aIsActivated)
    {
        mIsMotionAimingOn = !mIsMotionAimingOn;
    }
}
 
void MotionAiming(bool aIsActivated)
{
    if(aIsActivated)
    {
        static fix32 accelX, accelY;
        static fix32 stickX, stickY;
        if(accelX != get_actual(ACCEL_1_X) || accelY != get_actual(ACCEL_1_Y))
        {
            accelX = get_actual(ACCEL_1_X);
            accelY = get_actual(ACCEL_1_Y);
 
            stickX = (accelX - mCalibOffsetZ) * mBaseSensitivityX * mSensitivityMultipliersArray[mSensitivityMultiplierIndex];
            stickY = (accelY - mCalibOffsetX) * mBaseSensitivityY * mSensitivityMultipliersArray[mSensitivityMultiplierIndex];
 
            fix32 signalX = (stickX < 0.0) ? (stickX = inv(stickX), -1.0) : (stickX > 0.0) ? 1.0 : 0.0;
            fix32 signalY = (stickY < 0.0) ? (stickY = inv(stickY), -1.0) : (stickY > 0.0) ? 1.0 : 0.0;
            fix32 angle = atan2(stickY, stickX);
 
            stickX = clamp(((mDeadzoneX * pow(cos(angle), mDeadzoneD)) + stickX) * signalX, -100.0, 100.0);
            stickY = clamp(((mDeadzoneY * pow(sin(angle), mDeadzoneD)) + stickY) * signalY, -100.0, 100.0);
        }
        set_val(STICK_1_X, stickX);
        set_val(STICK_1_Y, stickY);
        return;
    }
}
 
void AddInnerDeadzone()
{
    if(abs(get_val(STICK_1_Y)) > 5.00 && abs(get_val(STICK_1_Y)) < mInnerDeadzone)
        set_val(STICK_1_Y, 0.0);
 
    if(abs(get_val(STICK_1_X)) > 5.00 && abs(get_val(STICK_1_X)) < mInnerDeadzone)
        set_val(STICK_1_X, 0.0);
}
 
void AddOuterDeadzone()
{
    if(get_val(STICK_1_Y) <= mOuterDeadzone * -1.00)
        set_val(STICK_1_Y, -100);
 
    if(get_val(STICK_1_Y) >= mOuterDeadzone)
        set_val(STICK_1_Y, 100);
 
    if(get_val(STICK_1_X) <= mOuterDeadzone * -1.00)
        set_val(STICK_1_X, -100);
 
    if(get_val(STICK_1_X) >= mOuterDeadzone)
        set_val(STICK_1_X, 100);
}
 
 
void SaveSensitivityIndex()
{
    printf("Sensitivity Index: %d, Sensitivity Multiplier: %f", mSensitivityMultiplierIndex, mSensitivityMultipliersArray[mSensitivityMultiplierIndex]);
    pmem_write(ADDR_SENSITIVITY_MULTIPLIER_INDEX, mSensitivityMultiplierIndex);
    pmem_save();
}
 
void SetLeds(uint8 aLeds)
{
    if(aLeds == 1)
        aLeds = 0;
 
    fix32 bits[4];
    bits[0] = (aLeds & (1 << 0)) == 0 ? 0.0 : 100.0;
    bits[1] = (aLeds & (1 << 1)) == 0 ? 0.0 : 100.0;
    bits[2] = (aLeds & (1 << 2)) == 0 ? 0.0 : 100.0;
    bits[4] = (aLeds & (1 << 3)) == 0 ? 0.0 : 100.0;
 
    led_set(LED_1, bits[0], 800);
    led_set(LED_2, bits[1], 800);
    led_set(LED_3, bits[2], 800);
    led_set(LED_4, bits[3], 800);
}
 
void MimicTouch(bool aIsActivated)
{
    if(aIsActivated)
    {
        set_val(BUTTON_19, 100.0);
        set_val(POINT_1_X, get_actual(ACCEL_1_X));
        set_val(POINT_1_Y, get_actual(ACCEL_1_Y));
        set_val(STICK_1_X, 0.0);
        set_val(STICK_1_Y, 0.0);
    }
}
 
 
fix32 stick_response(uint8 idx) {
    const uint8 mxyc[] = { 0xFF, 0x01, 0x00, 0x01, 0xD4, 0x00, 0x23, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x03, 0x06, 0x09, 0x0C, 0x0F, 0x12, 0x15, 0x18, 0x1B, 0x1E, 0x21, 0x24, 0x27, 0x2A, 0x2D, 0x30, 0x33, 0x36, 0x39, 0x3C };
 
    fix32 value = get_actual(idx);
    fix32 signal = (value >= 0.0 ? 1.0 : -1.0);
    value = abs(value);
 
    return(value * signal);
}
User avatar
teddy18
Lieutenant
Lieutenant
 
Posts: 346
Joined: Sun Jul 19, 2015 4:18 pm

Re: Universal Mouse and Keyboard Console on The fly New Vers

Postby teddy18 » Fri Nov 05, 2021 8:03 pm

New Version Deadzone Shape Circle
You can Use Gtuner Or if you have the Bluetooh Modul Gtuner Air to Interactive Configuration Adjustmant Deadzone

Titan Two Settings
Set on Titan 2 800 Dpi
Set on Titan 2 Input Poling Rate 1000Hz
Set on Titan 2 Output Poling 250Hu
Mouse 500 Hz Dpi 3200 Dpi

Keyboard Controls
WASD Left Stick
Q L1/LB/L
E R1/RB/R
R Square/X/Y
F R3/RS/SR
C Circle/B/A
G Triangle/Y/X
Tap Touch Click/View /Minus/Select/Back
For Ps4 and Ps5 Hold Tap move mouse for Touch mimic

Left Shift L3/LS/SR
Spacebar Cross/A/B
ESC Options/Menu/Plus/Start
Left Alt PS/Xbox/Home/Guide
1 DPad Up
2 DPad Right
3 DPad Down
4 DPad Left
Up Arrow DPad Up
Right Arrow DPad Right
Down Arrow DPad Down
Left Arrow DPad Left
6 Share/Capture
T Push To Talk

Mouse
Left Button R2/RT /ZR
Right Button L2/LT/ZL
Button 4 Circle/B/A
Button5 Triangle/Y/X
Wheal Middel Button R3/RS/SR
Whael Up DPad Left
Wheal Donw DPad Right
Code: Select all
#pragma METAINFO("Mouse Keyboard Script Dz Shape Circle ", 1, 0, "teddy18")
#import "example-file.git"
#include "DZ.gph"
 
#define PAD_OTHER  0
#define PAD_PS4    1
#define PAD_PS5 2
uint8 PAD_IDS[5] = { 6, 5, 4, 2, 1 };
uint8 PAD_IDS_LENGHT = 5;
init {
    remapper(example_file_cmap);
    keymapping(example_file_kmap);
    mousemapping(example_file_mmap);
    mxyconverter(example_file_mxyc);
    push_to_talk(FALSE);
}
main {
    MimicTouch(get_val(BUTTON_2) > 90.0 && GetPadType() != PAD_PS4);
    MimicTouch(get_val(BUTTON_2) > 90.0 && GetPadType() != PAD_PS5);
    if(event_active(PADDLE_1)) {push_to_talk(TRUE);} else if(event_release(PADDLE_1)) {push_to_talk(FALSE);}
}
uint8 GetPadType()
{
    uint8 status, protocol, device, i = 0;
    while(i < PAD_IDS_LENGHT)
    {
        status = port_status(PAD_IDS[i], &protocol, &device);
        if(status)
        {
            if(protocol == PROTOCOL_PS4)
                return PAD_PS4;
            else if(protocol == PROTOCOL_PS5)
                return PAD_PS5;
 
        }
        i++;
    }
    return(-1);
}
void MimicTouch(bool aIsActivated)
{
    if(aIsActivated)
    {
        set_val(BUTTON_19, 100.0);
        set_val(POINT_1_X, get_actual(STICK_1_X));
        set_val(POINT_1_Y, get_actual(STICK_1_Y));
        set_val(STICK_1_X, 0.0);
        set_val(STICK_1_Y, 0.0);
    }
}


    DZ.gph
    DZ
    (18.34 KiB) Downloaded 73 times
Code: Select all
#ifndef DZ
#define DZ
#define init                    init
#define main                    main
/*
<cfgdesc>
 
 
[CircularDeadzoneHip]
group      = false
shortdesc  = Change Value of the game's circular deadzone:
byteoffset = 42
bitsize    = 32
control    = spinboxf
default    = 0
minimum    = 000
maximum    = 080
step       = 1
decimals   = 2
 
[CircularDeadzoneEllipseYScaleHip]
group      = false
shortdesc  = Only Change Vaulu if you have after Changing CircularDeadzone problem ellipical will control width and this the height:
byteoffset = 46
bitsize    = 32
control    = spinboxf
default    = 0
minimum    = 000
maximum    = 100
step       = 1
decimals   = 2
 
[SquareDeadzoneHip]
group      = false
shortdesc  = Change Value of the game's square/axial deadzone:
byteoffset = 50
bitsize    = 32
control    = spinboxf
default    = 0
minimum    = 000
maximum    = 080
step       = 1
decimals   = 2
 
[RectangleYScaleHip]
group      = false
shortdesc  = Only Change Vaulu if you have after Changing SquareDeadzone problem rectangular will control width and this the height:
byteoffset = 54
bitsize    = 32
control    = spinboxf
default    = 0
minimum    = 000
maximum    = 100
step       = 1
decimals   = 2
 
[degreeHip]
group      = false
shortdesc  = Cancel the game's linear curve to make movment Faster
byteoffset = 58
bitsize    = 32
control    = spinboxf
default    = 100
minimum    = 100
maximum    = 200
step       = 1
decimals   = 2
 
[axialRestrictHip]
group      = false
shortdesc  = Restrict diagonal movement based on distance from the axis:
byteoffset = 62
bitsize    = 32
control    = spinboxf
default    = 0
minimum    = 000
maximum    = 100
step       = 1
decimals   = 2
 
[angularRestrictHip]
group      = false
shortdesc  = Restrict diagonal movement based on distance from the axis:
byteoffset = 66
bitsize    = 32
control    = spinboxf
default    = 0
minimum    = 000
maximum    = 090
step       = 1
decimals   = 2
 
[angularAntiHip]
group      = false
shortdesc  = Use to counter reticted diagonal movement around the axes based on angle:
byteoffset = 70
bitsize    = 32
control    = spinboxf
default    = 0
minimum    = 000
maximum    = 090
step       = 1
decimals   = 2
 
[diagonalScaleMinHip]
group      = false
shortdesc  = scaling the diagonal values Mostly useful for games that don't normalize input/require reach the corners:
byteoffset = 74
bitsize    = 32
control    = spinboxf
default    = 100
minimum    = 100
maximum    = 200
step       = 1
decimals   = 2
 
[diagonalScaleMaxHip]
group      = false
shortdesc  = scaling the diagonal values Mostly useful for games that don't normalize input/require reach the corners:
byteoffset = 78
bitsize    = 32
control    = spinboxf
default    = 100
minimum    = 100
maximum    = 200
step       = 1
decimals   = 2
 
[CircularDeadzoneAds]
group      = false
shortdesc  = Change Value of the game's circular deadzone:
byteoffset = 82
bitsize    = 32
control    = spinboxf
default    = 0
minimum    = 000
maximum    = 080
step       = 1
decimals   = 2
 
[CircularDeadzoneEllipseYScaleAds]
group      = false
shortdesc  = Only Change Vaulu if you have after Changing CircularDeadzone problem ellipical will control width and this the height:
byteoffset = 86
bitsize    = 32
control    = spinboxf
default    = 0
minimum    = 000
maximum    = 100
step       = 1
decimals   = 2
 
[SquareDeadzoneAds]
group      = false
shortdesc  = Change Value of the game's square/axial deadzone:
byteoffset = 90
bitsize    = 32
control    = spinboxf
default    = 0
minimum    = 000
maximum    = 080
step       = 1
decimals   = 2
 
[RectangleYScaleAds]
group      = false
shortdesc  = Only Change Vaulu if you have after Changing SquareDeadzone problem rectangular will control width and this the height:
byteoffset = 94
bitsize    = 32
control    = spinboxf
default    = 0
minimum    = 000
maximum    = 100
step       = 1
decimals   = 2
 
[degreeAds]
group      = false
shortdesc  = Cancel the game's linear curve to make movment Faster
byteoffset = 98
bitsize    = 32
control    = spinboxf
default    = 100
minimum    = 100
maximum    = 200
step       = 1
decimals   = 2
 
[axialRestrictAds]
group      = false
shortdesc  = Restrict diagonal movement based on distance from the axis:
byteoffset = 102
bitsize    = 32
control    = spinboxf
default    = 0
minimum    = 000
maximum    = 100
step       = 1
decimals   = 2
 
[angularRestrictAds]
group      = false
shortdesc  = Restrict diagonal movement based on distance from the axis:
byteoffset = 106
bitsize    = 32
control    = spinboxf
default    = 0
minimum    = 000
maximum    = 090
step       = 1
decimals   = 2
 
[angularAntiAds]
group      = false
shortdesc  = Use to counter reticted diagonal movement around the axes based on angle:
byteoffset = 110
bitsize    = 32
control    = spinboxf
default    = 0
minimum    = 000
maximum    = 090
step       = 1
decimals   = 2
 
[diagonalScaleMinAds]
group      = false
shortdesc  = scaling the diagonal values Mostly useful for games that don't normalize input/require reach the corners:
byteoffset = 114
bitsize    = 32
control    = spinboxf
default    = 100
minimum    = 100
maximum    = 200
step       = 1
decimals   = 2
 
[diagonalScaleMaxAds]
group      = false
shortdesc  = scaling the diagonal values Mostly useful for games that don't normalize input/require reach the corners:
byteoffset = 118
bitsize    = 32
control    = spinboxf
default    = 100
minimum    = 100
maximum    = 200
step       = 1
decimals   = 2
 
</cfgdesc>
*/

    //CHANGE BELOW VALUES
#define CircularDeadzoneHip                     42
#define CircularDeadzoneEllipseYScaleHip        46
#define SquareDeadzoneHip                       50
#define RectangleYScaleHip                      54
#define degreeHip                               58
#define axialRestrictHip                        62
#define angularRestrictHip                      66
#define angularAntiHip                      70
#define diagonalScaleMinHip                     74
#define diagonalScaleMaxHip                     78
#define CircularDeadzoneAds                     82
#define CircularDeadzoneEllipseYScaleAds        86
#define SquareDeadzoneAds                       90
#define RectangleYScaleAds                      94
#define degreeAds                               98
#define axialRestrictAds                        102
#define angularRestrictAds                      106
#define angularAntiAds                      110
#define diagonalScaleMinAds                     114
#define diagonalScaleMaxAds                     118
 
    //RIGHT STICK SETTINGS
    fix32 deadzone                =  0.00;    //Enter value of desired circular deadzone.
    fix32 antiCircularDeadzone    =  0.00;    //Enter value of the game's circular deadzone.  Common sizes are 0.2 to 0.25.
    fix32 antiEllipseYScale       =  0.00;    //Only change if deadzone is ellipical.  When changed, antiCircleDeadzone will control width and this the height.
    fix32 antiSquareDeadzone      =  0.00;    //Enter value of the game's square/axial deadzone.  Common sizes are 0.2 to 0.25.
    fix32 antiRectangleYScale     =  0.00;    //Only change if deadzone is rectangular.  When changed, antiSquareDeadzone will control the width and this the height.
    fix32 outerDeadzoneIn         =  1.04;     //Only useful if user's stick is unable to reach certain magnitudes.  1.00 is ideal normnally.
    fix32 outerDeadzoneOut        =  1.00;    //Enter value of the maximum range you want to limit stick output. Do not use values over 1.
    fix32 degree                  =  1.00;    //Enter value of the game's curve to cancel it into a linear curve.  Larger values result in faster starting movement.
    fix32 axialRestrict           =  0.00;    //Restrict diagonal movement based on distance from the axis.
    fix32 angularRestrict         =  0.00;    //Restrict diagonal movement around axis based on angle.
    fix32 angularAnti             =  0.00;    //Use to counter reticted diagonal movement around the axes based on angle.
    fix32 diagonalScaleMin        =  1.00;    ///Use to warp lower magnitude diagonal values.
    fix32 diagonalScaleMax        =  1.00;    //Use to warp higher magnitude diagonal values.
    bool  uncapValues             =  FALSE;   //Choose if to uncap values beyond the outerDeadzone.
 
    int8 useAlternate             =  50;     //Choose to use alternate settings when a button is held down.
    int8 useAlternate2          =  50;      //Please use values of ~42-60 to ignore buttons, or replace value of the button you'd
                       //like to use to switch to the alternate values below.  The button values can be
                          //found in the leftmost column from Help > GPC Input Reference or by pressing F1.
    //RIGHT STICK ALTERNATE SETTINGS
    fix32 deadzoneA               =  0.00;
    fix32 antiCircularDeadzoneA   =  0.00;
    fix32 antiEllipseYScaleA      =  0.00;
    fix32 antiSquareDeadzoneA     =  0.00;
    fix32 antiRectangleYScaleA    =  0.00;
    fix32 outerDeadzoneInA        =  1.04;
    fix32 outerDeadzoneOutA       =  1.00;
    fix32 degreeA                 =  1.00;
    fix32 axialRestrictA          =  0.00;
    fix32 angularRestrictA        =  0.00;
    fix32 angularAntiA            =  0.00;
    fix32 diagonalScaleMinA       =  1.00;
    fix32 diagonalScaleMaxA       =  1.00;
    bool  uncapValuesA            =  FALSE;
 
    //RIGHT STICK ALTERNATE 2 SETTINGS
    fix32 deadzoneA2              =  0.00;
    fix32 antiCircularDeadzoneA2  =  0.00;
    fix32 antiEllipseYScaleA2     =  0.00;
    fix32 antiSquareDeadzoneA2    =  0.00;
    fix32 antiRectangleYScaleA2   =  0.00;
    fix32 outerDeadzoneInA2       =  1.00;
    fix32 outerDeadzoneOutA2      =  1.00;
    fix32 degreeA2                =  1.00;
    fix32 axialRestrictA2         =  0.00;
    fix32 angularRestrictA2       =  0.00;
    fix32 angularAntiA2           =  0.00;
    fix32 diagonalScaleMinA2      =  1.00;
    fix32 diagonalScaleMaxA2      =  1.00;
    bool  uncapValuesA2           =  FALSE;
fix32 stickRX, stickRY;
 
init
{
    pmem_load();
 
    printf("Values loaded:");
    pmem_read(CircularDeadzoneHip, &antiCircularDeadzone);
    printf("CircularDeadzoneHip: %f", antiCircularDeadzone);
 
    pmem_read(CircularDeadzoneEllipseYScaleHip, &antiEllipseYScale);
    printf("CircularDeadzoneEllipseYScaleHip: %f", antiEllipseYScale);
 
    pmem_read(SquareDeadzoneHip, &antiSquareDeadzone);
    printf("SquareDeadzoneHip: %f", antiSquareDeadzone);
 
    pmem_read(RectangleYScaleHip, &antiRectangleYScale);
    printf("RectangleYScaleHip: %f", antiRectangleYScale);
 
    pmem_read(degreeHip, &degree);
    printf("degreeHip: %f", degree);
 
    pmem_read(axialRestrictHip, &axialRestrict);
    printf("axialRestrictHip: %f", axialRestrict);
 
    pmem_read(angularRestrictHip, &angularRestrict);
    printf("angularRestrictHip: %f", angularRestrict);
 
    pmem_read(angularAntiHip, &angularAnti);
    printf("angularAntiHip: %f", angularAnti);
 
    pmem_read(diagonalScaleMinHip, &diagonalScaleMin);
    printf("diagonalScaleMinHip: %f", diagonalScaleMin);
 
    pmem_read(diagonalScaleMaxHip, &diagonalScaleMax);
    printf("diagonalScaleMaxHip: %f", diagonalScaleMax);
 
    pmem_read(CircularDeadzoneAds, &antiCircularDeadzoneA);
    printf("CircularDeadzoneAds: %f", antiCircularDeadzoneA);
 
    pmem_read(CircularDeadzoneEllipseYScaleAds, &antiEllipseYScaleA);
    printf("CircularDeadzoneEllipseYScaleAds: %f", antiEllipseYScaleA);
 
    pmem_read(SquareDeadzoneAds, &antiSquareDeadzoneA);
    printf("SquareDeadzoneAds: %f", antiSquareDeadzoneA);
 
    pmem_read(RectangleYScaleAds, &antiRectangleYScaleA);
    printf("RectangleYScaleAds: %f", antiRectangleYScaleA);
 
    pmem_read(degreeAds, &degreeA);
    printf("degreeAds: %f", degreeA);
 
    pmem_read(angularRestrictAds, &angularRestrictA);
    printf("angularRestrictAds: %f", angularRestrictA);
 
    pmem_read(angularAntiAds, &angularAntiA);
    printf("angularAntiAds: %f", angularAntiA);
 
    pmem_read(diagonalScaleMinAds, &diagonalScaleMinA);
    printf("diagonalScaleMinAds: %f", diagonalScaleMinA);
 
    pmem_read(diagonalScaleMaxAds, &diagonalScaleMaxA);
    printf("diagonalScaleMaxAds: %f", diagonalScaleMaxA);
}
main {
    //Apply right stick settings
    static fix32 prevRX, prevRY;      //Magic CPU reduction variables by ME.
    fix32 currRX = get_val(STICK_1_X);
    fix32 currRY = get_val(STICK_1_Y);
 
    if(prevRX != currRX || prevRY != currRY){
        if(get_val(BUTTON_8) > 0.00){
            applyStick(deadzoneA, antiCircularDeadzoneA, antiEllipseYScaleA, antiSquareDeadzoneA, antiRectangleYScaleA, outerDeadzoneInA, outerDeadzoneOutA,  degreeA, axialRestrictA, angularRestrictA, angularAntiA, diagonalScaleMinA, diagonalScaleMaxA, uncapValuesA,  1);
        }
        else if(get_val(useAlternate2) > 0.00){
            applyStick(deadzoneA2, antiCircularDeadzoneA2, antiEllipseYScaleA2, antiSquareDeadzoneA2, antiRectangleYScaleA2, outerDeadzoneInA2, outerDeadzoneOutA2,  degreeA2, axialRestrictA2, angularRestrictA2, angularAntiA2, diagonalScaleMinA2, diagonalScaleMaxA2, uncapValuesA2,  1);
 
        }
        else{
            applyStick(deadzone, antiCircularDeadzone, antiEllipseYScale, antiSquareDeadzone, antiRectangleYScale, outerDeadzoneIn, outerDeadzoneOut,  degree, axialRestrict, angularRestrict, angularAnti, diagonalScaleMin, diagonalScaleMax, uncapValues,  1);
        }
 
        prevRX = currRX;
        prevRY = currRY;
    }
    set_val(STICK_1_X, stickRX);
    set_val(STICK_1_Y, stickRY);
}
void applyStick(fix32 dead, fix32 antiCDead, fix32 antiEScale, fix32 antiSDead, fix32 antiRScale, fix32 outerDeadIn, fix32 outerDeadOut, fix32 deg, fix32 axisRestrict, fix32 angleRestrict, fix32 angular, fix32 dScaleMin, fix32 dScaleMax, bool uncap, int8 stick){
 
    fix32 x;
    fix32 y;
    if(stick == 1){
    x               = get_val(STICK_1_X)/100.0;
    y               = get_val(STICK_1_Y)/100.0;
    }
 
    fix32 rAngle = rad2deg(abs(atan(y/x)));
    if(abs(x) < 0.0001){rAngle = 90.0;}
 
    //Setting up axial angle deadzone values
    fix32 axialX, axialY;
    if(abs(x) <= axisRestrict && rAngle > 45.0){axialX = 0.0;}
    else{ axialX = (abs(x) - axisRestrict)/(1.0 - axisRestrict); }
 
    if(abs(y) <= axisRestrict && rAngle <= 45.0){axialY = 0.0;}
    else{ axialY = (abs(y) - axisRestrict)/(1.0 - axisRestrict); }
 
    fix32 inputMagnitude  = sqrt(x*x + y*y);
    fix32 outputMagnitude;
    fix32 angle           = rad2deg(abs(atan(axialY/axialX)));
    if(abs(axialX) < 0.0001){angle = 90.0;}               //avoids angle change with Atan by avoiding dividing by 0
 
    //Checks if rectangular deadone is used.
    if(antiRScale == 0.00){ antiRScale = antiSDead; }
 
    //Ellipse warping
    if(antiEScale > 0.00 && antiCDead > 0.00){
    antiEScale = antiEScale/antiCDead;                         
    fix32 ellipseAngle = atan((1.0/antiEScale)*tan(deg2rad(rAngle)))//Find scaled ellipse angle
    if(ellipseAngle < 0.0){ellipseAngle = 1.570796;}                   //Capping range to avoid negative rollover
    fix32 ellipseX = cos(ellipseAngle);                                //use cos to find horizontal alligned value
    fix32 ellipseY = sqrt( sq(antiEScale)*(1.0 - sq(ellipseX)) );      //use ellipse to find vertical value
    antiCDead = antiCDead*sqrt( sq(ellipseX) + sq(ellipseY));          //Find magnitude to scale antiCircleDeadzone
    }
 
    //Resizes circular antideadzone to output expected value(counters shrinkage when scaling for the square antideadzone below).
    antiCDead =   antiCDead/( (antiCDead*(1.0 - antiSDead/outerDeadOut) )/( antiCDead*(1.0 - antiSDead) ) );
 
    //Angular Restriction
    if(abs(x) > axisRestrict && abs(y) > axisRestrict){
    if((angle > 0.0) && (angle < angleRestrict/2.0)){angle = 0.00;}
    if(angle > 90.0 - angleRestrict/2.0 && angle < 90.0){angle = 90.0;}
    if((angle > angleRestrict/2.0) && (angle < (90.0 - angleRestrict/2.0))){
        angle = ((angle - angleRestrict/2.0)*(90.0))/((90.0 - angleRestrict/2.0) - angleRestrict/2.0);
    }
    }
    fix32 refAngle = angle;
    if(refAngle < 0.001){refAngle = 0.0;}
 
    //Diagonal ScalePrep
    fix32 diagonal = angle;
    if(diagonal > 45.0){
    diagonal = (((diagonal - 45.0)*(-45.0))/(45.0)) + 45.0;
    }
 
    //Angular Restriction Countering
    if(angle < 90.0 && angle > 0.0){
    angle = ((angle - 0.0)*((90.0 - (angular/2.0)) - (angular/2.0)))/(90.0) + (angular/2.0);
    }
 
    //Flipping angles back to correct quadrant
    if(axialX < 0.0 && axialY > 0.0){angle = -angle;}
    if(axialX > 0.0 && axialY < 0.0){angle = angle - 180.0;}
    if(axialX < 0.0 && axialY < 0.0){angle = angle + 180.0;}
 
    //~~~~~~~~~~Deadzone wrap~~~~~~~~~~~~~~~~~~//
    if(inputMagnitude > dead){
    outputMagnitude = (inputMagnitude - dead)/(outerDeadIn - dead);
 
    //Circular antideadzone scaling
    outputMagnitude = ((pow(outputMagnitude, (1.0/deg))*(outerDeadOut - antiCDead) + antiCDead));   
 
    //Capping max range
    if(outputMagnitude > outerDeadOut && !uncap){
        outputMagnitude = outerDeadOut;
    }   
 
    //Diagonal Scale
    fix32 dScale = (((outputMagnitude - antiCDead)*(dScaleMax - dScaleMin))/(outerDeadOut - antiCDead)) + dScaleMin;   
    fix32 cScale = (((diagonal - 0.0)*(1.0/sqrt(2.0)))/(45.0));            //Both these lines scale the intensity of the warping
    cScale       = 1.0 - sqrt(1.0 - cScale*cScale);                        //based on a circular curve to the perfect diagonal
    dScale       = (((cScale - 0.0)*(dScale - 1.0))/(.29289)) + 1.0;
 
    outputMagnitude = outputMagnitude*dScale;
 
    //Scaling values for square antideadzone
    fix32 newX = cos(deg2rad(angle))*outputMagnitude;
    fix32 newY = sin(deg2rad(angle))*outputMagnitude;
 
    //Magic angle wobble fix by user ME.
    if (angle > 45.0 && angle < 225.0) {
        newX = inv(sin(deg2rad(angle - 90.0)))*outputMagnitude;
        newY = inv(cos(deg2rad(angle - 270.0)))*outputMagnitude;
    }
 
    //Square antideadzone scaling
    fix32 outputX = abs(newX)*(1.0 - antiSDead/outerDeadOut) + antiSDead;
    if(x < 0.0){outputX = outputX*(-1.0);}
    if(refAngle == 90.0){outputX = 0.0;}
 
    fix32 outputY = abs(newY)*(1.0 - antiRScale/outerDeadOut) + antiRScale;
    if(y < -0.0){outputY = outputY*(-1.0);}
    if(refAngle == 0.0){outputY = 0.0;}
 
    //Output
    if(stick == 1){
        stickRX = clamp(outputX*100.0, -outerDeadOut*100.0, outerDeadOut*100.0);
        stickRY = clamp(outputY*100.0, -outerDeadOut*100.0, outerDeadOut*100.0);
        }
    }
 
    else{
        if(stick == 1){
            stickRX = 0.0;
            stickRY = 0.0;
        }
        else{
    }
 
}
}
#endif


Input TranslaterCircle Deadzone

[list=]
Circle Deadzone.git
Circle Deadzone
(205 Bytes) Downloaded 79 times
example-file.git
example-file
(205 Bytes) Downloaded 70 times
[/list]
User avatar
teddy18
Lieutenant
Lieutenant
 
Posts: 346
Joined: Sun Jul 19, 2015 4:18 pm


Return to User's Script Documentation

Who is online

Users browsing this forum: No registered users and 111 guests