Struct Ds4Touch 

#[repr(C, packed(1))]
pub struct Ds4Touch {
    pub packet_counter: u8,
    pub is_up_tracking_num_1: u8,
    pub touch_data_1: [u8; 3],
    pub is_up_tracking_num_2: u8,
    pub touch_data_2: [u8; 3],
}

Represents a single packet of touchpad data for a DualShock 4 controller.

The DS4 can track up to two simultaneous touch points. This struct contains the state for both potential touches, along with a counter to sequence the packets. It is used within the Ds4ReportExData struct.

Fields

packet_counter: u8

A timestamp or packet counter that increments with each new touch data packet, used to sequence events.

is_up_tracking_num_1: u8

Touch state and tracking ID for the first touch point. This is a bit-packed field:

• The most significant bit (MSB, 0x80) indicates the contact state. This is “active-low”, meaning 0 for touch down and 1 for touch up.
• The lower 7 bits (0x7F) are the tracking ID for the finger. This ID is unique for a single press-drag-release gesture and increments for a new press.

touch_data_1: [u8; 3]

The raw X/Y coordinate data for the first touch point, with a resolution of 1920x943.

This is a packed 24-bit value encoding a 12-bit X and 12-bit Y coordinate. The middle byte holds the 4 least significant bits of X and the 4 most significant bits of Y.

You can unpack the coordinates like this:

let x = (self.touch_data_1[0] as u16) | (((self.touch_data_1[1] & 0x0F) as u16) << 8);
let y = (((self.touch_data_1[1] & 0xF0) as u16) >> 4) | ((self.touch_data_1[2] as u16) << 4);

is_up_tracking_num_2: u8

Touch state and tracking ID for the second touch point. Formatted identically to is_up_tracking_num_1.

touch_data_2: [u8; 3]

The raw X/Y coordinate data for the second touch point. Formatted identically to touch_data_1.

Implementations

impl Ds4Touch

pub fn set_touch_1(&mut self, is_down: bool, tracking_num: u8, x: u16, y: u16)

Sets the state for the first touch contact, abstracting away the bit-packing.

Arguments

• is_down - true if the finger is touching the pad, false otherwise.
• tracking_num - A unique ID for the finger gesture (0-127).
• x - The X coordinate (0-1919).
• y - The Y coordinate (0-942).

Examples found in repository

examples/ds4_ex.rs (line 63)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Connect to the ViGEm bus
    // This can fail if the ViGEm bus driver is not installed.
    let client = Client::connect()?;
    println!("Connected to ViGEm bus");

    // Create and plugin the virtual controller
    let ds4 = client.new_ds4_target().plugin()?;
    println!("Plugged in virtual DualShock 4 controller");

    // Wait for the controller to be ready
    ds4.wait_for_ready()?;
    println!("Controller is ready. You can test it at https://hardwaretester.com/gamepad");

    let notifications = ds4.register_notification()?;
    thread::spawn(move || {
        println!("Notification Thread Started. Waiting for feedback from the host...");
        while let Ok(Ok(notification)) = notifications.recv() {
            println!("Notification Thread Received feedback:");
            println!(
                "  - Rumble: Large Motor = {}, Small Motor = {}",
                notification.large_motor, notification.small_motor
            );
            println!(
                "  - Lightbar Color: R={}, G={}, B={}",
                notification.lightbar.red, notification.lightbar.green, notification.lightbar.blue
            );
        }
    });

    // Main input loop for extended reports
    let mut report_ex = Ds4ReportEx::default();

    // Variables to animate the touch point
    let mut packet_counter: u8 = 0;
    let mut touch_x: i32 = 0;
    let mut direction: i32 = 12;

    loop {
        // Move the touch point back and forth horizontally.
        if touch_x <= 0 {
            direction = 12;
        }
        if touch_x >= 1919 {
            direction = -12;
        }
        touch_x += direction;

        report_ex.touch_packets_n = 1;

        // Get a mut reference to the touch data struct inside the report.
        let touch = &mut report_ex.current_touch;

        // This counter should increment for each new packet of touch data (not sure if necessary for functionality).
        touch.packet_counter = packet_counter;
        packet_counter = packet_counter.wrapping_add(1);

        touch.set_touch_1(true, 1, touch_x as u16, 471); // Finger 1 is down, centered vertically.
        touch.set_touch_2(false, 0, 0, 0); // Finger 2 is up (inactive).

        // Send the updated report to the controller
        ds4.update_ex(&report_ex)?;

        thread::sleep(Duration::from_millis(16));
    }
}

pub fn set_touch_2(&mut self, is_down: bool, tracking_num: u8, x: u16, y: u16)

Sets the state for the second touch contact, abstracting away the bit-packing.

Arguments

• is_down - true if the finger is touching the pad, false otherwise.
• tracking_num - A unique ID for the finger gesture (0-127).
• x - The X coordinate (0-1919).
• y - The Y coordinate (0-942).

Examples found in repository

examples/ds4_ex.rs (line 64)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Connect to the ViGEm bus
    // This can fail if the ViGEm bus driver is not installed.
    let client = Client::connect()?;
    println!("Connected to ViGEm bus");

    // Create and plugin the virtual controller
    let ds4 = client.new_ds4_target().plugin()?;
    println!("Plugged in virtual DualShock 4 controller");

    // Wait for the controller to be ready
    ds4.wait_for_ready()?;
    println!("Controller is ready. You can test it at https://hardwaretester.com/gamepad");

    let notifications = ds4.register_notification()?;
    thread::spawn(move || {
        println!("Notification Thread Started. Waiting for feedback from the host...");
        while let Ok(Ok(notification)) = notifications.recv() {
            println!("Notification Thread Received feedback:");
            println!(
                "  - Rumble: Large Motor = {}, Small Motor = {}",
                notification.large_motor, notification.small_motor
            );
            println!(
                "  - Lightbar Color: R={}, G={}, B={}",
                notification.lightbar.red, notification.lightbar.green, notification.lightbar.blue
            );
        }
    });

    // Main input loop for extended reports
    let mut report_ex = Ds4ReportEx::default();

    // Variables to animate the touch point
    let mut packet_counter: u8 = 0;
    let mut touch_x: i32 = 0;
    let mut direction: i32 = 12;

    loop {
        // Move the touch point back and forth horizontally.
        if touch_x <= 0 {
            direction = 12;
        }
        if touch_x >= 1919 {
            direction = -12;
        }
        touch_x += direction;

        report_ex.touch_packets_n = 1;

        // Get a mut reference to the touch data struct inside the report.
        let touch = &mut report_ex.current_touch;

        // This counter should increment for each new packet of touch data (not sure if necessary for functionality).
        touch.packet_counter = packet_counter;
        packet_counter = packet_counter.wrapping_add(1);

        touch.set_touch_1(true, 1, touch_x as u16, 471); // Finger 1 is down, centered vertically.
        touch.set_touch_2(false, 0, 0, 0); // Finger 2 is up (inactive).

        // Send the updated report to the controller
        ds4.update_ex(&report_ex)?;

        thread::sleep(Duration::from_millis(16));
    }
}

pub fn get_packet_counter(&self) -> u8

Returns the packet counter/timestamp for this touch event.

pub fn get_is_down_1(&self) -> bool

Returns true if the first touch point is active (finger is down).

pub fn get_tracking_num_1(&self) -> u8

Returns the tracking ID for the first touch point (0-127).

pub fn get_coords_1(&self) -> (u16, u16)

Returns the (X, Y) coordinates for the first touch point. X is in the range 0-1919, Y is in the range 0-942.

pub fn get_is_down_2(&self) -> bool

Returns true if the second touch point is active (finger is down).

pub fn get_tracking_num_2(&self) -> u8

Returns the tracking ID for the second touch point (0-127).

pub fn get_coords_2(&self) -> (u16, u16)

Returns the (X, Y) coordinates for the second touch point. X is in the range 0-1919, Y is in the range 0-942.

Trait Implementations

impl Clone for Ds4Touch

fn clone(&self) -> Ds4Touch

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Ds4Touch

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Ds4Touch

fn default() -> Ds4Touch

Returns the “default value” for a type.

impl Copy for Ds4Touch