wiimote_state.h
Go to the documentation of this file.
00001 // _______________________________________________________________________________ 00002 // 00003 // - WiiYourself! - native C++ Wiimote library v1.15 00004 // (c) gl.tter 2007-10 - http://gl.tter.org 00005 // 00006 // see License.txt for conditions of use. see History.txt for change log. 00007 // _______________________________________________________________________________ 00008 // 00009 // wiimote_state.h (tab = 4 spaces) 00010 00011 // the 'wiimote_state' struct contains all the Wiimote and Extension state data 00012 // (buttons etc) - the wiimote class inherits from this and the app can poll 00013 // the data there at any time. 00014 #ifdef _MSC_VER // VC 00015 # pragma once 00016 #endif 00017 00018 #ifndef _WIIMOTE_STATE_H 00019 # define _WIIMOTE_STATE_H 00020 00021 #include "wiimote_common.h" 00022 00023 00024 // wiimote_state (contains the Wiimote and Extension data and settings) 00025 struct wiimote_state 00026 { 00027 friend class wiimote; // for Clear() 00028 00029 // calibration information (stored on the Wiimote) 00030 struct calibration_info 00031 { 00032 BYTE X0, Y0, Z0; 00033 BYTE XG, YG, ZG; 00034 } CalibrationInfo; 00035 00036 // button state: 00037 struct buttons 00038 { 00039 // convenience accessors 00040 inline bool A () const { return (Bits & _A) != 0; } 00041 inline bool B () const { return (Bits & _B) != 0; } 00042 inline bool Plus () const { return (Bits & PLUS) != 0; } 00043 inline bool Home () const { return (Bits & HOME) != 0; } 00044 inline bool Minus () const { return (Bits & MINUS) != 0; } 00045 inline bool One () const { return (Bits & ONE) != 0; } 00046 inline bool Two () const { return (Bits & TWO) != 0; } 00047 inline bool Up () const { return (Bits & UP) != 0; } 00048 inline bool Down () const { return (Bits & DOWN) != 0; } 00049 inline bool Left () const { return (Bits & LEFT) != 0; } 00050 inline bool Right () const { return (Bits & RIGHT) != 0; } 00051 00052 // all 11 buttons stored as bits (set = pressed) 00053 WORD Bits; 00054 00055 // button bit masks (little-endian order) 00056 enum mask 00057 { 00058 LEFT = 0x0001, 00059 RIGHT = 0x0002, 00060 DOWN = 0x0004, 00061 UP = 0x0008, 00062 PLUS = 0x0010, 00063 TWO = 0x0100, 00064 ONE = 0x0200, 00065 _B = 0x0400, // ie. trigger 00066 _A = 0x0800, 00067 MINUS = 0x1000, 00068 HOME = 0x8000, 00069 // 00070 ALL = LEFT|RIGHT|DOWN|UP|PLUS|TWO|ONE|_A|_B|MINUS|HOME, 00071 }; 00072 } Button; 00073 00074 // accelerometers state: 00075 struct acceleration 00076 { 00077 BYTE RawX, RawY, RawZ; 00078 float X, Y, Z; 00079 00080 // note: experimental! the orientation values can only be safely estimated 00081 // if the controller isn't accelerating (otherwise there is no 00082 // simple way to seperate orientation from acceleration - except 00083 // perhaps using the IR reference and/or some clever assumptions). 00084 // so for now the code only updates orientation if the controller 00085 // appear to be stationary (by checking if the acceleration vector 00086 // length is near 1G for several updates in a row). 00087 // also note that there is no way to detect Yaw from the accelerometer 00088 // alone when it's pointing at the screen (and I'm not curently 00089 // processing IR): 00090 struct orientation 00091 { 00092 float X, Y, Z; 00093 unsigned UpdateAge; // how many acceleration updates ago the last 00094 // orientation estimate was made (if this 00095 // value is high, the values are out-of-date 00096 // and probably shouldn't be used). 00097 // Euler angle support (useful for some things). 00098 // * note that decomposing to Euler angles is complex, not always reliable, 00099 // and also depends on your assumptions about the order each component 00100 // is applied in. you may need to handle this yourself for more 00101 // complex scenarios * 00102 float Pitch; // in degrees (-180 - +180) 00103 float Roll; // " 00104 // float Yaw; 00105 } Orientation; 00106 } Acceleration; 00107 00108 // IR camera state: 00109 struct ir 00110 { 00111 // in theory the IR imager is 1024x768 and so should report raw coords 00112 // 0-1023 x 0-767. in practice I have never seen them exceed the values 00113 // below, so I'm using them instead to give the full 0-1 float range 00114 // (it's possible that the edge pixels are used for processing, or masked 00115 // out due to being unreliable). let me know if your wiimote reports 00116 // a different range. 00117 static const unsigned MAX_RAW_X = 1016; 00118 static const unsigned MAX_RAW_Y = 760; 00119 00120 // data mode reported by the IR sensor 00121 enum mode 00122 { 00123 OFF = 0x00, 00124 BASIC = 0x01, // 10 bytes 00125 EXTENDED = 0x03, // 12 bytes 00126 FULL = 0x05, // 16 bytes * 2 (format unknown) 00127 }; 00128 00129 mode Mode; // read-only (depends on ReportType set) 00130 00131 struct dot 00132 { 00133 bool bVisible; // other values are not valid if == false 00134 unsigned RawX; 00135 unsigned RawY; 00136 float X; // 0-1 (left-right) 00137 float Y; // " (top -bottom) 00138 int Size; // (not available in BASIC mode) 00139 } Dot[4]; 00140 } IR; 00141 00142 struct leds 00143 { 00144 // all LEDs stored in bits 0-3 (1 = lit) 00145 BYTE Bits; 00146 00147 // convenience accessors: 00148 inline bool Lit (unsigned index) 00149 { _ASSERT(index < 4); 00150 return (index >= 4)? false : ((Bits & (1<<index)) != 0); } 00151 } LED; 00152 00153 BYTE BatteryRaw; // 0 - ~200 (it seems 200 *may* be the maximum charge) 00154 BYTE BatteryPercent; // (using the above assumption, where 200 raw = 100%) 00155 bool bBatteryDrained; // battery is nearly flat 00156 bool bRumble; 00157 bool bExtension; // an extension (eg. Nunchuk) is connected. 00158 00159 // speaker state: 00160 struct speaker 00161 { 00162 bool bEnabled; 00163 bool bMuted; 00164 speaker_freq Freq; 00165 BYTE Volume; 00166 } Speaker; 00167 00168 // the extension plugged into the Wiimote (if any) 00169 enum extension_type 00170 { 00171 NONE = 0, 00172 NUNCHUK, 00173 CLASSIC, 00174 GH3_GHWT_GUITAR, // GH3 or GHWT Guitar (treated as Classic) 00175 GHWT_DRUMS, // not yet used 00176 BALANCE_BOARD, 00177 MOTION_PLUS, 00178 PARTIALLY_INSERTED, 00179 }; 00180 extension_type ExtensionType; 00181 00182 // joystick struct (shared between Nunchuk & Classic Controller) 00183 struct joystick 00184 { 00185 friend class wiimote; 00186 00187 // raw unprocessed coordinates: 00188 float RawX, RawY; 00189 00190 // processed coordinates in approximately -1 - +1 range (includes calibration 00191 // data and deadzones) - note that due to calibration inaccuracies, the 00192 // extremes may be slightly over/under (+-)1.0. 00193 float X, Y; 00194 00195 // a 'deadzone' is a user-defined range near the joystick center which 00196 // is treated as zero (joysticks often drift a little even at the center 00197 // position). you can set a deadzone for each axis at any time, range is 00198 // 0.0 (off) to 1.0 (entire range - not useful :). try 0.03. 00199 struct deadzone 00200 { 00201 float X, Y; 00202 } DeadZone; 00203 }; 00204 00205 // Nunchuk state (if connected) 00206 struct nunchuk 00207 { 00208 struct calibration_info 00209 { 00210 BYTE X0, Y0, Z0; 00211 BYTE XG, YG, ZG; 00212 BYTE MinX, MidX, MaxX; 00213 BYTE MinY, MidY, MaxY; 00214 } CalibrationInfo; 00215 00216 acceleration Acceleration; 00217 joystick Joystick; 00218 bool C; 00219 bool Z; 00220 } Nunchuk; 00221 00222 // Classic Controller state (if connected) 00223 struct classic_controller 00224 { 00225 // calibration information (stored on the controller) 00226 struct calibration_info 00227 { 00228 BYTE MinXL, MidXL, MaxXL; 00229 BYTE MinYL, MidYL, MaxYL; 00230 BYTE MinXR, MidXR, MaxXR; 00231 BYTE MinYR, MidYR, MaxYR; 00232 BYTE MinTriggerL, MaxTriggerL; 00233 BYTE MinTriggerR, MaxTriggerR; 00234 } CalibrationInfo; 00235 00236 // button state 00237 struct buttons 00238 { 00239 // convenience accessors 00240 inline bool A () const { return (Bits & _A) != 0; } 00241 inline bool B () const { return (Bits & _B) != 0; } 00242 inline bool Plus () const { return (Bits & PLUS) != 0; } 00243 inline bool Minus () const { return (Bits & MINUS) != 0; } 00244 inline bool Home () const { return (Bits & HOME) != 0; } 00245 inline bool Up () const { return (Bits & UP) != 0; } 00246 inline bool Down () const { return (Bits & DOWN) != 0; } 00247 inline bool Left () const { return (Bits & LEFT) != 0; } 00248 inline bool Right () const { return (Bits & RIGHT) != 0; } 00249 inline bool X () const { return (Bits & _X) != 0; } 00250 inline bool Y () const { return (Bits & _Y) != 0; } 00251 inline bool ZL () const { return (Bits & _ZL) != 0; } 00252 inline bool ZR () const { return (Bits & _ZR) != 0; } 00253 inline bool TriggerL () const { return (Bits & TRIG_L) != 0; } 00254 inline bool TriggerR () const { return (Bits & TRIG_R) != 0; } 00255 00256 // all 15 buttons stored as bits (set = pressed) 00257 WORD Bits; 00258 00259 // button bitmasks (little-endian order) 00260 enum mask 00261 { 00262 TRIG_R = 0x0002, 00263 PLUS = 0x0004, 00264 HOME = 0x0008, 00265 MINUS = 0x0010, 00266 TRIG_L = 0x0020, 00267 DOWN = 0x0040, 00268 RIGHT = 0x0080, 00269 UP = 0x0100, 00270 LEFT = 0x0200, 00271 _ZR = 0x0400, 00272 _X = 0x0800, 00273 _A = 0x1000, 00274 _Y = 0x2000, 00275 _B = 0x4000, 00276 _ZL = 0x8000, 00277 // 00278 ALL = TRIG_R|PLUS|HOME|MINUS|TRIG_L|DOWN|RIGHT|UP|LEFT| 00279 _ZR|_X|_A|_Y|_B|_ZL, 00280 }; 00281 } Button; 00282 00283 // joysticks 00284 joystick JoystickL; 00285 joystick JoystickR; 00286 00287 // triggers 00288 BYTE RawTriggerL, RawTriggerR; 00289 float TriggerL, TriggerR; 00290 } ClassicController; 00291 00292 struct balance_board 00293 { 00294 // values for each of the board's 4 sensors: 00295 // (these values are always exposed unmodifed) 00296 struct sensors_raw 00297 { 00298 short TopR; 00299 short TopL; 00300 short BottomR; 00301 short BottomL; 00302 }; 00303 struct sensors_f 00304 { 00305 float TopL; 00306 float TopR; 00307 float BottomL; 00308 float BottomR; 00309 00310 float Total; // sum of the 4 corner weights 00311 }; 00312 00313 // calibration info 00314 struct calibration_info 00315 { 00316 sensors_raw Kg0; // calibration at 0 Kg 00317 sensors_raw Kg17; // " 17 Kg 00318 sensors_raw Kg34; // " 34 Kg 00319 } CalibrationInfo; 00320 00321 // state: 00322 sensors_raw Raw; // raw values (per sensor) 00323 sensors_f AtRestKg; // set by Connect() and CalibrateAtRest() 00324 // (the values below have their 'at-rest' offsets automatically removed) 00325 sensors_f Kg; // kilograms (per sensor) 00326 sensors_f Lb; // pounds (per sensor) 00327 } BalanceBoard; 00328 00329 struct motion_plus 00330 { 00331 // (these values are always exposed unmodifed) 00332 struct sensors_raw 00333 { 00334 short Yaw; 00335 short Pitch; 00336 short Roll; 00337 }; 00338 struct sensors_f 00339 { 00340 float Yaw; 00341 float Pitch; 00342 float Roll; 00343 }; 00344 00345 // state: 00346 sensors_raw Raw; 00347 sensors_f Speed; 00348 } MotionPlus; 00349 00350 // ---- internal use only ---- 00351 protected: 00352 unsigned WiimoteNearGUpdates; 00353 unsigned NunchukNearGUpdates; 00354 00355 void Clear (bool including_deadzones) 00356 { 00357 joystick::deadzone nunchuk_deadzone, 00358 classic_joyl_deadzone, 00359 classic_joyr_deadzone; 00360 00361 // preserve the deadzone settings? 00362 if(!including_deadzones) { 00363 nunchuk_deadzone = Nunchuk.Joystick.DeadZone; 00364 classic_joyl_deadzone = ClassicController.JoystickL.DeadZone; 00365 classic_joyr_deadzone = ClassicController.JoystickR.DeadZone; 00366 } 00367 00368 memset(this, 0, sizeof(wiimote_state)); 00369 00370 // restore the deadzones? 00371 if(!including_deadzones) { 00372 Nunchuk.Joystick.DeadZone = nunchuk_deadzone; 00373 ClassicController.JoystickL.DeadZone = classic_joyl_deadzone; 00374 ClassicController.JoystickR.DeadZone = classic_joyr_deadzone; 00375 } 00376 } 00377 }; 00378 00379 #endif // _WIIMOTE_STATE_H
