Struct Ds4Report 

#[repr(C)]
pub struct Ds4Report {
    pub thumb_lx: u8,
    pub thumb_ly: u8,
    pub thumb_rx: u8,
    pub thumb_ry: u8,
    pub buttons: u16,
    pub special: u8,
    pub trigger_l: u8,
    pub trigger_r: u8,
}

Represents the standard input state of a virtual DualShock 4 controller.

An instance of this struct is sent to the bus via TargetHandle::update to update the controller’s state.

Examples

use vigem_rust::controller::ds4::{Ds4Report, Ds4Button, Ds4Dpad};

let mut report = Ds4Report::default();

// Set analog stick positions (128 is center)
report.thumb_lx = 200; // Move right
report.thumb_ly = 50;  // Move up

// Press the Cross button
report.buttons = Ds4Button::CROSS.bits();

// Set the D-Pad to South
report.set_dpad(Ds4Dpad::South);

// Pull the right trigger
report.trigger_r = 255;

Fields

thumb_lx: u8

Left thumbstick X-axis (0-255). 128 is center.

thumb_ly: u8

Left thumbstick Y-axis (0-255). 128 is center.

thumb_rx: u8

Right thumbstick X-axis (0-255). 128 is center.

thumb_ry: u8

Right thumbstick Y-axis (0-255). 128 is center.

buttons: u16

A bitmask of the main digital buttons and D-Pad state. See Ds4Button and set_dpad.

special: u8

A bitmask of the special buttons. See Ds4SpecialButton.

trigger_l: u8

Left trigger value (0-255).

trigger_r: u8

Right trigger value (0-255).

Implementations

impl Ds4Report

pub fn set_dpad(&mut self, dpad: Ds4Dpad)

Sets the D-Pad state on the report.

This helper correctly manipulates the lower 4 bits of the buttons field to set the D-Pad state, leaving the other button flags untouched.

Examples

use vigem_rust::controller::ds4::{Ds4Report, Ds4Button, Ds4Dpad};

let mut report = Ds4Report::default();
report.buttons = Ds4Button::SQUARE.bits();
report.set_dpad(Ds4Dpad::East);

// The Square button is still set
assert!(report.buttons & Ds4Button::SQUARE.bits() != 0);
// The D-Pad bits are correctly set
assert_eq!(report.buttons & 0x000F, Ds4Dpad::East as u16);

Examples found in repository

examples/ds4.rs (line 42)

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");

    // Set up a notification listener in a separate thread
    // This allows us to react to feedback from the system, like rumble or LED changes.
    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
            );
        }
    });

    // Here, we'll send reports to the controller to simulate input.

    let mut report = Ds4Report::default();

    // Hold the right D-pad button
    report.set_dpad(Ds4Dpad::East);
    // Hold the Cross button
    report.buttons |= Ds4Button::CROSS.bits();
    // Fully press the right trigger
    report.trigger_r = 255;

    let mut angle: f64 = 0.0;

    loop {
        // Animate the right thumbstick in a circle
        let (sin, cos) = angle.sin_cos();

        // DS4 thumbsticks are 0-255, with 128 as the center.
        report.thumb_rx = (128.0 + sin * 127.0) as u8;
        report.thumb_ry = (128.0 + cos * 127.0) as u8;

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

        thread::sleep(Duration::from_millis(16));
        angle += 0.05;
    }
}

Trait Implementations

impl Clone for Ds4Report

fn clone(&self) -> Ds4Report

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Ds4Report

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

Formats the value using the given formatter.

impl Default for Ds4Report

fn default() -> Self

Returns the “default value” for a type.

impl Copy for Ds4Report