/*
* This file is part of the DXX-Rebirth project <https://www.dxx-rebirth.com/>.
* It is copyright by its individual contributors, as recorded in the
* project's Git history. See COPYING.txt at the top level for license
* terms and a link to the Git history.
*/
/*
*
* SDL mouse driver
*
*/
#include <string.h>
#include <SDL.h>
#include "maths.h"
#include "timer.h"
#include "event.h"
#include "window.h"
#include "mouse.h"
#include "playsave.h"
#include "dxxerror.h"
#include "args.h"
#include "gr.h"
namespace dcx {
namespace {
struct flushable_mouseinfo
{
int delta_x, delta_y, delta_z;
int z;
};
struct mouseinfo : flushable_mouseinfo
{
int x,y;
int cursor_enabled;
fix64 cursor_time;
std::array<fix64, MOUSE_MAX_BUTTONS> time_lastpressed;
};
}
static mouseinfo Mouse;
d_event_mousebutton::d_event_mousebutton(const event_type etype, const unsigned b) :
d_event{etype}, button(b)
{
}
void mouse_init(void)
{
Mouse = {};
}
void mouse_close(void)
{
SDL_ShowCursor(SDL_ENABLE);
}
static window_event_result maybe_send_z_move(const unsigned button)
{
short dz;
if (button == MBTN_Z_UP)
{
Mouse.delta_z += Z_SENSITIVITY;
Mouse.z += Z_SENSITIVITY;
dz = Z_SENSITIVITY;
}
else if (button == MBTN_Z_DOWN)
{
Mouse.delta_z -= Z_SENSITIVITY;
Mouse.z -= Z_SENSITIVITY;
dz = -1*Z_SENSITIVITY;
}
else
return window_event_result::ignored;
const d_event_mouse_moved event{EVENT_MOUSE_MOVED, 0, 0, dz};
return event_send(event);
}
static window_event_result send_singleclick(const bool pressed, const unsigned button)
{
const d_event_mousebutton event{pressed ? EVENT_MOUSE_BUTTON_DOWN : EVENT_MOUSE_BUTTON_UP, button};
con_printf(CON_DEBUG, "Sending event EVENT_MOUSE_BUTTON_%s, button %d, coords %d,%d,%d",
pressed ? "DOWN" : "UP", event.button, Mouse.x, Mouse.y, Mouse.z);
return event_send(event);
}
static window_event_result maybe_send_doubleclick(const fix64 now, const unsigned button)
{
auto &when = Mouse.time_lastpressed[button];
const auto then = when;
when = now;
if (now > then + F1_0/5)
return window_event_result::ignored;
const d_event_mousebutton event{EVENT_MOUSE_DOUBLE_CLICKED, button};
con_printf(CON_DEBUG, "Sending event EVENT_MOUSE_DOUBLE_CLICKED, button %d, coords %d,%d", button, Mouse.x, Mouse.y);
return event_send(event);
}
window_event_result mouse_button_handler(const SDL_MouseButtonEvent *const mbe)
{
window_event_result highest_result(window_event_result::ignored);
if (unlikely(CGameArg.CtlNoMouse))
return window_event_result::ignored;
// to bad, SDL buttons use a different mapping as descent expects,
// this is at least true and tested for the first three buttons
static const std::array<int, 17> button_remap{{
MBTN_LEFT,
MBTN_MIDDLE,
MBTN_RIGHT,
MBTN_Z_UP,
MBTN_Z_DOWN,
MBTN_PITCH_BACKWARD,
MBTN_PITCH_FORWARD,
MBTN_BANK_LEFT,
MBTN_BANK_RIGHT,
MBTN_HEAD_LEFT,
MBTN_HEAD_RIGHT,
MBTN_11,
MBTN_12,
MBTN_13,
MBTN_14,
MBTN_15,
MBTN_16
}};
const unsigned button_idx = mbe->button - 1; // -1 since SDL seems to start counting at 1
if (unlikely(button_idx >= button_remap.size()))
return window_event_result::ignored;
const auto now = timer_query();
const auto button = button_remap[button_idx];
const auto mbe_state = mbe->state;
Mouse.cursor_time = now;
const auto pressed = mbe_state != SDL_RELEASED;
if (pressed) {
highest_result = maybe_send_z_move(button);
}
highest_result = std::max(send_singleclick(pressed, button), highest_result);
//Double-click support
if (pressed)
{
highest_result = std::max(maybe_send_doubleclick(now, button), highest_result);
}
return highest_result;
}
window_event_result mouse_motion_handler(const SDL_MouseMotionEvent *const mme)
{
Mouse.cursor_time = timer_query();
Mouse.x += mme->xrel;
Mouse.y += mme->yrel;
// z handled in mouse_button_handler
const d_event_mouse_moved event{EVENT_MOUSE_MOVED, mme->xrel, mme->yrel, 0};
//con_printf(CON_DEBUG, "Sending event EVENT_MOUSE_MOVED, relative motion %d,%d,%d",
// event.dx, event.dy, event.dz);
return event_send(event);
}
void mouse_flush() // clears all mice events...
{
// event_poll();
static_cast<flushable_mouseinfo &>(Mouse) = {};
SDL_GetMouseState(&Mouse.x, &Mouse.y); // necessary because polling only gives us the delta.
}
//========================================================================
void mouse_get_pos( int *x, int *y, int *z )
{
//event_poll(); // Have to assume this is called in event_process, because event_poll can cause a window to close (depending on what the user does)
*x=Mouse.x;
*y=Mouse.y;
*z=Mouse.z;
}
window_event_result mouse_in_window(window *wind)
{
auto &canv = window_get_canvas(*wind);
return (static_cast<unsigned>(Mouse.x) - canv.cv_bitmap.bm_x <= canv.cv_bitmap.bm_w) &&
(static_cast<unsigned>(Mouse.y) - canv.cv_bitmap.bm_y <= canv.cv_bitmap.bm_h) ? window_event_result::handled : window_event_result::ignored;
}
void mouse_get_delta( int *dx, int *dy, int *dz )
{
*dz = Mouse.delta_z;
Mouse.delta_x = 0;
Mouse.delta_y = 0;
Mouse.delta_z = 0;
SDL_GetRelativeMouseState(dx, dy);
}
template <bool noactivate>
static void mouse_change_cursor()
{
Mouse.cursor_enabled = (!noactivate && !CGameArg.CtlNoMouse && !CGameArg.CtlNoCursor);
if (!Mouse.cursor_enabled)
SDL_ShowCursor(SDL_DISABLE);
}
void mouse_enable_cursor()
{
mouse_change_cursor<false>();
}
void mouse_disable_cursor()
{
mouse_change_cursor<true>();
}
// If we want to display/hide cursor, do so if not already and also hide it automatically after some time.
void mouse_cursor_autohide()
{
static fix64 hidden_time = 0;
const auto is_showing = SDL_ShowCursor(SDL_QUERY);
int result;
if (Mouse.cursor_enabled)
{
const auto now = timer_query();
const auto cursor_time = Mouse.cursor_time;
const auto recent_cursor_time = cursor_time + (F1_0*2) >= now;
if (is_showing)
{
if (recent_cursor_time)
return;
hidden_time = now;
result = SDL_DISABLE;
}
else
{
if (!(recent_cursor_time && hidden_time + (F1_0/2) < now))
return;
result = SDL_ENABLE;
}
}
else
{
if (!is_showing)
return;
result = SDL_DISABLE;
}
SDL_ShowCursor(result);
}
}