static WogModifiers check_keystate(WPARAM mousedata)
{
WogModifiers m = 0U;
#define PRESSED(KEY) ((((unsigned short) GetKeyState(VK_##KEY)) >> 15) == 1)
#ifdef HARDDEBUG
debugf("PRESSED(CONTROL) -> 0x%08x\n",(unsigned) PRESSED(CONTROL));
#endif
if (PRESSED(CONTROL))
m |= WOG_MODIFIER_CTRL;
if (PRESSED(SHIFT))
m |= WOG_MODIFIER_SHIFT;
if (PRESSED(MENU))
m |= WOG_MODIFIER_ALT;
if (mousedata & MK_LBUTTON)
m |= WOG_MODIFIER_MOUSE_LEFT;
if (mousedata & MK_RBUTTON)
m |= WOG_MODIFIER_MOUSE_RIGHT;
if (mousedata & MK_MBUTTON)
m |= WOG_MODIFIER_MOUSE_MIDDLE;
return m;
#undef PRESSED
}
bool PSPKeyboard::handleDefaultState(Common::Event &event, SceCtrlData &pad) {
DEBUG_ENTER_FUNC();
bool haveEvent = false;
if (PRESSED(PSP_CTRL_LTRIGGER)) // Don't say we used up the input
_state = kLTriggerDown;
else if (PRESSED(PSP_CTRL_RTRIGGER)) // Don't say we used up the input
_state = kRTriggerDown;
else if (CHANGED(PSP_4BUTTONS)) // We only care about the 4 buttons
haveEvent = getInputChoice(event, pad);
else if (!DOWN(PSP_4BUTTONS)) // Must be up to move cursor
getCursorMovement(pad);
return haveEvent;
}
int gmread(int ev)
{
gm.key = KEY(ev);
if(gm.key < 128) {
if(RELEASED(ev)) gm.kb[gm.key] = 0;
else gm.kb[gm.key] = 1;
}
if(gm.key == MICE_DX) {
gm.ms.x += AXIS(ev);
if(gm.ms.x < 0) gm.ms.x = 0;
if(gm.ms.x >= gm.vfb->width) gm.ms.x = gm.vfb->width - 1;
}
if(gm.key == MICE_DY) {
gm.ms.y += AXIS(ev);
if(gm.ms.y < 0) gm.ms.y = 0;
if(gm.ms.y >= gm.vfb->height) gm.ms.y = gm.vfb->height - 1;
}
if(gm.key == MICE_LEFT) {
if(PRESSED(ev)) {
gm.push.key = 1;
gm.push.x = gm.ms.x;
gm.push.y = gm.ms.y;
}
else {
gm.click.key = 1;
gm.click.x = gm.ms.x;
gm.click.y = gm.ms.y;
}
}
return ev;
}
/*
* Attempts to read a character from the controller
* Uses the state machine.
* returns whether we have an event
*/
bool PSPKeyboard::processInput(Common::Event &event, PspEvent &pspEvent, SceCtrlData &pad) {
DEBUG_ENTER_FUNC();
bool haveEvent = false; // Whether we have an event for the event manager to process
bool havePspEvent = false;
event.kbd.flags = 0;
_buttonsChanged = _prevButtons ^ pad.Buttons;
if (!_init) // In case we never had init
return false;
if (_state == kInvisible) // Return if we're invisible
return false;
if (_state != kMove && PRESSED(PSP_CTRL_SELECT)) {
_lastState = _state;
_state = kMove; // Check for move or visible state
} else if (CHANGED(PSP_CTRL_START)) { // Handle start button: enter, make KB invisible
event.kbd.ascii = '\r';
event.kbd.keycode = Common::KEYCODE_RETURN;
event.type = DOWN(PSP_CTRL_START) ? Common::EVENT_KEYDOWN : Common::EVENT_KEYUP;
haveEvent = true;
_dirty = true;
if (UP(PSP_CTRL_START))
havePspEvent = true;
}
// Check for being in state of moving the keyboard onscreen or pressing select
else if (_state == kMove)
havePspEvent = handleMoveState(pad);
else if (_state == kDefault)
haveEvent = handleDefaultState(event, pad);
else if (_state == kCornersSelected)
haveEvent = handleCornersSelectedState(event, pad);
else if (_state == kRTriggerDown)
handleRTriggerDownState(pad); // Deal with trigger states
else if (_state == kLTriggerDown)
handleLTriggerDownState(pad); // Deal with trigger states
if (havePspEvent) {
pspEvent.type = PSP_EVENT_SHOW_VIRTUAL_KB; // tell the input handler we're off
pspEvent.data = false;
}
_prevButtons = pad.Buttons;
return haveEvent;
}
void KeyboardCallback(GLFWwindow *window, int key, int scancode, int action, int mods) {
#define PRESSED(k) (key == k && action == GLFW_PRESS)
#define RELEASED(k) (key == k && action == GLFW_RELEASE)
// Left player controls
if (PRESSED(GLFW_KEY_W)) {
leftPlayer.setVerticalSpeed(-PLAYER_SPEED);
}
if (RELEASED(GLFW_KEY_W)) {
leftPlayer.setVerticalSpeed(0.0f);
}
if (PRESSED(GLFW_KEY_S)) {
leftPlayer.setVerticalSpeed(PLAYER_SPEED);
}
if (RELEASED(GLFW_KEY_S)) {
leftPlayer.setVerticalSpeed(0.0f);
}
// Right player controls
if (PRESSED(GLFW_KEY_UP)) {
rightPlayer.setVerticalSpeed(-PLAYER_SPEED);
}
if (RELEASED(GLFW_KEY_UP)) {
rightPlayer.setVerticalSpeed(0.0f);
}
if (PRESSED(GLFW_KEY_DOWN)) {
rightPlayer.setVerticalSpeed(PLAYER_SPEED);
}
if (RELEASED(GLFW_KEY_DOWN)) {
rightPlayer.setVerticalSpeed(0.0f);
}
// General game controls
if (PRESSED(GLFW_KEY_SPACE)) {
paused = !paused;
}
if (PRESSED(GLFW_KEY_ESCAPE)) {
glfwSetWindowShouldClose(window, 1);
}
}
void kmain(void)
{
int reset_after_shutdown=0;
#ifdef CONF_DKEY
int c;
#endif
/* Install the text.hi segment in the correct place. The
* firmware loader puts it in the bss segment, we copy it
* to it's final location.
*/
memcpy(&__text_hi, &__bss, &__etext_hi - &__text_hi);
reset_vector = rom_reset_vector;
/* Turn off motor, since writing to hitext manipulates motors */
motor_controller = 0;
memset(&__bss, 0, &__bss_end - &__bss);
#ifdef CONF_MM
mm_init();
#endif
while (1) {
power_init();
#ifdef CONF_AUTOSHUTOFF
shutoff_init();
#endif
lcd_init();
#ifdef CONF_DSOUND
dsound_init();
#endif
#ifdef CONF_TIME
systime_init();
#endif
#ifdef CONF_DSENSOR
ds_init();
#endif
#ifdef CONF_DMOTOR
dm_init();
#endif
#ifdef CONF_LNP
lnp_init();
lnp_logical_init();
#endif
#ifdef CONF_TM
tm_init();
#endif
#ifdef CONF_PROGRAM
program_init();
#endif
show_on();
// wait till power key released
//
#ifdef CONF_DKEY
dkey_multi=KEY_ANY;
while((c=dkey_multi) & KEY_ONOFF);
#else
while (PRESSED(dbutton(), BUTTON_ONOFF));
delay(100);
#endif
cls();
#ifndef CONF_PROGRAM
lcd_show(man_run);
#ifndef CONF_LCD_REFRESH
lcd_refresh();
#endif
#endif
// run app
//
#ifdef CONF_TM
#ifndef CONF_PROGRAM
execi(&main,0,0,PRIO_NORMAL,DEFAULT_STACK_SIZE);
#endif
tm_start();
#else
main(0,0);
#endif
show_off();
// ON/OFF + PROGRAM -> erase firmware
#ifdef CONF_DKEY
while((c=dkey_multi) & KEY_ONOFF)
if(c&KEY_PRGM)
reset_after_shutdown=1;
#else
while (PRESSED(dbutton(), BUTTON_ONOFF))
if (PRESSED(dbutton(), BUTTON_PROGRAM))
reset_after_shutdown=1;
#endif
#ifdef CONF_PROGRAM
program_shutdown();
#endif
#ifdef CONF_LNP
lnp_logical_shutdown();
#endif
#ifdef CONF_DMOTOR
dm_shutdown();
#endif
#ifdef CONF_DSENSOR
ds_shutdown();
#endif
#ifdef CONF_TIME
systime_shutdown();
#endif
if (reset_after_shutdown)
rom_reset();
lcd_clear();
lcd_power_off();
power_off();
}
}
UBYTE
scale_position (UBYTE keys)
{
// is only one d-pad key being pressed?
BOOLEAN nothing_else = !((keys & 0x0F) & ((keys & 0x0F) - 1));
if (PRESSED (LEFT) && nothing_else) return 1;
if (PRESSED (LEFT) && PRESSED (DOWN)) return 2;
if (PRESSED (DOWN) && nothing_else) return 3;
if (PRESSED (DOWN) && PRESSED (RIGHT)) return 4;
if (PRESSED (RIGHT) && nothing_else) return 5;
if (PRESSED (RIGHT) && PRESSED (UP)) return 6;
if (PRESSED (UP) && nothing_else) return 7;
if (PRESSED (UP) && PRESSED (LEFT)) return 8;
return 0;
}
void
main ()
{
UBYTE keys;
UBYTE pos, old_pos = 0;
UBYTE note, old_note = 0;
UBYTE relative_octave = 0;
UBYTE absolute_octave;
UBYTE waveform = pulse_50;
UBYTE mode = 0;
UBYTE root = C;
SCALE scale[8];
font_t big_font, small_font;
font_init ();
big_font = font_load (font_ibm);
small_font = font_load (font_spect);
font_set (big_font);
printf (";; Boueux v%s\n", BOUEUX_VERSION);
INIT_SOUND;
MASTER_VOLUME = OFF;
update_waveform (waveform);
MASTER_VOLUME = HIGH;
build_scale_mode (scale, root, mode);
for (;;)
{
keys = joypad ();
pos = scale_position (keys);
if (pos)
{
note = scale[pos - 1] + relative_octave*OCTAVE_LEN;
/* Raise by perfect 4th */
if (PRESSED (B)) note += 5; /* a perfect fourth = 5 semitones */
/* Lower by semitone */
if (PRESSED (A)) note -= 1;
}
/* Change octave */
if (PRESSED (START))
{
relative_octave = !relative_octave;
printf ("\n;; rel octave +%d\n", relative_octave);
WAIT_KEY_UP (START);
}
if (PRESSED (SELECT))
{
/* Change mode */
if (PRESSED (RIGHT))
{
mode = (mode + 1) % NUM_MODES;
WAIT_KEY_UP (RIGHT);
build_scale_mode (scale, root, mode);
}
/* Change waveform */
if (PRESSED (LEFT))
{
WAIT_KEY_UP (LEFT);
waveform = (waveform + 1) % NUM_WAVEFORMS;
update_waveform (waveform);
}
/* Increment root note */
if (PRESSED (UP))
{
WAIT_KEY_UP (UP);
root = (root + 1) % OCTAVE_LEN;
build_scale_mode (scale, root, mode);
}
/* Decrement root note */
if (PRESSED (DOWN))
{
WAIT_KEY_UP (DOWN);
if (root == 0)
root = OCTAVE_LEN - 1;
else
root = (root - 1) % OCTAVE_LEN;
build_scale_mode (scale, root, mode);
}
continue;
}
if ((note != old_note) || (pos != old_pos))
{
if (pos) /* Note will be played */
{
CH1_VOL = HIGH;
CH2_VOL = HIGH;
play_note (note, waveform);
font_set (small_font);
printf (note_names[note % OCTAVE_LEN]);
absolute_octave = note/OCTAVE_LEN + 3;
printf ("%d", absolute_octave);
printf (" ");
font_set (big_font);
}
else /* Stop note */
{
CH1_VOL = OFF;
CH2_VOL = OFF;
printf (". ");
}
}
if (waveform == wawa) wawa_update();
old_note = note;
old_pos = pos;
}
}
bool PSPKeyboard::getInputChoice(Common::Event &event, SceCtrlData &pad) {
DEBUG_ENTER_FUNC();
int innerChoice;
bool haveEvent = false;
if (UNPRESSED(PSP_CTRL_TRIANGLE)) {
innerChoice = 0;
event.type = Common::EVENT_KEYUP; // We give priority to key_up
} else if (UNPRESSED(PSP_CTRL_CIRCLE)) {
innerChoice = 1;
event.type = Common::EVENT_KEYUP; // We give priority to key_up
} else if (UNPRESSED(PSP_CTRL_CROSS)) {
innerChoice = 2;
event.type = Common::EVENT_KEYUP; // We give priority to key_up
} else if (UNPRESSED(PSP_CTRL_SQUARE)) {
innerChoice = 3;
event.type = Common::EVENT_KEYUP; // We give priority to key_up
} else if (UNPRESSED(PSP_CTRL_LTRIGGER) && _state == kCornersSelected) {
innerChoice = 4;
event.type = Common::EVENT_KEYUP; // We give priority to key_up
} else if (UNPRESSED(PSP_CTRL_RTRIGGER) && _state == kCornersSelected) {
innerChoice = 5;
event.type = Common::EVENT_KEYUP; // We give priority to key_up
} else if (PRESSED(PSP_CTRL_TRIANGLE)) {
innerChoice = 0;
event.type = Common::EVENT_KEYDOWN;
} else if (PRESSED(PSP_CTRL_CIRCLE)) {
innerChoice = 1;
event.type = Common::EVENT_KEYDOWN;
} else if (PRESSED(PSP_CTRL_CROSS)) {
innerChoice = 2;
event.type = Common::EVENT_KEYDOWN;
} else if (PRESSED(PSP_CTRL_SQUARE)) {
innerChoice = 3;
event.type = Common::EVENT_KEYDOWN;
} else if (PRESSED(PSP_CTRL_LTRIGGER) && _state == kCornersSelected) {
innerChoice = 4;
event.type = Common::EVENT_KEYDOWN; // We give priority to key_up
} else { /* (PRESSED(PSP_CTRL_RTRIGGER)) && _state == kCornersSelected */
innerChoice = 5;
event.type = Common::EVENT_KEYDOWN; // We give priority to key_up
}
#define IS_UPPERCASE(x) ((x) >= (unsigned short)'A' && (x) <= (unsigned short)'Z')
#define TO_LOWER(x) ((x) += 'a'-'A')
//Now grab the value out of the array
short choice = _modeChar[_mode][_oldCursor][innerChoice];
event.kbd.ascii = choice <= 255 ? choice : 0;
// Handle upper-case which is missing in Common::KeyCode
if (IS_UPPERCASE(choice)) {
event.kbd.keycode = (Common::KeyCode) TO_LOWER(choice);
event.kbd.flags = Common::KBD_SHIFT;
} else
event.kbd.keycode = (Common::KeyCode) choice;
haveEvent = (choice != Common::KEYCODE_INVALID) ? true : false; // We have an event/don't if it's invalid
return haveEvent;
}
/* Programme "Flocon de Koch" */
int main(int argc, char *argv[])
{
struct parameters parameters;
struct list *koch = NULL;
uint32_t *picture = NULL;
char *outfile = NULL;
bool screenshots = false;
srand(time(NULL));
#ifdef PSP2
vita2d_init();
vita2d_set_clear_color(RGBA8(0, 0, 0, 0xFF));
vita2d_texture *tex = vita2d_create_empty_texture(960, 544);
uint32_t *tex_data = vita2d_texture_get_datap(tex);
SceCtrlData pad, lastbuttons;
memset(&pad, 0, sizeof(pad));
#endif
/* Initialisations */
init_parameters(¶meters, argc, argv);
show_parameters(parameters);
init_koch(&koch, parameters.image_size, parameters.segment_length);
outfile = malloc(3 + strlen(parameters.outfile) + 1);
int32_t i = 0, step = 1;
bool done = false;
/* Génération de chaque flocon */
while (!done)
{
#ifdef PSP2
lastbuttons = pad;
sceCtrlPeekBufferPositive(0, &pad, 1);
if (pad.buttons & PSP2_CTRL_TRIANGLE) break;
if (PRESSED(lastbuttons.buttons, pad.buttons, PSP2_CTRL_LTRIGGER))
parameters.fg_color = RGBA8(rand()%255, rand()%255, rand()%255, 255);
//if (PRESSED(lastbuttons.buttons, pad.buttons, PSP2_CTRL_RTRIGGER))
// screenshots ^= 1;
vita2d_start_drawing();
vita2d_clear_screen();
#endif
sprintf(outfile, "%02d_%s", i, parameters.outfile);
if (step > 0)
generer_koch(koch, i);
else {
for (uint32_t j = 0; j < i; j++)
generer_koch(koch, j);
}
//show_koch_list(koch);
/* Ne générer l'image que si c'est la dernière ou qu'on les génère toutes */
if (parameters.all_images || i == parameters.nb_iterations)
{
init_picture(&picture, parameters.image_size, parameters.bg_color);
render_image_bresenham(picture, koch, parameters.image_size, parameters.fg_color);
#ifndef PSP2
const uint32_t LEN = 960 * 544;
uint32_t *data = calloc(LEN, sizeof(uint32_t));
for (uint32_t i = 0; i < LEN; i++)
data[i] = 0;
uint32_t k = 0;
for (uint32_t i = 0; i < 544; i++)
for (uint32_t j = 0; j < 960; j++) {
if (208 <= j && j < 752 && k < 544*544)
data[i * 960 + j] = picture[k++];
else
data[i * 960 + j] = 0;
}
create_image(data, 960, 544, outfile);
//create_image(picture, parameters.image_size, parameters.image_size, outfile);
#else
uint32_t k = 0;
for (uint32_t i = 0; i < 544; i++)
for (uint32_t j = 0; j < 960; j++) {
if (208 <= j && j < 752 && k < 544*544)
tex_data[i * 960 + j] = picture[k++];
else
tex_data[i * 960 + j] = 0;
}
if (screenshots)
create_image(tex_data, 960, 544, outfile);
#endif
}
#ifdef PSP2
vita2d_draw_texture(tex, 0, 0);
vita2d_end_drawing();
vita2d_swap_buffers();
sceKernelDelayThread(100000);
#endif
i = i + step;
if (i == parameters.nb_iterations)
#ifdef PSP2
i--, step = -1;
#else
done = true;
#endif
else if (i == 0) {
step = 1;
free_koch(koch);
init_koch(&koch, parameters.image_size, parameters.segment_length);
}
if (step < 0) {
free_koch(koch);
init_koch(&koch, parameters.image_size, parameters.segment_length);
}
if (parameters.nb_iterations == 1)
done = true;
}
bool Keyboard::stateChanged(Code key) const { return (PRESSED(state, key) != PRESSED(lastState, key)); }
bool Keyboard::isPressed(Code key) const { return PRESSED(state, key); }
std::vector<Keyboard::Code> Keyboard::activeKeys() const {
std::vector<Code> res;
for (unsigned int key=0; key<256; key++)
if (PRESSED(state, key)) res.push_back(key);
return res;
}
static int JoyPressed(int btn) {
switch(btn) {
case XE_BTN_UP: {
return PRESSED(up);
}
case XE_BTN_DOWN: {
return PRESSED(down);
}
case XE_BTN_LEFT: {
return PRESSED(left);
}
case XE_BTN_RIGHT: {
return PRESSED(right);
}
case XE_BTN_A: {
return PRESSED(a);
}
case XE_BTN_B: {
return PRESSED(b);
}
case XE_BTN_X: {
return PRESSED(x);
}
case XE_BTN_Y: {
return PRESSED(y);
}
case XE_BTN_START: {
return PRESSED(start);
}
case XE_BTN_BACK: {
return PRESSED(back);
}
case XE_BTN_LOGO: {
return PRESSED(logo);
}
case XE_BTN_RB: {
return PRESSED(rb);
}
case XE_BTN_LB: {
return PRESSED(lb);
}
case XE_BTN_LT: {
return ctrl.lt>200;
}
case XE_BTN_RT: {
return ctrl.rt>200;
}
default:
return 0;
}
}
C_RESULT update_wiimote(void)
{
C_RESULT res = C_OK;
static struct cwiid_state state,previous_state;
static int control_mode = 1;
static int valid_domain = 0;
int8_t x, y;
static int start=0;
static int select=0;
static vec3 a={0,0,0},s={0,0,0};
static vec3sph r={0,0,0},pr={0,0,0},rref={0,0,0};
static float pitch=0.0f,roll=0.0f,gaz=0.0f,yaw=0.0f;
float tmp;
static int fly=0;
if (cwiid_get_state(wiimote, &state))
{
fprintf(stderr, "Error getting state\n");
res = C_FAIL;
}
#define SWITCHING(X) ((state.buttons&X) && !(previous_state.buttons&X))
#define RELEASING(X) ((!state.buttons&X) && (previous_state.buttons&X))
#define PRESSED(X) ((state.buttons&X))
static int flag_rumble=0;
#define RUMBLE_ON { if (!flag_rumble) {flag_rumble=1; } }
/* Sets how to use the wiimote */
#define MAXMODE 4
if (SWITCHING(CWIID_BTN_MINUS)) {
control_mode--;
if (control_mode<1) control_mode=MAXMODE;
leds(1<<(control_mode-1));
}
if (SWITCHING(CWIID_BTN_PLUS)) {
control_mode++;
if (control_mode>MAXMODE) control_mode=1;
leds(1<<(control_mode-1));
}
/* Gets gravitation G projection on x,y,z axis */
a.x = - (float32_t) ((((double)state.acc[CWIID_X] - wm_cal.zero[CWIID_X]) /
(wm_cal.one[CWIID_X] - wm_cal.zero[CWIID_X])));
a.y = - (float32_t) ((((double)state.acc[CWIID_Y] - wm_cal.zero[CWIID_Y]) /
(wm_cal.one[CWIID_Y] - wm_cal.zero[CWIID_Y])));
a.z = + (float32_t) ((((double)state.acc[CWIID_Z] - wm_cal.zero[CWIID_Z]) /
(wm_cal.one[CWIID_Z] - wm_cal.zero[CWIID_Z])));
s.x = (a.x<0.0f)?(1.0f):(-1.0f);
s.y = (a.y<0.0f)?(1.0f):(-1.0f);
s.z = (a.z<0.0f)?(1.0f):(-1.0f);
float ax2 = a.x*a.x;
float ay2 = a.y*a.y;
float az2 = a.z*a.z;
r.r = sqrtf((ax2+ay2)+az2);
switch(control_mode)
{
case 1:
case 2:
if (r.r==0.0f) { r.p=r.t=0.0f; } else {
// Angle gauche/droite
r.p = asin(a.y); if (isnan(r.p)) r.p=0.0f;
// Sur plan vertical radial
r.t = acos(a.z/(sqrtf(az2+ax2))); if (isnan(r.t)) r.t=0.0f;
r.t*=s.x;
}
break;
case 3:
case 4:
if (r.r==0.0f) { r.p=r.t=0.0f; } else {
// Angle entre le projete de G sur le plan vertical longitudinal (yz) et l'axe z
r.p = acos(a.z/(sqrtf(az2+ay2))); if (isnan(r.p)) r.p=0.0f;
/* If wiimote faces the ground */
//if (a.z<0.0f) r.p= M_PI-r.p;
r.p*=s.y;
// Idem sur le plan vertical radial
r.t = acos(a.z/(sqrtf(az2+ax2))); if (isnan(r.t)) r.t=0.0f;
r.t*=s.x;
}
break;
}
r.r = (r.r+pr.r)/2.0f;
r.t = (r.t+pr.t)/2.0f;
r.p = (r.p+pr.p)/2.0f;
switch(control_mode)
{
case 1:
case 2:
/* Wiimote is handled horizontally.
* '2' button under left thumb
* directionnal cross under right thumb
*/
/* 0 -> buttons facing sky */
if ((SWITCHING(CWIID_BTN_1)||SWITCHING(CWIID_BTN_2)||SWITCHING(CWIID_BTN_B))){ rref=r; }
if (PRESSED(CWIID_BTN_1)||PRESSED(CWIID_BTN_2)||PRESSED(CWIID_BTN_B))
{
/* If wiimote facing ground */
if (a.z<0 && a.x>0)
{
rumble(1);
}
else
{
rumble(0);
leds(1<<(control_mode-1));
pitch = (r.t-rref.t)*1.0f; if (pitch<-1.0f) pitch=-1.0f; if (pitch>1.0f) pitch=1.0f;
roll = -(r.p-rref.p)*0.75f; if (roll<-1.0f) roll=-1.0f; if (roll>1.0f) roll=1.0f;
fly=1;
}
}
else
{
pitch=roll=0;
rumble(0);
leds(1<<(control_mode-1));
fly=0;
}
gaz = (PRESSED(CWIID_BTN_LEFT))? 1.0f: (PRESSED(CWIID_BTN_RIGHT)) ? -1.0f : 0.0f;
yaw = (PRESSED(CWIID_BTN_DOWN))? -1.0f: (PRESSED(CWIID_BTN_UP)) ? 1.0f : (control_mode==2) ? (-pitch*roll) : 0.0f;
break;
case 3:
case 4:
if (PRESSED(CWIID_BTN_B))
{
if (a.z<-0.5f)
{
rumble(1);
}
else
{
rumble(0);
leds(1<<(control_mode-1));
pitch = -(r.p-rref.p)*1.5f; if (pitch<-1.0f) pitch=-1.0f; if (pitch>1.0f) pitch=1.0f;
roll = (r.t-rref.t)*1.5f; if (roll<-1.0f) roll=-1.0f; if (roll>1.0f) roll=1.0f;
fly=1;
}
}
else
{
rumble(0);
leds(1<<(control_mode-1));
fly=0;
pitch=roll=0;
}
if (SWITCHING(CWIID_BTN_B)) { rref = r; }
gaz = (PRESSED(CWIID_BTN_DOWN))? -1.0f: (PRESSED(CWIID_BTN_UP)) ? +1.0f : 0.0f;
yaw = (PRESSED(CWIID_BTN_LEFT))? -1.0f: (PRESSED(CWIID_BTN_RIGHT)) ? 1.0f : (control_mode==4) ? (-pitch*roll) : 0.0f;
}
/* Buttons common to all modes */
if (SWITCHING(CWIID_BTN_A)) { start^=1; ardrone_tool_set_ui_pad_start(start); }
if (SWITCHING(CWIID_BTN_HOME)) {
select^=1;
ardrone_tool_set_ui_pad_select(select);
ardrone_tool_set_ui_pad_start(0);
}
//
//printf("Wiimote mode 2 [ax %f][ay %f][az %f]\n\033[1A", a.x,a.y,a.z);
printf("Wiimode %i [rr %3.2f][rp %3.2f][rt %3.2f]\n", control_mode,r.r,r.p,r.t);
printf("[Fly %i][Ptc %3.2f][Rl %3.2f][Yw %3.2f][Gz %3.2f][Strt. %i][Sel. %i]\n\033[2A", fly,pitch,roll,yaw,gaz,start,select);
ardrone_at_set_progress_cmd( fly,/*roll*/roll,/*pitch*/pitch,/*gaz*/gaz,/*yaw*/yaw);
/*api_set_iphone_acceleros(
(state.buttons&CWIID_BTN_2 ? 1 : 0)|(state.buttons&CWIID_BTN_A ? 2 : 0),
a_x, a_y, a_z);*/
previous_state = state;
pr=r;
return C_OK;
}
