#include <libpad.h>

Include dependency graph for input.h:

This graph shows which files directly or indirectly include this file:

Data Structures
struct	actuator_t

struct	pad_t

Macros
#define	MODE_DIGITAL 0

#define	MODE_ANALOG 1

#define	MODE_UNLOCKED 0

#define	MODE_LOCKED 1

#define	PAD_LEFT 0x0080

#define	PAD_DOWN 0x0040

#define	PAD_RIGHT 0x0020

#define	PAD_UP 0x0010

#define	PAD_START 0x0008

#define	PAD_R3 0x0004

#define	PAD_L3 0x0002

#define	PAD_SELECT 0x0001

#define	PAD_SQUARE 0x8000

#define	PAD_CROSS 0x4000

#define	PAD_CIRCLE 0x2000

#define	PAD_TRIANGLE 0x1000

#define	PAD_R1 0x0800

#define	PAD_L1 0x0400

#define	PAD_R2 0x0200

#define	PAD_L2 0x0100

Functions
pad_t *	pad_open (unsigned int port, unsigned int slot, unsigned int mode, unsigned int lock)

static void	pad_get_buttons (pad_t *pad)

void	pad_close (pad_t *pad)

void	pad_wait (pad_t *pad)

void	pad_set_mode (pad_t *pad, int mode, int lock)

void	pad_set_sensitivity (pad_t *pad, int enable)

void	pad_init_actuators (pad_t *pad)

void	pad_set_actuators (pad_t *pad, int small, unsigned char large)

int	pad_get_state (pad_t *pad)

int	pad_get_num_modes (pad_t *pad)

int	pad_has_type (pad_t *pad, int type)

int	pad_get_type (pad_t *pad)

int	pad_get_mode (pad_t *pad)

Detailed Description

Input library

Definition in file input.h.

Macro Definition Documentation

◆ MODE_ANALOG

#define MODE_ANALOG 1

Definition at line 12 of file input.h.

◆ MODE_DIGITAL

#define MODE_DIGITAL 0

Definition at line 11 of file input.h.

◆ MODE_LOCKED

#define MODE_LOCKED 1

Definition at line 15 of file input.h.

◆ MODE_UNLOCKED

#define MODE_UNLOCKED 0

Definition at line 14 of file input.h.

◆ PAD_CIRCLE

#define PAD_CIRCLE 0x2000

Definition at line 27 of file input.h.

◆ PAD_CROSS

#define PAD_CROSS 0x4000

Definition at line 26 of file input.h.

◆ PAD_DOWN

#define PAD_DOWN 0x0040

Definition at line 18 of file input.h.

◆ PAD_L1

#define PAD_L1 0x0400

Definition at line 30 of file input.h.

◆ PAD_L2

#define PAD_L2 0x0100

Definition at line 32 of file input.h.

◆ PAD_L3

#define PAD_L3 0x0002

Definition at line 23 of file input.h.

◆ PAD_LEFT

#define PAD_LEFT 0x0080

Definition at line 17 of file input.h.

◆ PAD_R1

#define PAD_R1 0x0800

Definition at line 29 of file input.h.

◆ PAD_R2

#define PAD_R2 0x0200

Definition at line 31 of file input.h.

◆ PAD_R3

#define PAD_R3 0x0004

Definition at line 22 of file input.h.

◆ PAD_RIGHT

#define PAD_RIGHT 0x0020

Definition at line 19 of file input.h.

◆ PAD_SELECT

#define PAD_SELECT 0x0001

Definition at line 24 of file input.h.

◆ PAD_SQUARE

#define PAD_SQUARE 0x8000

Definition at line 25 of file input.h.

◆ PAD_START

#define PAD_START 0x0008

Definition at line 21 of file input.h.

◆ PAD_TRIANGLE

#define PAD_TRIANGLE 0x1000

Definition at line 28 of file input.h.

◆ PAD_UP

#define PAD_UP 0x0010

Definition at line 20 of file input.h.

Function Documentation

◆ pad_close()

void pad_close ( pad_t * pad )

Close the pad

Definition at line 82 of file input.c.

 {
  
         if (pad == NULL)
         {
                 return;
         }
  
         if (pad->actuator != NULL)
         {
                 free(pad->actuator);
         }
  
         padPortClose(pad->port,pad->slot);
  
         free(pad->buttons);
         free(pad->buffer);
         free(pad);
  
 }

References pad_t::actuator, pad_t::buffer, pad_t::buttons, NULL, padPortClose(), pad_t::port, and pad_t::slot.

◆ pad_get_buttons()

static void pad_get_buttons ( pad_t * pad )

inlinestatic

Get the pad's current button status

Definition at line 70 of file input.h.

 {
         padRead(pad->port,pad->slot,pad->buttons);
 }

References pad_t::buttons, padRead(), pad_t::port, and pad_t::slot.

◆ pad_get_mode()

int pad_get_mode ( pad_t * pad )

Get the pad's current mode

◆ pad_get_num_modes()

int pad_get_num_modes ( pad_t * pad )

Get number of modes supported by pad

Definition at line 145 of file input.c.

 {
  
         pad->num_modes = padInfoMode(pad->port,pad->slot,PAD_MODETABLE,-1);
  
         return pad->num_modes;
  
 }

References pad_t::num_modes, PAD_MODETABLE, padInfoMode(), pad_t::port, and pad_t::slot.

Referenced by pad_has_type().

◆ pad_get_state()

int pad_get_state ( pad_t * pad )

Get the pad's state

Definition at line 103 of file input.c.

 {
  
         pad->state = padGetState(pad->port, pad->slot);
  
         return pad->state;
  
 }

References padGetState(), pad_t::port, pad_t::slot, and pad_t::state.

Referenced by pad_wait().

◆ pad_get_type()

int pad_get_type ( pad_t * pad )

Get the pad's type

Definition at line 206 of file input.c.

 {
  
         pad->type = padInfoMode(pad->port,pad->slot,PAD_MODECURID,0);
  
         return pad->type;
  
 }

References PAD_MODECURID, padInfoMode(), pad_t::port, pad_t::slot, and pad_t::type.

◆ pad_has_type()

int pad_has_type	(	pad_t *	pad,
		int	type
	)

Check if a type is supported by pad

Definition at line 178 of file input.c.

 {
  
         int i = 0;
  
         if (pad->num_modes < 0)
         {
                 pad_get_num_modes(pad);
         }
  
         if ((pad->num_modes == 0) && (type == PAD_TYPE_DIGITAL))
         {
                 return 1;
         }
  
         for (i = 0; i < pad->num_modes; i++)
         {
                 if (padInfoMode(pad->port,pad->slot,PAD_MODETABLE,i) == type)
                 {
                         return 1;
                 }
  
         }
  
         return 0;
  
 }

References pad_t::num_modes, pad_get_num_modes(), PAD_MODETABLE, PAD_TYPE_DIGITAL, padInfoMode(), pad_t::port, and pad_t::slot.

Referenced by pad_set_mode().

◆ pad_init_actuators()

void pad_init_actuators ( pad_t * pad )

Init actuators

Definition at line 288 of file input.c.

 {
  
         if (pad->actuator == NULL)
         {
 #ifdef _XINPUT
                 if (padInfoAct(pad->port, pad->slot, -1, 0))
 #else
                 if (padInfoMode(pad->port,pad->slot,PAD_MODECUREXID,0))
 #endif
                 {
                         pad_wait(pad);
                         pad->actuator = (actuator_t*)malloc(sizeof(actuator_t));
                 }
                 else
                 {
                         pad_wait(pad);
                         return;
                 }
         }
  
         pad->actuator->small = 0;
         pad->actuator->large = 0x00;
  
         pad->actuator->status[0] = 0;
         pad->actuator->status[1] = 1;
         pad->actuator->status[2] = 0xFF;
         pad->actuator->status[3] = 0xFF;
         pad->actuator->status[4] = 0xFF;
         pad->actuator->status[5] = 0xFF;
  
  
         pad_wait(pad);
         padSetActAlign(pad->port,pad->slot,pad->actuator->status);
         pad_wait(pad);
  
 }

References pad_t::actuator, actuator_t::large, NULL, PAD_MODECUREXID, pad_wait(), padInfoAct(), padInfoMode(), padSetActAlign(), pad_t::port, pad_t::slot, actuator_t::small, and actuator_t::status.

◆ pad_open()

pad_t* pad_open	(	unsigned int	port,
		unsigned int	slot,
		unsigned int	mode,
		unsigned int	lock
	)

Open and initialize a pad

Definition at line 10 of file input.c.

 {
  
         pad_t *pad = (pad_t*)malloc(sizeof(pad_t));
  
         pad->buffer = (char*)memalign(64,256);
         pad->buttons = (struct padButtonStatus*)malloc(sizeof(struct padButtonStatus));
         pad->actuator = NULL;
  
         // there are only two ports
         if (port > 1)
         {
                 free(pad->buttons);
                 free(pad);
                 return NULL;
         }
  
 #ifdef _XINPUT
         if (mtapGetConnection(pad->port))
         {
                 // there are only four slots
                 if (slot > 3)
                 {
                         free(pad->buttons);
                         free(pad);
                         return NULL;
                 }
         }
         else
         {
 #endif
         // there's only one slot
         if (slot)
         {
                 free(pad->buttons);
                 free(pad);
                 return NULL;
         }
 #ifdef _XINPUT
         }
 #endif
  
         pad->port = port;
 #ifdef _XINPUT
         pad->slot = slot;
 #else
         pad->slot = 0;
 #endif
  
         // Placeholders
         pad->type = PAD_TYPE_DIGITAL;
  
         pad->state = 0;
         pad->last_state = -1;
         pad->exec_cmd = 0;
         pad->num_modes = -1;
         pad->sensitivity = 0;
  
         // These get verified by pad_set_mode()
         pad->mode = mode;
         pad->lock = lock;
  
         padPortOpen(pad->port,pad->slot,pad->buffer);
  
         pad_wait(pad);
  
         pad_set_mode(pad,pad->mode,pad->lock);
  
         return pad;
  
 }

References pad_t::actuator, pad_t::buffer, pad_t::buttons, pad_t::exec_cmd, pad_t::last_state, pad_t::lock, lock, pad_t::mode, mode, mtapGetConnection(), NULL, pad_t::num_modes, pad_set_mode(), PAD_TYPE_DIGITAL, pad_wait(), padPortOpen(), pad_t::port, port, pad_t::sensitivity, pad_t::slot, slot, pad_t::state, and pad_t::type.

◆ pad_set_actuators()

void pad_set_actuators	(	pad_t *	pad,
		int	small,
		unsigned char	large
	)

Set actuators

Definition at line 326 of file input.c.

 {
  
         if (!small)
         {
                 pad->actuator->small = small;
         }
         else
         {
                 pad->actuator->small = 0x01;
         }
  
         pad->actuator->large = large;
  
         pad->actuator->status[0] = pad->actuator->small;
         pad->actuator->status[1] = pad->actuator->large;
  
         padSetActDirect(pad->port,pad->slot,pad->actuator->status);
  
 }

References pad_t::actuator, actuator_t::large, padSetActDirect(), pad_t::port, pad_t::slot, actuator_t::small, and actuator_t::status.

◆ pad_set_mode()

void pad_set_mode	(	pad_t *	pad,
		int	mode,
		int	lock
	)

Set the pad's mode and mode lock

Definition at line 215 of file input.c.

 {
  
         int status = 0;
  
         if (lock == PAD_MMODE_LOCK)
         {
                 pad->lock = lock;
         }
         else
         {
                 pad->lock = PAD_MMODE_UNLOCK;
         }
  
         if ((mode == PAD_MMODE_DUALSHOCK) || (mode == PAD_TYPE_DUALSHOCK))
         {
                 if (pad_has_type(pad,PAD_TYPE_DUALSHOCK))
                 {
                         status = padSetMainMode(pad->port,pad->slot,pad->mode,pad->lock);
                 }
  
                 if (status)
                 {
                         pad->mode = PAD_MMODE_DUALSHOCK;
                 }
         }
         else
         {
                 if (pad_has_type(pad,PAD_TYPE_DIGITAL))
                 {
                         status = padSetMainMode(pad->port,pad->slot,pad->mode,pad->lock);
                 }
  
                 if (status)
                 {
                         pad->mode = PAD_MMODE_DIGITAL;
                 }
         }
  
         if (status)
         {
                 pad_wait(pad);
         }
  
 }

References pad_t::lock, lock, pad_t::mode, mode, pad_has_type(), PAD_MMODE_DIGITAL, PAD_MMODE_DUALSHOCK, PAD_MMODE_LOCK, PAD_MMODE_UNLOCK, PAD_TYPE_DIGITAL, PAD_TYPE_DUALSHOCK, pad_wait(), padSetMainMode(), pad_t::port, and pad_t::slot.

Referenced by pad_open().

◆ pad_set_sensitivity()

void pad_set_sensitivity	(	pad_t *	pad,
		int	enable
	)

Set the pad's pressure sensitivity

Definition at line 261 of file input.c.

 {
  
         if(padInfoPressMode(pad->port,pad->slot))
         {
                 pad_wait(pad);
                 pad->sensitivity = 1;
         }
         else
         {
                 pad_wait(pad);
                 pad->sensitivity = 0;
                 return;
         }
  
         if (enable)
         {
                 padEnterPressMode(pad->port,pad->slot);
         }
         else
         {
                 padExitPressMode(pad->port,pad->slot);
         }
  
  
 }

References pad_wait(), padEnterPressMode(), padExitPressMode(), padInfoPressMode(), pad_t::port, pad_t::sensitivity, and pad_t::slot.

◆ pad_wait()

void pad_wait ( pad_t * pad )

Wait until the pad is ready to accept commands

Definition at line 122 of file input.c.

 {
  
         pad_get_state(pad);
  
         if (pad->state != pad->last_state)
         {
 #ifdef DEBUG
                 pad_print_state(pad);
 #endif
                 pad->last_state = pad->state;
  
         }
  
         if (pad->state == PAD_STATE_STABLE) return;
         if (pad->state == PAD_STATE_ERROR) return;
         if (pad->state == PAD_STATE_DISCONN) return;
         if (pad->state == PAD_STATE_FINDCTP1) return;
  
         return pad_wait(pad);
  
 }

References pad_t::last_state, pad_get_state(), PAD_STATE_DISCONN, PAD_STATE_ERROR, PAD_STATE_FINDCTP1, PAD_STATE_STABLE, pad_wait(), and pad_t::state.

Referenced by pad_init_actuators(), pad_open(), pad_set_mode(), pad_set_sensitivity(), and pad_wait().

Data Structures

Macros

Functions