mirror of
https://github.com/scp-fs2open/fs2open.github.com.git
synced 2026-11-09 13:01:29 -10:00
The_E
6e91857745
git-svn-id: svn://svn.icculus.org/fs2open/trunk/fs2_open@10544 387891d4-d844-0410-90c0-e4c51a9137d3
735 lines
14 KiB
C++
735 lines
14 KiB
C++
/*
|
|
* Copyright (C) Volition, Inc. 1999. All rights reserved.
|
|
*
|
|
* All source code herein is the property of Volition, Inc. You may not sell
|
|
* or otherwise commercially exploit the source or things you created based on the
|
|
* source.
|
|
*
|
|
*/
|
|
|
|
|
|
|
|
#ifdef _WIN32
|
|
#include <windows.h>
|
|
#include <windowsx.h>
|
|
#endif
|
|
|
|
#include "io/mouse.h"
|
|
#include "graphics/2d.h"
|
|
#include "parse/scripting.h"
|
|
|
|
#define THREADED // to use the proper set of macros
|
|
#include "osapi/osapi.h"
|
|
#include "cmdline/cmdline.h"
|
|
|
|
#define MOUSE_MODE_DI 0
|
|
#define MOUSE_MODE_WIN 1
|
|
|
|
LOCAL int Mouse_mode = MOUSE_MODE_WIN;
|
|
|
|
int mouse_inited = 0;
|
|
#ifdef WIN32
|
|
LOCAL int Di_mouse_inited = 0;
|
|
#endif
|
|
LOCAL int Mouse_x;
|
|
LOCAL int Mouse_y;
|
|
|
|
CRITICAL_SECTION mouse_lock;
|
|
|
|
int mouse_flags;
|
|
int mouse_left_pressed = 0;
|
|
int mouse_right_pressed = 0;
|
|
int mouse_middle_pressed = 0;
|
|
int mouse_left_up = 0;
|
|
int mouse_right_up = 0;
|
|
int mouse_middle_up = 0;
|
|
int Mouse_dx = 0;
|
|
int Mouse_dy = 0;
|
|
int Mouse_dz = 0;
|
|
|
|
int Mouse_sensitivity = 4;
|
|
int Use_mouse_to_fly = 0;
|
|
int Mouse_hidden = 0;
|
|
int Keep_mouse_centered = 0;
|
|
|
|
#ifdef WIN32
|
|
int di_init();
|
|
void di_cleanup();
|
|
void mouse_eval_deltas_di();
|
|
#endif
|
|
|
|
void mouse_force_pos(int x, int y);
|
|
|
|
static bool Mouse_in_focus = true;
|
|
|
|
void mouse_got_focus()
|
|
{
|
|
if ( !mouse_inited ) return;
|
|
|
|
Mouse_in_focus = true;
|
|
|
|
mouse_flush();
|
|
}
|
|
|
|
void mouse_lost_focus()
|
|
{
|
|
if ( !mouse_inited ) return;
|
|
|
|
Mouse_in_focus = false;
|
|
|
|
mouse_flush();
|
|
}
|
|
|
|
int mouse_is_visible()
|
|
{
|
|
return !Mouse_hidden;
|
|
}
|
|
|
|
void mouse_close()
|
|
{
|
|
if (!mouse_inited)
|
|
return;
|
|
|
|
#ifdef WIN32
|
|
if (Mouse_mode == MOUSE_MODE_DI)
|
|
di_cleanup();
|
|
#endif
|
|
|
|
mouse_inited = 0;
|
|
|
|
DELETE_CRITICAL_SECTION( mouse_lock );
|
|
}
|
|
|
|
void mouse_init()
|
|
{
|
|
// Initialize queue
|
|
if ( mouse_inited ) return;
|
|
mouse_inited = 1;
|
|
|
|
INITIALIZE_CRITICAL_SECTION( mouse_lock );
|
|
|
|
ENTER_CRITICAL_SECTION( mouse_lock );
|
|
|
|
mouse_flags = 0;
|
|
Mouse_x = gr_screen.max_w / 2;
|
|
Mouse_y = gr_screen.max_h / 2;
|
|
|
|
#ifdef WIN32
|
|
if (Cmdline_no_di_mouse) {
|
|
Mouse_mode = MOUSE_MODE_WIN;
|
|
} else {
|
|
if (!di_init() || Cmdline_window || Cmdline_fullscreen_window)
|
|
Mouse_mode = MOUSE_MODE_WIN;
|
|
else
|
|
Mouse_mode = MOUSE_MODE_DI;
|
|
}
|
|
#else
|
|
Mouse_mode = MOUSE_MODE_WIN;
|
|
#endif
|
|
|
|
|
|
#ifdef SCP_UNIX
|
|
// we poll for mouse motion events so be sure to skip those in normal event polling
|
|
SDL_EventState( SDL_MOUSEMOTION, SDL_IGNORE );
|
|
|
|
// we do want to make sure that button presses go through event polling though
|
|
// (should be on by default already, just here as a reminder)
|
|
SDL_EventState( SDL_MOUSEBUTTONDOWN, SDL_ENABLE );
|
|
SDL_EventState( SDL_MOUSEBUTTONUP, SDL_ENABLE );
|
|
#endif
|
|
|
|
LEAVE_CRITICAL_SECTION( mouse_lock );
|
|
|
|
atexit( mouse_close );
|
|
}
|
|
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// mouse_mark_button() is called asynchronously by the OS when a mouse button
|
|
// goes up or down. The mouse button that is affected is passed via the
|
|
// flags parameter.
|
|
//
|
|
// parameters: flags ==> mouse button pressed/released
|
|
// set ==> 1 - button is pressed
|
|
// 0 - button is released
|
|
|
|
void mouse_mark_button( uint flags, int set)
|
|
{
|
|
if ( !mouse_inited ) return;
|
|
|
|
ENTER_CRITICAL_SECTION( mouse_lock );
|
|
|
|
if ( !(mouse_flags & MOUSE_LEFT_BUTTON) ) {
|
|
|
|
if ( (flags & MOUSE_LEFT_BUTTON) && (set == 1) ) {
|
|
mouse_left_pressed++;
|
|
}
|
|
}
|
|
else {
|
|
if ( (flags & MOUSE_LEFT_BUTTON) && (set == 0) ){
|
|
mouse_left_up++;
|
|
}
|
|
}
|
|
|
|
if ( !(mouse_flags & MOUSE_RIGHT_BUTTON) ) {
|
|
|
|
if ( (flags & MOUSE_RIGHT_BUTTON) && (set == 1) ){
|
|
mouse_right_pressed++;
|
|
}
|
|
}
|
|
else {
|
|
if ( (flags & MOUSE_RIGHT_BUTTON) && (set == 0) ){
|
|
mouse_right_up++;
|
|
}
|
|
}
|
|
|
|
if ( !(mouse_flags & MOUSE_MIDDLE_BUTTON) ) {
|
|
|
|
if ( (flags & MOUSE_MIDDLE_BUTTON) && (set == 1) ){
|
|
mouse_middle_pressed++;
|
|
}
|
|
}
|
|
else {
|
|
if ( (flags & MOUSE_MIDDLE_BUTTON) && (set == 0) ){
|
|
mouse_middle_up++;
|
|
}
|
|
}
|
|
|
|
if ( set ){
|
|
mouse_flags |= flags;
|
|
} else {
|
|
mouse_flags &= ~flags;
|
|
}
|
|
|
|
LEAVE_CRITICAL_SECTION(mouse_lock);
|
|
|
|
Script_system.SetHookVar("MouseButton", 'i', &flags);
|
|
|
|
//WMC - On Mouse Pressed and On Mouse Released hooks
|
|
if (set == 1)
|
|
{
|
|
Script_system.RunCondition(CHA_MOUSEPRESSED);
|
|
}
|
|
else if (set == 0)
|
|
{
|
|
Script_system.RunCondition(CHA_MOUSERELEASED);
|
|
}
|
|
|
|
Script_system.RemHookVar("MouseButton");
|
|
}
|
|
|
|
void mouse_flush()
|
|
{
|
|
if (!mouse_inited)
|
|
return;
|
|
|
|
mouse_eval_deltas();
|
|
Mouse_dx = Mouse_dy = Mouse_dz = 0;
|
|
ENTER_CRITICAL_SECTION( mouse_lock );
|
|
mouse_left_pressed = 0;
|
|
mouse_right_pressed = 0;
|
|
mouse_middle_pressed = 0;
|
|
mouse_flags = 0;
|
|
LEAVE_CRITICAL_SECTION( mouse_lock );
|
|
}
|
|
|
|
int mouse_down_count(int n, int reset_count)
|
|
{
|
|
int tmp = 0;
|
|
if ( !mouse_inited ) return 0;
|
|
|
|
if ( (n < LOWEST_MOUSE_BUTTON) || (n > HIGHEST_MOUSE_BUTTON)) return 0;
|
|
|
|
ENTER_CRITICAL_SECTION( mouse_lock );
|
|
|
|
switch (n) {
|
|
case MOUSE_LEFT_BUTTON:
|
|
tmp = mouse_left_pressed;
|
|
if ( reset_count ) {
|
|
mouse_left_pressed = 0;
|
|
}
|
|
break;
|
|
|
|
case MOUSE_RIGHT_BUTTON:
|
|
tmp = mouse_right_pressed;
|
|
if ( reset_count ) {
|
|
mouse_right_pressed = 0;
|
|
}
|
|
break;
|
|
|
|
case MOUSE_MIDDLE_BUTTON:
|
|
tmp = mouse_middle_pressed;
|
|
if ( reset_count ) {
|
|
mouse_middle_pressed = 0;
|
|
}
|
|
break;
|
|
} // end switch
|
|
|
|
LEAVE_CRITICAL_SECTION( mouse_lock );
|
|
|
|
return tmp;
|
|
}
|
|
|
|
// mouse_up_count() returns the number of times button n has gone from down to up
|
|
// since the last call
|
|
//
|
|
// parameters: n - button of mouse (see #define's in mouse.h)
|
|
//
|
|
int mouse_up_count(int n)
|
|
{
|
|
int tmp = 0;
|
|
if ( !mouse_inited ) return 0;
|
|
|
|
if ( (n < LOWEST_MOUSE_BUTTON) || (n > HIGHEST_MOUSE_BUTTON)) return 0;
|
|
|
|
ENTER_CRITICAL_SECTION( mouse_lock );
|
|
|
|
switch (n) {
|
|
case MOUSE_LEFT_BUTTON:
|
|
tmp = mouse_left_up;
|
|
mouse_left_up = 0;
|
|
break;
|
|
|
|
case MOUSE_RIGHT_BUTTON:
|
|
tmp = mouse_right_up;
|
|
mouse_right_up = 0;
|
|
break;
|
|
|
|
case MOUSE_MIDDLE_BUTTON:
|
|
tmp = mouse_middle_up;
|
|
mouse_middle_up = 0;
|
|
break;
|
|
|
|
default:
|
|
Assert(0); // can't happen
|
|
break;
|
|
} // end switch
|
|
|
|
LEAVE_CRITICAL_SECTION( mouse_lock );
|
|
|
|
return tmp;
|
|
}
|
|
|
|
// returns 1 if mouse button btn is down, 0 otherwise
|
|
|
|
int mouse_down(int btn)
|
|
{
|
|
int tmp;
|
|
if ( !mouse_inited ) return 0;
|
|
|
|
if ( (btn < LOWEST_MOUSE_BUTTON) || (btn > HIGHEST_MOUSE_BUTTON)) return 0;
|
|
|
|
|
|
ENTER_CRITICAL_SECTION( mouse_lock );
|
|
|
|
|
|
if ( mouse_flags & btn )
|
|
tmp = 1;
|
|
else
|
|
tmp = 0;
|
|
|
|
LEAVE_CRITICAL_SECTION( mouse_lock );
|
|
|
|
return tmp;
|
|
}
|
|
|
|
// returns the fraction of time btn has been down since last call
|
|
// (currently returns 1 if buttons is down, 0 otherwise)
|
|
//
|
|
float mouse_down_time(int btn)
|
|
{
|
|
float tmp;
|
|
if ( !mouse_inited ) return 0.0f;
|
|
|
|
if ( (btn < LOWEST_MOUSE_BUTTON) || (btn > HIGHEST_MOUSE_BUTTON)) return 0.0f;
|
|
|
|
ENTER_CRITICAL_SECTION( mouse_lock );
|
|
|
|
if ( mouse_flags & btn )
|
|
tmp = 1.0f;
|
|
else
|
|
tmp = 0.0f;
|
|
|
|
LEAVE_CRITICAL_SECTION( mouse_lock );
|
|
|
|
return tmp;
|
|
}
|
|
|
|
void mouse_get_delta(int *dx, int *dy, int *dz)
|
|
{
|
|
if (dx)
|
|
*dx = Mouse_dx;
|
|
if (dy)
|
|
*dy = Mouse_dy;
|
|
if (dz)
|
|
*dz = Mouse_dz;
|
|
}
|
|
|
|
// Forces the actual windows cursor to be at (x,y). This may be independent of our tracked (x,y) mouse pos.
|
|
void mouse_force_pos(int x, int y)
|
|
{
|
|
if (os_foreground()) { // only mess with windows's mouse if we are in control of it
|
|
POINT pnt;
|
|
|
|
pnt.x = x;
|
|
pnt.y = y;
|
|
setWindowMousePos(&pnt);
|
|
}
|
|
}
|
|
|
|
#include "gamesequence/gamesequence.h"
|
|
|
|
// change in mouse position since last call
|
|
void mouse_eval_deltas()
|
|
{
|
|
static int old_x = 0;
|
|
static int old_y = 0;
|
|
int tmp_x, tmp_y, cx, cy;
|
|
|
|
Mouse_dx = Mouse_dy = Mouse_dz = 0;
|
|
if (!mouse_inited)
|
|
return;
|
|
|
|
#ifdef WIN32
|
|
if (Mouse_mode == MOUSE_MODE_DI) {
|
|
mouse_eval_deltas_di();
|
|
return;
|
|
}
|
|
#endif
|
|
|
|
cx = gr_screen.max_w / 2;
|
|
cy = gr_screen.max_h / 2;
|
|
|
|
ENTER_CRITICAL_SECTION( mouse_lock );
|
|
|
|
POINT pnt;
|
|
getWindowMousePos(&pnt);
|
|
tmp_x = pnt.x;
|
|
tmp_y = pnt.y;
|
|
|
|
Mouse_dx = tmp_x - old_x;
|
|
Mouse_dy = tmp_y - old_y;
|
|
Mouse_dz = 0;
|
|
|
|
// Speeds up the menu mouse on higher resolutions. The check for a
|
|
// visible mouse should eliminate any possible gameplay changes.
|
|
if ( mouse_is_visible() ) {
|
|
gr_resize_screen_pos( &Mouse_dx, &Mouse_dy );
|
|
}
|
|
|
|
if (Keep_mouse_centered && Mouse_hidden) {
|
|
if (Mouse_dx || Mouse_dy)
|
|
mouse_force_pos(cx, cy);
|
|
|
|
old_x = cx;
|
|
old_y = cy;
|
|
|
|
} else {
|
|
old_x = tmp_x;
|
|
old_y = tmp_y;
|
|
}
|
|
|
|
LEAVE_CRITICAL_SECTION( mouse_lock );
|
|
|
|
//WMC - For On Mouse Moved trigger
|
|
if(Mouse_dx != 0 || Mouse_dy != 0)
|
|
{
|
|
Script_system.RunCondition(CHA_MOUSEMOVED);
|
|
}
|
|
}
|
|
|
|
#ifdef WIN32
|
|
#include "directx/vdinput.h"
|
|
|
|
static LPDIRECTINPUT Di_mouse_obj = NULL;
|
|
static LPDIRECTINPUTDEVICE Di_mouse = NULL;
|
|
|
|
void mouse_eval_deltas_di()
|
|
{
|
|
int repeat = 1;
|
|
HRESULT hr = 0;
|
|
DIMOUSESTATE mouse_state;
|
|
|
|
Mouse_dx = Mouse_dy = Mouse_dz = 0;
|
|
if (!Di_mouse_inited)
|
|
return;
|
|
|
|
repeat = 1;
|
|
memset(&mouse_state, 0, sizeof(mouse_state));
|
|
while (repeat) {
|
|
repeat = 0;
|
|
|
|
hr = Di_mouse->GetDeviceState(sizeof(mouse_state), &mouse_state);
|
|
if ((hr == DIERR_INPUTLOST) || (hr == DIERR_NOTACQUIRED)) {
|
|
// DirectInput is telling us that the input stream has
|
|
// been interrupted. We aren't tracking any state
|
|
// between polls, so we don't have any special reset
|
|
// that needs to be done. We just re-acquire and
|
|
// try again.
|
|
Sleep(500); // Pause a half second...
|
|
hr = Di_mouse->Acquire();
|
|
if (SUCCEEDED(hr))
|
|
repeat = 1;
|
|
}
|
|
}
|
|
|
|
if (SUCCEEDED(hr)) {
|
|
Mouse_dx = (int) mouse_state.lX;
|
|
Mouse_dy = (int) mouse_state.lY;
|
|
Mouse_dz = (int) mouse_state.lZ;
|
|
|
|
} else {
|
|
Mouse_dx = Mouse_dy = Mouse_dz = 0;
|
|
}
|
|
|
|
// Speeds up the menu mouse on higher resolutions. The check for a
|
|
// visible mouse should eliminate any possible gameplay changes.
|
|
if ( mouse_is_visible() ) {
|
|
gr_resize_screen_pos( &Mouse_dx, &Mouse_dy );
|
|
}
|
|
|
|
Mouse_x += Mouse_dx;
|
|
Mouse_y += Mouse_dy;
|
|
|
|
if (Mouse_x < 0)
|
|
Mouse_x = 0;
|
|
|
|
if (Mouse_y < 0)
|
|
Mouse_y = 0;
|
|
|
|
if (Mouse_x >= gr_screen.max_w)
|
|
Mouse_x = gr_screen.max_w - 1;
|
|
|
|
if (Mouse_y >= gr_screen.max_h)
|
|
Mouse_y = gr_screen.max_h - 1;
|
|
|
|
// keep the mouse inside our window so we don't switch applications or anything (debug bug people reported?)
|
|
// JH: Dang! This makes the mouse readings in DirectInput act screwy!
|
|
// mouse_force_pos(gr_screen.max_w / 2, gr_screen.max_h / 2);
|
|
}
|
|
#endif //#ifdef WIN32
|
|
|
|
int mouse_get_pos(int *xpos, int *ypos)
|
|
{
|
|
int flags;
|
|
|
|
if (!Mouse_in_focus)
|
|
{
|
|
if (xpos)
|
|
*xpos = Mouse_x;
|
|
|
|
if (ypos)
|
|
*ypos = Mouse_y;
|
|
|
|
return 0;
|
|
}
|
|
|
|
if (Mouse_mode == MOUSE_MODE_DI) {
|
|
if (xpos)
|
|
*xpos = Mouse_x;
|
|
|
|
if (ypos)
|
|
*ypos = Mouse_y;
|
|
|
|
return mouse_flags;
|
|
}
|
|
|
|
if (!mouse_inited) {
|
|
*xpos = *ypos = 0;
|
|
return 0;
|
|
}
|
|
|
|
POINT pnt;
|
|
getWindowMousePos(&pnt);
|
|
|
|
// EnterCriticalSection(&mouse_lock);
|
|
|
|
flags = mouse_flags;
|
|
Mouse_x = pnt.x;
|
|
Mouse_y = pnt.y;
|
|
|
|
// LeaveCriticalSection(&mouse_lock);
|
|
|
|
if (Mouse_x < 0){
|
|
Mouse_x = 0;
|
|
}
|
|
|
|
if (Mouse_y < 0){
|
|
Mouse_y = 0;
|
|
}
|
|
|
|
if (Mouse_x >= gr_screen.max_w){
|
|
Mouse_x = gr_screen.max_w - 1;
|
|
}
|
|
|
|
if (Mouse_y >= gr_screen.max_h){
|
|
Mouse_y = gr_screen.max_h - 1;
|
|
}
|
|
|
|
if (xpos){
|
|
*xpos = Mouse_x;
|
|
}
|
|
|
|
if (ypos){
|
|
*ypos = Mouse_y;
|
|
}
|
|
|
|
return flags;
|
|
}
|
|
|
|
int mouse_get_pos_unscaled( int *xpos, int *ypos )
|
|
{
|
|
int flags = mouse_get_pos( xpos, ypos );
|
|
|
|
gr_unsize_screen_pos( (xpos) ? xpos : NULL, (ypos) ? ypos : NULL, NULL, NULL, GR_RESIZE_MENU );
|
|
|
|
return flags;
|
|
}
|
|
|
|
void mouse_get_real_pos(int *mx, int *my)
|
|
{
|
|
if (Mouse_mode == MOUSE_MODE_DI) {
|
|
*mx = Mouse_x;
|
|
*my = Mouse_y;
|
|
return;
|
|
}
|
|
|
|
POINT pnt;
|
|
getWindowMousePos(&pnt);
|
|
|
|
*mx = pnt.x;
|
|
*my = pnt.y;
|
|
}
|
|
|
|
void mouse_set_pos(int xpos, int ypos)
|
|
{
|
|
if (Mouse_mode == MOUSE_MODE_DI) {
|
|
Mouse_x = xpos;
|
|
Mouse_y = ypos;
|
|
return;
|
|
}
|
|
|
|
if ((xpos != Mouse_x) || (ypos != Mouse_y)){
|
|
mouse_force_pos(xpos, ypos);
|
|
}
|
|
}
|
|
|
|
#ifdef WIN32
|
|
int di_init()
|
|
{
|
|
HRESULT hr;
|
|
|
|
if (Mouse_mode == MOUSE_MODE_WIN){
|
|
return 0;
|
|
}
|
|
|
|
Di_mouse_inited = 0;
|
|
hr = DirectInputCreate(GetModuleHandle(NULL), DIRECTINPUT_VERSION, &Di_mouse_obj, NULL);
|
|
if (FAILED(hr)) {
|
|
hr = DirectInputCreate(GetModuleHandle(NULL), 0x300, &Di_mouse_obj, NULL);
|
|
if (FAILED(hr)) {
|
|
mprintf(( "DirectInputCreate() failed!\n" ));
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
hr = Di_mouse_obj->CreateDevice(GUID_SysMouse, &Di_mouse, NULL);
|
|
if (FAILED(hr)) {
|
|
mprintf(( "CreateDevice() failed!\n" ));
|
|
return FALSE;
|
|
}
|
|
|
|
hr = Di_mouse->SetDataFormat(&c_dfDIMouse);
|
|
if (FAILED(hr)) {
|
|
mprintf(( "SetDataFormat() failed!\n" ));
|
|
return FALSE;
|
|
}
|
|
|
|
hr = Di_mouse->SetCooperativeLevel((HWND)os_get_window(), DISCL_NONEXCLUSIVE | DISCL_FOREGROUND);
|
|
if (FAILED(hr)) {
|
|
mprintf(( "SetCooperativeLevel() failed!\n" ));
|
|
return FALSE;
|
|
}
|
|
/*
|
|
DIPROPDWORD hdr;
|
|
|
|
// Turn on buffering
|
|
hdr.diph.dwSize = sizeof(DIPROPDWORD);
|
|
hdr.diph.dwHeaderSize = sizeof(DIPROPHEADER);
|
|
hdr.diph.dwObj = 0;
|
|
hdr.diph.dwHow = DIPH_DEVICE; // Apply to entire device
|
|
hdr.dwData = 16; //MAX_BUFFERED_KEYBOARD_EVENTS;
|
|
|
|
hr = Di_mouse->SetProperty( DIPROP_BUFFERSIZE, &hdr.diph );
|
|
if (FAILED(hr)) {
|
|
mprintf(( "SetProperty DIPROP_BUFFERSIZE failed\n" ));
|
|
return FALSE;
|
|
}
|
|
|
|
Di_event = CreateEvent( NULL, FALSE, FALSE, NULL );
|
|
Assert(Di_event != NULL);
|
|
|
|
hr = Di_mouse->SetEventNotification(Di_event);
|
|
if (FAILED(hr)) {
|
|
mprintf(( "SetEventNotification failed\n" ));
|
|
return FALSE;
|
|
}
|
|
*/
|
|
Di_mouse->Acquire();
|
|
|
|
Di_mouse_inited = 1;
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
void di_cleanup()
|
|
{
|
|
// Destroy any lingering IDirectInputDevice object.
|
|
if (Di_mouse) {
|
|
// Unacquire the device one last time just in case we got really confused
|
|
// and tried to exit while the device is still acquired.
|
|
Di_mouse->Unacquire();
|
|
|
|
Di_mouse->Release();
|
|
Di_mouse = NULL;
|
|
}
|
|
|
|
// Destroy any lingering IDirectInput object.
|
|
if (Di_mouse_obj) {
|
|
Di_mouse_obj->Release();
|
|
Di_mouse_obj = NULL;
|
|
}
|
|
|
|
Di_mouse_inited = 0;
|
|
}
|
|
#endif //ifdef WIN32
|
|
|
|
// portable routine to get the mouse position, relative
|
|
// to current window
|
|
void getWindowMousePos(POINT * pt)
|
|
{
|
|
Assert(pt != NULL);
|
|
|
|
#ifdef _WIN32
|
|
GetCursorPos(pt);
|
|
ScreenToClient((HWND)os_get_window(), pt);
|
|
#else
|
|
SDL_GetMouseState(&pt->x, &pt->y);
|
|
#endif
|
|
}
|
|
|
|
|
|
// portable routine to get the mouse position, relative
|
|
// to current window
|
|
void setWindowMousePos(POINT * pt)
|
|
{
|
|
Assert(pt != NULL);
|
|
|
|
#ifdef _WIN32
|
|
ClientToScreen((HWND) os_get_window(), pt);
|
|
SetCursorPos(pt->x, pt->y);
|
|
#else
|
|
SDL_WarpMouse(pt->x, pt->y);
|
|
#endif
|
|
}
|