Struct SDL_HapticDirection 

#[repr(C)]
pub struct SDL_HapticDirection {
    pub type: SDL_HapticDirectionType,
    pub dir: [Sint32; 3],
}

Structure that represents a haptic direction.

This is the direction where the force comes from, instead of the direction in which the force is exerted.

Directions can be specified by:

• SDL_HAPTIC_POLAR : Specified by polar coordinates.
• SDL_HAPTIC_CARTESIAN : Specified by cartesian coordinates.
• SDL_HAPTIC_SPHERICAL : Specified by spherical coordinates.

Cardinal directions of the haptic device are relative to the positioning of the device. North is considered to be away from the user.

The following diagram represents the cardinal directions:

               .--.
               |__| .-------.
               |=.| |.-----.|
               |--| ||     ||
               |  | |'-----'|
               |__|~')_____('
                 [ COMPUTER ]


                   North (0,-1)
                       ^
                       |
                       |
 (-1,0)  West <----[ HAPTIC ]----> East (1,0)
                       |
                       |
                       v
                    South (0,1)


                    [ USER ]
                      \|||/
                      (o o)
                ---ooO-(_)-Ooo---

If type is SDL_HAPTIC_POLAR, direction is encoded by hundredths of a degree starting north and turning clockwise. SDL_HAPTIC_POLAR only uses the first dir parameter. The cardinal directions would be:

• North: 0 (0 degrees)
• East: 9000 (90 degrees)
• South: 18000 (180 degrees)
• West: 27000 (270 degrees)

If type is SDL_HAPTIC_CARTESIAN, direction is encoded by three positions (X axis, Y axis and Z axis (with 3 axes)). SDL_HAPTIC_CARTESIAN uses the first three dir parameters. The cardinal directions would be:

• North: 0,-1, 0
• East: 1, 0, 0
• South: 0, 1, 0
• West: -1, 0, 0

The Z axis represents the height of the effect if supported, otherwise it’s unused. In cartesian encoding (1, 2) would be the same as (2, 4), you can use any multiple you want, only the direction matters.

If type is SDL_HAPTIC_SPHERICAL, direction is encoded by two rotations. The first two dir parameters are used. The dir parameters are as follows (all values are in hundredths of degrees):

• Degrees from (1, 0) rotated towards (0, 1).
• Degrees towards (0, 0, 1) (device needs at least 3 axes).

Example of force coming from the south with all encodings (force coming from the south means the user will have to pull the stick to counteract):

 SDL_HapticDirection direction;

 // Cartesian directions
 direction.type = SDL_HAPTIC_CARTESIAN; // Using cartesian direction encoding.
 direction.dir[0] = 0; // X position
 direction.dir[1] = 1; // Y position
 // Assuming the device has 2 axes, we don't need to specify third parameter.

 // Polar directions
 direction.type = SDL_HAPTIC_POLAR; // We'll be using polar direction encoding.
 direction.dir[0] = 18000; // Polar only uses first parameter

 // Spherical coordinates
 direction.type = SDL_HAPTIC_SPHERICAL; // Spherical encoding
 direction.dir[0] = 9000; // Since we only have two axes we don't need more parameters.

Availability

This struct is available since SDL 3.2.0.

See also

• SDL_HAPTIC_POLAR
• SDL_HAPTIC_CARTESIAN
• SDL_HAPTIC_SPHERICAL
• SDL_HAPTIC_STEERING_AXIS
• SDL_HapticEffect
• SDL_GetNumHapticAxes

Fields

type: SDL_HapticDirectionType

The type of encoding.

dir: [Sint32; 3]

The encoded direction.

Trait Implementations

impl Clone for SDL_HapticDirection

fn clone(&self) -> SDL_HapticDirection

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SDL_HapticDirection

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

Formats the value using the given formatter.

impl Default for SDL_HapticDirection

fn default() -> SDL_HapticDirection

Returns the “default value” for a type.

impl Hash for SDL_HapticDirection

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for SDL_HapticDirection

fn eq(&self, other: &SDL_HapticDirection) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for SDL_HapticDirection

impl Eq for SDL_HapticDirection

impl StructuralPartialEq for SDL_HapticDirection