misc.wiiremote/trunk/wiimote_state.h

// _______________________________________________________________________________
//
//   - WiiYourself! - native C++ Wiimote library  v1.15
//    (c) gl.tter 2007-10 - http://gl.tter.org
//
//    see License.txt for conditions of use.  see History.txt for change log.
// _______________________________________________________________________________
//
//  wiimote_state.h  (tab = 4 spaces)

// the 'wiimote_state' struct contains all the Wiimote and Extension state data
//  (buttons etc) - the wiimote class inherits from this and the app can poll
//  the data there at any time.
#ifdef _MSC_VER // VC
# pragma once
#endif

#ifndef _WIIMOTE_STATE_H
# define _WIIMOTE_STATE_H

#include "wiimote_common.h"


// wiimote_state (contains the Wiimote and Extension data and settings)
struct wiimote_state
    {
    friend class wiimote; // for Clear()

    // calibration information (stored on the Wiimote)
    struct calibration_info
        {
        BYTE X0, Y0, Z0;
        BYTE XG, YG, ZG;
        } CalibrationInfo;

    // button state:
    struct buttons
        {
        // convenience accessors
        inline bool A       () const    { return (Bits & _A)    != 0; }
        inline bool B       () const    { return (Bits & _B)    != 0; }
        inline bool Plus    () const    { return (Bits & PLUS)  != 0; }
        inline bool Home    () const    { return (Bits & HOME)  != 0; }
        inline bool Minus   () const    { return (Bits & MINUS) != 0; }
        inline bool One     () const    { return (Bits & ONE)   != 0; }
        inline bool Two     () const    { return (Bits & TWO)   != 0; }
        inline bool Up      () const    { return (Bits & UP)    != 0; }
        inline bool Down    () const    { return (Bits & DOWN)  != 0; }
        inline bool Left    () const    { return (Bits & LEFT)  != 0; }
        inline bool Right   () const    { return (Bits & RIGHT) != 0; }

        // all 11 buttons stored as bits (set = pressed)
        WORD Bits;

        // button bit masks (little-endian order)
        enum mask
            {
            LEFT    = 0x0001,
            RIGHT   = 0x0002,
            DOWN    = 0x0004,
            UP      = 0x0008,
            PLUS    = 0x0010,
            TWO     = 0x0100,
            ONE     = 0x0200,
            _B      = 0x0400,   // ie. trigger
            _A      = 0x0800,
            MINUS   = 0x1000,
            HOME    = 0x8000,
            //
            ALL     = LEFT|RIGHT|DOWN|UP|PLUS|TWO|ONE|_A|_B|MINUS|HOME,
            };
        } Button;

    // accelerometers state:
    struct acceleration
        {
        BYTE  RawX, RawY, RawZ;
        float X, Y, Z;

        // note: experimental! the orientation values can only be safely estimated
        //        if the controller isn't accelerating (otherwise there is no
        //        simple way to seperate orientation from acceleration - except
        //        perhaps using the IR reference and/or some clever assumptions).
        //        so for now the code only updates orientation if the controller
        //        appear to be stationary (by checking if the acceleration vector
        //        length is near 1G for several updates in a row).
        //        also note that there is no way to detect Yaw from the accelerometer
        //        alone when it's pointing at the screen (and I'm not curently
        //        processing IR):
        struct orientation
            {
            float X, Y, Z;
            unsigned UpdateAge; // how many acceleration updates ago the last
                                //  orientation estimate was made (if this
                                //  value is high, the values are out-of-date
                                //  and probably shouldn't be used).
            // Euler angle support (useful for some things).
            // * note that decomposing to Euler angles is complex, not always reliable,
            //    and also depends on your assumptions about the order each component
            //    is applied in.  you may need to handle this yourself for more
            //    complex scenarios *
            float    Pitch; // in degrees (-180 - +180)
            float    Roll;  // "
            // float Yaw;   
            } Orientation;
        } Acceleration;

    // IR camera state:
    struct ir
        {
        // in theory the IR imager is 1024x768 and so should report raw coords
        //  0-1023 x 0-767.  in practice I have never seen them exceed the values
        //  below, so I'm using them instead to give the full 0-1 float range
        //  (it's possible that the edge pixels are used for processing, or masked
        //  out due to being unreliable).  let me know if your wiimote reports
        //  a different range.
        static const unsigned MAX_RAW_X = 1016;
        static const unsigned MAX_RAW_Y =  760;

        // data mode reported by the IR sensor
        enum mode
            {
            OFF         = 0x00,
            BASIC       = 0x01, // 10 bytes
            EXTENDED    = 0x03, // 12 bytes
            FULL        = 0x05, // 16 bytes * 2 (format unknown)
            };
        
        mode    Mode;       // read-only (depends on ReportType set)
        
        struct dot
            {
            bool     bVisible;  // other values are not valid if == false
            unsigned RawX;
            unsigned RawY;
            float    X;         // 0-1 (left-right)
            float    Y;         // "   (top -bottom)
            int      Size;      // (not available in BASIC mode)
            } Dot[4];
        } IR;

    struct leds
        {
        // all LEDs stored in bits 0-3  (1 = lit)
         BYTE Bits;

        // convenience accessors:
        inline bool Lit (unsigned index)
            { _ASSERT(index < 4);
              return (index >= 4)? false : ((Bits & (1<<index)) != 0); }
        } LED;

     BYTE BatteryRaw;       // 0 - ~200 (it seems 200 *may* be the maximum charge)
     BYTE BatteryPercent;   // (using the above assumption, where 200 raw = 100%)
     bool bBatteryDrained;  // battery is nearly flat
     bool bRumble;
     bool bExtension;       // an extension (eg. Nunchuk) is connected.

    // speaker state:
    struct speaker
        {
         bool         bEnabled;
         bool         bMuted;
         speaker_freq Freq;
         BYTE         Volume;
        } Speaker;

    // the extension plugged into the Wiimote (if any)
    enum extension_type
        {
        NONE = 0,
        NUNCHUK,
        CLASSIC,
        GH3_GHWT_GUITAR, // GH3 or GHWT Guitar (treated as Classic)
        GHWT_DRUMS,      // not yet used
        BALANCE_BOARD,
        MOTION_PLUS,
        PARTIALLY_INSERTED,
        };
     extension_type ExtensionType;

    // joystick struct (shared between Nunchuk & Classic Controller)
    struct joystick
        {
        friend class wiimote;
        
        // raw unprocessed coordinates:
        float RawX, RawY;

        // processed coordinates in approximately -1 - +1 range (includes calibration
        //  data and deadzones) - note that due to calibration inaccuracies, the
        //  extremes may be slightly over/under (+-)1.0.
        float X, Y;

        // a 'deadzone' is a user-defined range near the joystick center which
        //  is treated as zero (joysticks often drift a little even at the center
        //  position).  you can set a deadzone for each axis at any time, range is
        //  0.0 (off) to 1.0 (entire range - not useful :). try 0.03.
        struct deadzone
            {
             float X, Y;
            } DeadZone;
        };

    // Nunchuk state (if connected)
    struct nunchuk
        {
        struct calibration_info
            {
             BYTE X0, Y0, Z0;
             BYTE XG, YG, ZG;
             BYTE MinX, MidX, MaxX;
             BYTE MinY, MidY, MaxY;
            } CalibrationInfo;

        acceleration  Acceleration;
        joystick      Joystick;
         bool C;
         bool Z;
        } Nunchuk;

    // Classic Controller state (if connected)
    struct classic_controller
        {
        // calibration information (stored on the controller)
        struct calibration_info
            {
             BYTE MinXL, MidXL, MaxXL;
             BYTE MinYL, MidYL, MaxYL;
             BYTE MinXR, MidXR, MaxXR;
             BYTE MinYR, MidYR, MaxYR;
             BYTE MinTriggerL, MaxTriggerL;
             BYTE MinTriggerR, MaxTriggerR;
            } CalibrationInfo;

        // button state
        struct buttons
            {
            // convenience accessors
            inline  bool A          () const { return (Bits & _A)     != 0; }
            inline  bool B          () const { return (Bits & _B)     != 0; }
            inline  bool Plus       () const { return (Bits & PLUS)   != 0; }
            inline  bool Minus      () const { return (Bits & MINUS)  != 0; }
            inline  bool Home       () const { return (Bits & HOME)   != 0; }
            inline  bool Up         () const { return (Bits & UP)     != 0; }
            inline  bool Down       () const { return (Bits & DOWN)   != 0; }
            inline  bool Left       () const { return (Bits & LEFT)   != 0; }
            inline  bool Right      () const { return (Bits & RIGHT)  != 0; }
            inline  bool X          () const { return (Bits & _X)     != 0; }
            inline  bool Y          () const { return (Bits & _Y)     != 0; }
            inline  bool ZL         () const { return (Bits & _ZL)    != 0; }
            inline  bool ZR         () const { return (Bits & _ZR)    != 0; }
            inline  bool TriggerL   () const { return (Bits & TRIG_L) != 0; }
            inline  bool TriggerR   () const { return (Bits & TRIG_R) != 0; }
            
            // all 15 buttons stored as bits (set = pressed)
             WORD Bits;

            // button bitmasks (little-endian order)
            enum mask
                {
                TRIG_R  = 0x0002,
                PLUS    = 0x0004,
                HOME    = 0x0008,
                MINUS   = 0x0010,
                TRIG_L  = 0x0020,
                DOWN    = 0x0040,
                RIGHT   = 0x0080,
                UP      = 0x0100,
                LEFT    = 0x0200,
                _ZR     = 0x0400,
                _X      = 0x0800,
                _A      = 0x1000,
                _Y      = 0x2000,
                _B      = 0x4000,
                _ZL     = 0x8000,
                //
                ALL     = TRIG_R|PLUS|HOME|MINUS|TRIG_L|DOWN|RIGHT|UP|LEFT|
                          _ZR|_X|_A|_Y|_B|_ZL,
                };
            } Button;

        // joysticks
        joystick JoystickL;
        joystick JoystickR;

        // triggers
        BYTE  RawTriggerL, RawTriggerR;
        float TriggerL, TriggerR;
        } ClassicController;

    struct balance_board
        {
        // values for each of the board's 4 sensors:
        //  (these values are always exposed unmodifed)
        struct sensors_raw
            {
            short    TopR;
            short    TopL;
            short BottomR;
            short BottomL;
            };
        struct sensors_f
            {
            float    TopL;
            float    TopR;
            float BottomL;
            float BottomR;
            
            float Total; // sum of the 4 corner weights
            };

        // calibration info
        struct calibration_info
            {
            sensors_raw Kg0;    // calibration at  0 Kg
            sensors_raw Kg17;   // "              17 Kg
            sensors_raw Kg34;   // "              34 Kg
            } CalibrationInfo;

        // state:
        sensors_raw Raw;      // raw values (per sensor)
        sensors_f   AtRestKg; // set by Connect() and CalibrateAtRest()
        //  (the values below have their 'at-rest' offsets automatically removed)
        sensors_f   Kg;       // kilograms  (per sensor)
        sensors_f   Lb;       // pounds   (per sensor)
        } BalanceBoard;

    struct motion_plus
        {
        //  (these values are always exposed unmodifed)
        struct sensors_raw
            {
            short Yaw;
            short Pitch;
            short Roll;
            };
        struct sensors_f
            {
            float Yaw;
            float Pitch;
            float Roll;
            };

        // state:
        sensors_raw Raw;
        sensors_f   Speed;
        } MotionPlus;

    // ---- internal use only ----
    protected: 
         unsigned WiimoteNearGUpdates;
         unsigned NunchukNearGUpdates;

        void Clear (bool including_deadzones)
            {
            joystick::deadzone nunchuk_deadzone,
                               classic_joyl_deadzone,
                               classic_joyr_deadzone;
        
            // preserve the deadzone settings?
            if(!including_deadzones) {
                nunchuk_deadzone      = Nunchuk.Joystick.DeadZone;
                classic_joyl_deadzone = ClassicController.JoystickL.DeadZone;
                classic_joyr_deadzone = ClassicController.JoystickR.DeadZone;
                }

            memset(this, 0, sizeof(wiimote_state));

            // restore the deadzones?
            if(!including_deadzones) {
                Nunchuk.Joystick.DeadZone            = nunchuk_deadzone;
                ClassicController.JoystickL.DeadZone = classic_joyl_deadzone;
                ClassicController.JoystickR.DeadZone = classic_joyr_deadzone;
                }
            }
    };

#endif // _WIIMOTE_STATE_H
1	// _______________________________________________________________________________
2	//
3	// - WiiYourself! - native C++ Wiimote library v1.15
4	// (c) gl.tter 2007-10 - http://gl.tter.org
5	//
6	// see License.txt for conditions of use. see History.txt for change log.
7	// _______________________________________________________________________________
8	//
9	// wiimote_state.h (tab = 4 spaces)
10
11	// the 'wiimote_state' struct contains all the Wiimote and Extension state data
12	// (buttons etc) - the wiimote class inherits from this and the app can poll
13	// the data there at any time.
14	#ifdef _MSC_VER // VC
15	# pragma once
16	#endif
17
18	#ifndef _WIIMOTE_STATE_H
19	# define _WIIMOTE_STATE_H
20
21	#include "wiimote_common.h"
22
23
24	// wiimote_state (contains the Wiimote and Extension data and settings)
25	struct wiimote_state
26	{
27	friend class wiimote; // for Clear()
28
29	// calibration information (stored on the Wiimote)
30	struct calibration_info
31	{
32	BYTE X0, Y0, Z0;
33	BYTE XG, YG, ZG;
34	} CalibrationInfo;
35
36	// button state:
37	struct buttons
38	{
39	// convenience accessors
40	inline bool A () const { return (Bits & _A) != 0; }
41	inline bool B () const { return (Bits & _B) != 0; }
42	inline bool Plus () const { return (Bits & PLUS) != 0; }
43	inline bool Home () const { return (Bits & HOME) != 0; }
44	inline bool Minus () const { return (Bits & MINUS) != 0; }
45	inline bool One () const { return (Bits & ONE) != 0; }
46	inline bool Two () const { return (Bits & TWO) != 0; }
47	inline bool Up () const { return (Bits & UP) != 0; }
48	inline bool Down () const { return (Bits & DOWN) != 0; }
49	inline bool Left () const { return (Bits & LEFT) != 0; }
50	inline bool Right () const { return (Bits & RIGHT) != 0; }
51
52	// all 11 buttons stored as bits (set = pressed)
53	WORD Bits;
54
55	// button bit masks (little-endian order)
56	enum mask
57	{
58	LEFT = 0x0001,
59	RIGHT = 0x0002,
60	DOWN = 0x0004,
61	UP = 0x0008,
62	PLUS = 0x0010,
63	TWO = 0x0100,
64	ONE = 0x0200,
65	_B = 0x0400, // ie. trigger
66	_A = 0x0800,
67	MINUS = 0x1000,
68	HOME = 0x8000,
69	//
70	ALL = LEFT\|RIGHT\|DOWN\|UP\|PLUS\|TWO\|ONE\|_A\|_B\|MINUS\|HOME,
71	};
72	} Button;
73
74	// accelerometers state:
75	struct acceleration
76	{
77	BYTE RawX, RawY, RawZ;
78	float X, Y, Z;
79
80	// note: experimental! the orientation values can only be safely estimated
81	// if the controller isn't accelerating (otherwise there is no
82	// simple way to seperate orientation from acceleration - except
83	// perhaps using the IR reference and/or some clever assumptions).
84	// so for now the code only updates orientation if the controller
85	// appear to be stationary (by checking if the acceleration vector
86	// length is near 1G for several updates in a row).
87	// also note that there is no way to detect Yaw from the accelerometer
88	// alone when it's pointing at the screen (and I'm not curently
89	// processing IR):
90	struct orientation
91	{
92	float X, Y, Z;
93	unsigned UpdateAge; // how many acceleration updates ago the last
94	// orientation estimate was made (if this
95	// value is high, the values are out-of-date
96	// and probably shouldn't be used).
97	// Euler angle support (useful for some things).
98	// * note that decomposing to Euler angles is complex, not always reliable,
99	// and also depends on your assumptions about the order each component
100	// is applied in. you may need to handle this yourself for more
101	// complex scenarios *
102	float Pitch; // in degrees (-180 - +180)
103	float Roll; // "
104	// float Yaw;
105	} Orientation;
106	} Acceleration;
107
108	// IR camera state:
109	struct ir
110	{
111	// in theory the IR imager is 1024x768 and so should report raw coords
112	// 0-1023 x 0-767. in practice I have never seen them exceed the values
113	// below, so I'm using them instead to give the full 0-1 float range
114	// (it's possible that the edge pixels are used for processing, or masked
115	// out due to being unreliable). let me know if your wiimote reports
116	// a different range.
117	static const unsigned MAX_RAW_X = 1016;
118	static const unsigned MAX_RAW_Y = 760;
119
120	// data mode reported by the IR sensor
121	enum mode
122	{
123	OFF = 0x00,
124	BASIC = 0x01, // 10 bytes
125	EXTENDED = 0x03, // 12 bytes
126	FULL = 0x05, // 16 bytes * 2 (format unknown)
127	};
128
129	mode Mode; // read-only (depends on ReportType set)
130
131	struct dot
132	{
133	bool bVisible; // other values are not valid if == false
134	unsigned RawX;
135	unsigned RawY;
136	float X; // 0-1 (left-right)
137	float Y; // " (top -bottom)
138	int Size; // (not available in BASIC mode)
139	} Dot[4];
140	} IR;
141
142	struct leds
143	{
144	// all LEDs stored in bits 0-3 (1 = lit)
145	BYTE Bits;
146
147	// convenience accessors:
148	inline bool Lit (unsigned index)
149	{ _ASSERT(index < 4);
150	return (index >= 4)? false : ((Bits & (1<<index)) != 0); }
151	} LED;
152
153	BYTE BatteryRaw; // 0 - ~200 (it seems 200 may be the maximum charge)
154	BYTE BatteryPercent; // (using the above assumption, where 200 raw = 100%)
155	bool bBatteryDrained; // battery is nearly flat
156	bool bRumble;
157	bool bExtension; // an extension (eg. Nunchuk) is connected.
158
159	// speaker state:
160	struct speaker
161	{
162	bool bEnabled;
163	bool bMuted;
164	speaker_freq Freq;
165	BYTE Volume;
166	} Speaker;
167
168	// the extension plugged into the Wiimote (if any)
169	enum extension_type
170	{
171	NONE = 0,
172	NUNCHUK,
173	CLASSIC,
174	GH3_GHWT_GUITAR, // GH3 or GHWT Guitar (treated as Classic)
175	GHWT_DRUMS, // not yet used
176	BALANCE_BOARD,
177	MOTION_PLUS,
178	PARTIALLY_INSERTED,
179	};
180	extension_type ExtensionType;
181
182	// joystick struct (shared between Nunchuk & Classic Controller)
183	struct joystick
184	{
185	friend class wiimote;
186
187	// raw unprocessed coordinates:
188	float RawX, RawY;
189
190	// processed coordinates in approximately -1 - +1 range (includes calibration
191	// data and deadzones) - note that due to calibration inaccuracies, the
192	// extremes may be slightly over/under (+-)1.0.
193	float X, Y;
194
195	// a 'deadzone' is a user-defined range near the joystick center which
196	// is treated as zero (joysticks often drift a little even at the center
197	// position). you can set a deadzone for each axis at any time, range is
198	// 0.0 (off) to 1.0 (entire range - not useful :). try 0.03.
199	struct deadzone
200	{
201	float X, Y;
202	} DeadZone;
203	};
204
205	// Nunchuk state (if connected)
206	struct nunchuk
207	{
208	struct calibration_info
209	{
210	BYTE X0, Y0, Z0;
211	BYTE XG, YG, ZG;
212	BYTE MinX, MidX, MaxX;
213	BYTE MinY, MidY, MaxY;
214	} CalibrationInfo;
215
216	acceleration Acceleration;
217	joystick Joystick;
218	bool C;
219	bool Z;
220	} Nunchuk;
221
222	// Classic Controller state (if connected)
223	struct classic_controller
224	{
225	// calibration information (stored on the controller)
226	struct calibration_info
227	{
228	BYTE MinXL, MidXL, MaxXL;
229	BYTE MinYL, MidYL, MaxYL;
230	BYTE MinXR, MidXR, MaxXR;
231	BYTE MinYR, MidYR, MaxYR;
232	BYTE MinTriggerL, MaxTriggerL;
233	BYTE MinTriggerR, MaxTriggerR;
234	} CalibrationInfo;
235
236	// button state
237	struct buttons
238	{
239	// convenience accessors
240	inline bool A () const { return (Bits & _A) != 0; }
241	inline bool B () const { return (Bits & _B) != 0; }
242	inline bool Plus () const { return (Bits & PLUS) != 0; }
243	inline bool Minus () const { return (Bits & MINUS) != 0; }
244	inline bool Home () const { return (Bits & HOME) != 0; }
245	inline bool Up () const { return (Bits & UP) != 0; }
246	inline bool Down () const { return (Bits & DOWN) != 0; }
247	inline bool Left () const { return (Bits & LEFT) != 0; }
248	inline bool Right () const { return (Bits & RIGHT) != 0; }
249	inline bool X () const { return (Bits & _X) != 0; }
250	inline bool Y () const { return (Bits & _Y) != 0; }
251	inline bool ZL () const { return (Bits & _ZL) != 0; }
252	inline bool ZR () const { return (Bits & _ZR) != 0; }
253	inline bool TriggerL () const { return (Bits & TRIG_L) != 0; }
254	inline bool TriggerR () const { return (Bits & TRIG_R) != 0; }
255
256	// all 15 buttons stored as bits (set = pressed)
257	WORD Bits;
258
259	// button bitmasks (little-endian order)
260	enum mask
261	{
262	TRIG_R = 0x0002,
263	PLUS = 0x0004,
264	HOME = 0x0008,
265	MINUS = 0x0010,
266	TRIG_L = 0x0020,
267	DOWN = 0x0040,
268	RIGHT = 0x0080,
269	UP = 0x0100,
270	LEFT = 0x0200,
271	_ZR = 0x0400,
272	_X = 0x0800,
273	_A = 0x1000,
274	_Y = 0x2000,
275	_B = 0x4000,
276	_ZL = 0x8000,
277	//
278	ALL = TRIG_R\|PLUS\|HOME\|MINUS\|TRIG_L\|DOWN\|RIGHT\|UP\|LEFT\|
279	_ZR\|_X\|_A\|_Y\|_B\|_ZL,
280	};
281	} Button;
282
283	// joysticks
284	joystick JoystickL;
285	joystick JoystickR;
286
287	// triggers
288	BYTE RawTriggerL, RawTriggerR;
289	float TriggerL, TriggerR;
290	} ClassicController;
291
292	struct balance_board
293	{
294	// values for each of the board's 4 sensors:
295	// (these values are always exposed unmodifed)
296	struct sensors_raw
297	{
298	short TopR;
299	short TopL;
300	short BottomR;
301	short BottomL;
302	};
303	struct sensors_f
304	{
305	float TopL;
306	float TopR;
307	float BottomL;
308	float BottomR;
309
310	float Total; // sum of the 4 corner weights
311	};
312
313	// calibration info
314	struct calibration_info
315	{
316	sensors_raw Kg0; // calibration at 0 Kg
317	sensors_raw Kg17; // " 17 Kg
318	sensors_raw Kg34; // " 34 Kg
319	} CalibrationInfo;
320
321	// state:
322	sensors_raw Raw; // raw values (per sensor)
323	sensors_f AtRestKg; // set by Connect() and CalibrateAtRest()
324	// (the values below have their 'at-rest' offsets automatically removed)
325	sensors_f Kg; // kilograms (per sensor)
326	sensors_f Lb; // pounds (per sensor)
327	} BalanceBoard;
328
329	struct motion_plus
330	{
331	// (these values are always exposed unmodifed)
332	struct sensors_raw
333	{
334	short Yaw;
335	short Pitch;
336	short Roll;
337	};
338	struct sensors_f
339	{
340	float Yaw;
341	float Pitch;
342	float Roll;
343	};
344
345	// state:
346	sensors_raw Raw;
347	sensors_f Speed;
348	} MotionPlus;
349
350	// ---- internal use only ----
351	protected:
352	unsigned WiimoteNearGUpdates;
353	unsigned NunchukNearGUpdates;
354
355	void Clear (bool including_deadzones)
356	{
357	joystick::deadzone nunchuk_deadzone,
358	classic_joyl_deadzone,
359	classic_joyr_deadzone;
360
361	// preserve the deadzone settings?
362	if(!including_deadzones) {
363	nunchuk_deadzone = Nunchuk.Joystick.DeadZone;
364	classic_joyl_deadzone = ClassicController.JoystickL.DeadZone;
365	classic_joyr_deadzone = ClassicController.JoystickR.DeadZone;
366	}
367
368	memset(this, 0, sizeof(wiimote_state));
369
370	// restore the deadzones?
371	if(!including_deadzones) {
372	Nunchuk.Joystick.DeadZone = nunchuk_deadzone;
373	ClassicController.JoystickL.DeadZone = classic_joyl_deadzone;
374	ClassicController.JoystickR.DeadZone = classic_joyr_deadzone;
375	}
376	}
377	};
378
379	#endif // _WIIMOTE_STATE_H
tadas_AT_dailyda_DOT_com	ViewVC Help
Powered by ViewVC 1.1.8