Mirrored_Repos/LookingGlass
1
0
Fork 0
mirror of https://github.com/gnif/LookingGlass.git synced 2024-11-22 13:37:22 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

[client] all: properly support guest rotation

Browse Source 
If the guest has it's output rotated (ie, landscape) we must rotate and
translate the pointer draw location, as well as all the translations of
cursor coordinate spaces based on the rotation, along with any local
rotations that may also be applied.
This commit is contained in:
Geoffrey McRae 2021-01-19 02:44:56 +11:00
parent 733bbf5153
commit 8a1578230f
9 changed files with 340 additions and 152 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
client/include/interface/renderer.h
View File

@ -66,6 +66,10 @@ typedef enum LG_RendererRotate
}
LG_RendererRotate;
// kept out of the enum so gcc doesn't warn when it's missing from a switch
// statement.
#define LG_ROTATE_MAX (LG_ROTATE_270+1)
typedef struct LG_RendererFormat
{
FrameType type; // frame type
@ -74,7 +78,7 @@ typedef struct LG_RendererFormat
unsigned int stride; // scanline width (zero if compresed)
unsigned int pitch; // scanline bytes (or compressed size)
unsigned int bpp; // bits per pixel (zero if compressed)
LG_RendererRotate rotate; // output rotation
LG_RendererRotate rotate; // guest rotation
}
LG_RendererFormat;
@ -107,13 +111,14 @@ typedef bool (* LG_RendererInitialize )(void * opaque, Uint32 * sdlFla
typedef void (* LG_RendererDeInitialize )(void * opaque);
typedef bool (* LG_RendererSupports )(void * opaque, LG_RendererSupport support);
typedef void (* LG_RendererOnRestart )(void * opaque);
typedef void (* LG_RendererOnResize )(void * opaque, const int width, const int height, const LG_RendererRect destRect);
typedef bool (* LG_RendererOnMouseShape )(void * opaque, const LG_RendererCursor cursor, const int width, const int height, const LG_RendererRotate rotate, const int pitch, const uint8_t * data);
typedef void (* LG_RendererOnResize )(void * opaque, const int width, const int height, const LG_RendererRect destRect, LG_RendererRotate rotate);
typedef bool (* LG_RendererOnMouseShape )(void * opaque, const LG_RendererCursor cursor, const int width, const int height, const int pitch, const uint8_t * data);
typedef bool (* LG_RendererOnMouseEvent )(void * opaque, const bool visible , const int x, const int y);
typedef bool (* LG_RendererOnFrameFormat)(void * opaque, const LG_RendererFormat format, bool useDMA);
typedef bool (* LG_RendererOnFrame )(void * opaque, const FrameBuffer * frame, int dmaFD);
typedef void (* LG_RendererOnAlert )(void * opaque, const LG_MsgAlert alert, const char * message, bool ** closeFlag);
typedef bool (* LG_RendererRender )(void * opaque, SDL_Window *window);
typedef bool (* LG_RendererRenderStartup)(void * opaque, SDL_Window *window);
typedef bool (* LG_RendererRender )(void * opaque, SDL_Window *window, LG_RendererRotate rotate);
typedef void (* LG_RendererUpdateFPS )(void * opaque, const float avgUPS, const float avgFPS);
typedef struct LG_Renderer
@ -132,7 +137,7 @@ typedef struct LG_Renderer
LG_RendererOnFrameFormat on_frame_format;
LG_RendererOnFrame on_frame;
LG_RendererOnAlert on_alert;
LG_RendererRender render_startup;
LG_RendererRenderStartup render_startup;
LG_RendererRender render;
LG_RendererUpdateFPS update_fps;
}

10
client/renderers/EGL/cursor.c
View File

@ -57,7 +57,7 @@ struct EGL_Cursor
// cursor state
bool visible;
float x, y, w, h;
int rotate;
LG_RendererRotate rotate;
int cbMode;
struct CursorTex norm;
@ -170,8 +170,7 @@ void egl_cursor_free(EGL_Cursor ** cursor)
}
bool egl_cursor_set_shape(EGL_Cursor * cursor, const LG_RendererCursor type,
const int width, const int height, const LG_RendererRotate rotate,
const int stride, const uint8_t * data)
const int width, const int height, const int stride, const uint8_t * data)
{
LG_LOCK(cursor->lock);
@ -179,7 +178,6 @@ bool egl_cursor_set_shape(EGL_Cursor * cursor, const LG_RendererCursor type,
cursor->width = width;
cursor->height = (type == LG_CURSOR_MONOCHROME ? height / 2 : height);
cursor->stride = stride;
cursor->rotate = rotate;
const size_t size = height * stride;
if (size > cursor->dataSize)
@ -217,7 +215,7 @@ void egl_cursor_set_state(EGL_Cursor * cursor, const bool visible, const float x
cursor->y = y;
}
void egl_cursor_render(EGL_Cursor * cursor)
void egl_cursor_render(EGL_Cursor * cursor, LG_RendererRotate rotate)
{
if (!cursor->visible)
return;
@ -270,6 +268,8 @@ void egl_cursor_render(EGL_Cursor * cursor)
LG_UNLOCK(cursor->lock);
}
cursor->rotate = rotate;
glEnable(GL_BLEND);
switch(cursor->type)
{

10
client/renderers/EGL/cursor.h
View File

@ -33,10 +33,12 @@ bool egl_cursor_set_shape(
const LG_RendererCursor type,
const int width,
const int height,
const LG_RendererRotate rotate,
const int stride,
const uint8_t * data);
void egl_cursor_set_size (EGL_Cursor * cursor, const float x, const float y);
void egl_cursor_set_state(EGL_Cursor * cursor, const bool visible, const float x, const float y);
void egl_cursor_render (EGL_Cursor * cursor);
void egl_cursor_set_size(EGL_Cursor * cursor, const float x, const float y);
void egl_cursor_set_state(EGL_Cursor * cursor, const bool visible,
const float x, const float y);
void egl_cursor_render(EGL_Cursor * cursor, LG_RendererRotate rotate);

7
client/renderers/EGL/desktop.c
View File

@ -204,7 +204,6 @@ bool egl_desktop_setup(EGL_Desktop * desktop, const LG_RendererFormat format, bo
desktop->width = format.width;
desktop->height = format.height;
desktop->rotate = format.rotate;
if (!egl_texture_setup(
desktop->texture,
@ -246,7 +245,9 @@ bool egl_desktop_update(EGL_Desktop * desktop, const FrameBuffer * frame, int dm
return true;
}
bool egl_desktop_render(EGL_Desktop * desktop, const float x, const float y, const float scaleX, const float scaleY, const bool nearest)
bool egl_desktop_render(EGL_Desktop * desktop, const float x, const float y,
const float scaleX, const float scaleY, const bool nearest,
LG_RendererRotate rotate)
{
if (!desktop->shader)
return false;
@ -254,7 +255,7 @@ bool egl_desktop_render(EGL_Desktop * desktop, const float x, const float y, con
const struct DesktopShader * shader = desktop->shader;
egl_shader_use(shader->shader);
glUniform4f(shader->uDesktopPos , x, y, scaleX, scaleY);
glUniform1i(shader->uRotate , desktop->rotate);
glUniform1i(shader->uRotate , rotate);
glUniform1i(shader->uNearest , nearest ? 1 : 0);
glUniform2f(shader->uDesktopSize, desktop->width, desktop->height);

4
client/renderers/EGL/desktop.h
View File

@ -31,4 +31,6 @@ void egl_desktop_free(EGL_Desktop ** desktop);
bool egl_desktop_setup (EGL_Desktop * desktop, const LG_RendererFormat format, bool useDMA);
bool egl_desktop_update(EGL_Desktop * desktop, const FrameBuffer * frame, int dmaFd);
bool egl_desktop_render(EGL_Desktop * desktop, const float x, const float y, const float scaleX, const float scaleY, const bool nearest);
bool egl_desktop_render(EGL_Desktop * desktop, const float x, const float y,
const float scaleX, const float scaleY, const bool nearest,
LG_RendererRotate rotate);

116
client/renderers/EGL/egl.c
View File

@ -82,6 +82,7 @@ struct Inst
int width, height;
LG_RendererRect destRect;
LG_RendererRotate rotate; //client side rotation
float translateX , translateY;
float scaleX , scaleY;
@ -263,12 +264,83 @@ void egl_on_restart(void * opaque)
this->start = false;
}
void egl_on_resize(void * opaque, const int width, const int height, const LG_RendererRect destRect)
static void egl_calc_mouse_size(struct Inst * this)
{
int w, h;
switch(this->format.rotate)
{
case LG_ROTATE_0:
case LG_ROTATE_180:
this->mouseScaleX = 2.0f / this->format.width;
this->mouseScaleY = 2.0f / this->format.height;
w = this->format.width;
h = this->format.height;
break;
case LG_ROTATE_90:
case LG_ROTATE_270:
this->mouseScaleX = 2.0f / this->format.height;
this->mouseScaleY = 2.0f / this->format.width;
w = this->format.height;
h = this->format.width;
break;
}
switch((this->format.rotate + this->rotate) % LG_ROTATE_MAX)
{
case LG_ROTATE_0:
case LG_ROTATE_180:
egl_cursor_set_size(this->cursor,
(this->mouseWidth * (1.0f / w)) * this->scaleX,
(this->mouseHeight * (1.0f / h)) * this->scaleY
);
break;
case LG_ROTATE_90:
case LG_ROTATE_270:
egl_cursor_set_size(this->cursor,
(this->mouseWidth * (1.0f / w)) * this->scaleY,
(this->mouseHeight * (1.0f / h)) * this->scaleX
);
break;
}
}
static void egl_calc_mouse_state(struct Inst * this)
{
switch((this->format.rotate + this->rotate) % LG_ROTATE_MAX)
{
case LG_ROTATE_0:
case LG_ROTATE_180:
egl_cursor_set_state(
this->cursor,
this->cursorVisible,
(((float)this->cursorX * this->mouseScaleX) - 1.0f) * this->scaleX,
(((float)this->cursorY * this->mouseScaleY) - 1.0f) * this->scaleY
);
break;
case LG_ROTATE_90:
case LG_ROTATE_270:
egl_cursor_set_state(
this->cursor,
this->cursorVisible,
(((float)this->cursorX * this->mouseScaleX) - 1.0f) * this->scaleY,
(((float)this->cursorY * this->mouseScaleY) - 1.0f) * this->scaleX
);
break;
}
}
void egl_on_resize(void * opaque, const int width, const int height,
const LG_RendererRect destRect, LG_RendererRotate rotate)
{
struct Inst * this = (struct Inst *)opaque;
this->width = width;
this->height = height;
this->rotate = rotate;
memcpy(&this->destRect, &destRect, sizeof(LG_RendererRect));
glViewport(0, 0, width, height);
@ -281,31 +353,22 @@ void egl_on_resize(void * opaque, const int width, const int height, const LG_Re
this->scaleY = (float)destRect.h / (float)height;
}
this->mouseScaleX = 2.0f / this->format.width ;
this->mouseScaleY = 2.0f / this->format.height;
egl_cursor_set_size(this->cursor,
(this->mouseWidth * (1.0f / this->format.width )) * this->scaleX,
(this->mouseHeight * (1.0f / this->format.height)) * this->scaleY
);
egl_calc_mouse_size(this);
this->splashRatio = (float)width / (float)height;
this->screenScaleX = 1.0f / width;
this->screenScaleY = 1.0f / height;
egl_cursor_set_state(
this->cursor,
this->cursorVisible,
(((float)this->cursorX * this->mouseScaleX) - 1.0f) * this->scaleX,
(((float)this->cursorY * this->mouseScaleY) - 1.0f) * this->scaleY
);
egl_calc_mouse_state(this);
}
bool egl_on_mouse_shape(void * opaque, const LG_RendererCursor cursor,
const int width, const int height, const LG_RendererRotate rotate,
const int width, const int height,
const int pitch, const uint8_t * data)
{
struct Inst * this = (struct Inst *)opaque;
if (!egl_cursor_set_shape(this->cursor, cursor, width, height, rotate, pitch, data))
if (!egl_cursor_set_shape(this->cursor, cursor, width, height, pitch, data))
{
DEBUG_ERROR("Failed to update the cursor shape");
return false;
@ -313,10 +376,7 @@ bool egl_on_mouse_shape(void * opaque, const LG_RendererCursor cursor,
this->mouseWidth = width;
this->mouseHeight = height;
egl_cursor_set_size(this->cursor,
(this->mouseWidth * (1.0f / this->format.width )) * this->scaleX,
(this->mouseHeight * (1.0f / this->format.height)) * this->scaleY
);
egl_calc_mouse_size(this);
return true;
}
@ -327,14 +387,7 @@ bool egl_on_mouse_event(void * opaque, const bool visible, const int x, const in
this->cursorVisible = visible;
this->cursorX = x;
this->cursorY = y;
egl_cursor_set_state(
this->cursor,
this->cursorVisible,
(((float)this->cursorX * this->mouseScaleX) - 1.0f) * this->scaleX,
(((float)this->cursorY * this->mouseScaleY) - 1.0f) * this->scaleY
);
egl_calc_mouse_state(this);
return true;
}
@ -621,7 +674,7 @@ bool egl_render_startup(void * opaque, SDL_Window * window)
return true;
}
bool egl_render(void * opaque, SDL_Window * window)
bool egl_render(void * opaque, SDL_Window * window, LG_RendererRotate rotate)
{
struct Inst * this = (struct Inst *)opaque;
@ -631,7 +684,8 @@ bool egl_render(void * opaque, SDL_Window * window)
if (this->start && egl_desktop_render(this->desktop,
this->translateX, this->translateY,
this->scaleX , this->scaleY ,
this->useNearest))
this->useNearest,
rotate))
{
if (!this->waitFadeTime)
{
@ -640,7 +694,9 @@ bool egl_render(void * opaque, SDL_Window * window)
else
this->waitDone = true;
}
egl_cursor_render(this->cursor);
egl_cursor_render(this->cursor,
(this->format.rotate + rotate) % LG_ROTATE_MAX);
}
if (!this->waitDone)

8
client/renderers/OpenGL/opengl.c
View File

@ -316,7 +316,8 @@ void opengl_on_restart(void * opaque)
this->waiting = true;
}
void opengl_on_resize(void * opaque, const int width, const int height, const LG_RendererRect destRect)
void opengl_on_resize(void * opaque, const int width, const int height,
const LG_RendererRect destRect, LG_RendererRotate rotate)
{
struct Inst * this = (struct Inst *)opaque;
@ -346,7 +347,8 @@ void opengl_on_resize(void * opaque, const int width, const int height, const LG
}
}
bool opengl_on_mouse_shape(void * opaque, const LG_RendererCursor cursor, const int width, const int height, const LG_RendererRotate rotate, const int pitch, const uint8_t * data)
bool opengl_on_mouse_shape(void * opaque, const LG_RendererCursor cursor,
const int width, const int height, const int pitch, const uint8_t * data)
{
struct Inst * this = (struct Inst *)opaque;
if (!this)
@ -562,7 +564,7 @@ bool opengl_render_startup(void * opaque, SDL_Window * window)
return true;
}
bool opengl_render(void * opaque, SDL_Window * window)
bool opengl_render(void * opaque, SDL_Window * window, LG_RendererRotate rotate)
{
struct Inst * this = (struct Inst *)opaque;
if (!this)

201
client/src/main.c
View File

@ -173,23 +173,41 @@ static void alignToGuest(void)
static void updatePositionInfo(void)
{
if (g_state.haveSrcSize)
if (!g_state.haveSrcSize)
goto done;
float srcW;
float srcH;
switch(params.winRotate)
{
case LG_ROTATE_0:
case LG_ROTATE_180:
srcW = g_state.srcSize.x;
srcH = g_state.srcSize.y;
break;
case LG_ROTATE_90:
case LG_ROTATE_270:
srcW = g_state.srcSize.y;
srcH = g_state.srcSize.x;
break;
}
if (params.keepAspect)
{
const float srcAspect = (float)g_state.srcSize.y / (float)g_state.srcSize.x;
const float srcAspect = srcH / srcW;
const float wndAspect = (float)g_state.windowH / (float)g_state.windowW;
bool force = true;
if (params.dontUpscale &&
g_state.srcSize.x <= g_state.windowW &&
g_state.srcSize.y <= g_state.windowH)
srcW <= g_state.windowW &&
srcH <= g_state.windowH)
{
force = false;
g_state.dstRect.w = g_state.srcSize.x;
g_state.dstRect.h = g_state.srcSize.y;
g_state.dstRect.x = g_state.windowCX - g_state.srcSize.x / 2;
g_state.dstRect.y = g_state.windowCY - g_state.srcSize.y / 2;
g_state.dstRect.w = srcW;
g_state.dstRect.h = srcH;
g_state.dstRect.x = g_state.windowCX - srcW / 2;
g_state.dstRect.y = g_state.windowCY - srcH / 2;
}
else
if ((int)(wndAspect * 1000) == (int)(srcAspect * 1000))
@ -232,15 +250,15 @@ static void updatePositionInfo(void)
g_state.dstRect.valid = true;
g_cursor.useScale = (
g_state.srcSize.y != g_state.dstRect.h ||
g_state.srcSize.x != g_state.dstRect.w ||
srcH != g_state.dstRect.h ||
srcW != g_state.dstRect.w ||
g_cursor.guest.dpiScale != 100);
g_cursor.scale.x = (float)g_state.srcSize.y / (float)g_state.dstRect.h;
g_cursor.scale.y = (float)g_state.srcSize.x / (float)g_state.dstRect.w;
g_cursor.scale.x = (float)srcH / (float)g_state.dstRect.h;
g_cursor.scale.y = (float)srcW / (float)g_state.dstRect.w;
g_cursor.dpiScale = g_cursor.guest.dpiScale / 100.0f;
}
done:
atomic_fetch_add(&g_state.lgrResize, 1);
}
@ -274,11 +292,12 @@ static int renderThread(void * unused)
if (resize)
{
if (g_state.lgr)
g_state.lgr->on_resize(g_state.lgrData, g_state.windowW, g_state.windowH, g_state.dstRect);
g_state.lgr->on_resize(g_state.lgrData, g_state.windowW, g_state.windowH,
g_state.dstRect, params.winRotate);
atomic_compare_exchange_weak(&g_state.lgrResize, &resize, 0);
}
if (!g_state.lgr->render(g_state.lgrData, g_state.window))
if (!g_state.lgr->render(g_state.lgrData, g_state.window, params.winRotate))
break;
if (params.showFPS)
@ -430,7 +449,6 @@ static int cursorThread(void * unused)
cursorType,
cursor->width,
cursor->height,
params.winRotate,
cursor->pitch,
data)
)
@ -568,6 +586,15 @@ static int frameThread(void * unused)
lgrFormat.stride = frame->stride;
lgrFormat.pitch = frame->pitch;
switch(frame->rotation)
{
case FRAME_ROT_0 : lgrFormat.rotate = LG_ROTATE_0 ; break;
case FRAME_ROT_90 : lgrFormat.rotate = LG_ROTATE_90 ; break;
case FRAME_ROT_180: lgrFormat.rotate = LG_ROTATE_180; break;
case FRAME_ROT_270: lgrFormat.rotate = LG_ROTATE_270; break;
}
g_state.rotate = lgrFormat.rotate;
bool error = false;
switch(frame->type)
{
@ -599,12 +626,11 @@ static int frameThread(void * unused)
formatValid = true;
formatVer = frame->formatVer;
DEBUG_INFO("Format: %s %ux%u %u %u",
DEBUG_INFO("Format: %s %ux%u stride:%u pitch:%u rotation:%d",
FrameTypeStr[frame->type],
frame->width, frame->height,
frame->stride, frame->pitch);
lgrFormat.rotate = params.winRotate;
frame->stride, frame->pitch,
frame->rotation);
if (!g_state.lgr->on_frame_format(g_state.lgrData, lgrFormat, useDMA))
{
@ -1104,12 +1130,101 @@ void app_handleKeyRelease(int sc)
}
}
static void rotatePoint(struct DoublePoint *point)
{
double temp;
switch((g_state.rotate + params.winRotate) % LG_ROTATE_MAX)
{
case LG_ROTATE_0:
break;
case LG_ROTATE_90:
temp = point->x;
point->x = point->y;
point->y = -temp;
break;
case LG_ROTATE_180:
point->x = -point->x;
point->y = -point->y;
break;
case LG_ROTATE_270:
temp = point->x;
point->x = -point->y;
point->y = temp;
break;
}
}
static void guestCurToLocal(struct DoublePoint *local)
{
local->x = g_state.dstRect.x +
(g_cursor.guest.x + g_cursor.guest.hx) / g_cursor.scale.x;
local->y = g_state.dstRect.y +
(g_cursor.guest.y + g_cursor.guest.hy) / g_cursor.scale.y;
const struct DoublePoint point =
{
.x = g_cursor.guest.x + g_cursor.guest.hx,
.y = g_cursor.guest.y + g_cursor.guest.hy
};
switch((g_state.rotate + params.winRotate) % LG_ROTATE_MAX)
{
case LG_ROTATE_0:
local->x = (point.x / g_cursor.scale.x) + g_state.dstRect.x;
local->y = (point.y / g_cursor.scale.y) + g_state.dstRect.y;;
break;
case LG_ROTATE_90:
local->x = (g_state.dstRect.x + g_state.dstRect.w) -
point.y / g_cursor.scale.y;
local->y = (point.x / g_cursor.scale.x) + g_state.dstRect.y;
break;
case LG_ROTATE_180:
local->x = (g_state.dstRect.x + g_state.dstRect.w) -
point.x / g_cursor.scale.x;
local->y = (g_state.dstRect.y + g_state.dstRect.h) -
point.y / g_cursor.scale.y;
break;
case LG_ROTATE_270:
local->x = (point.y / g_cursor.scale.y) + g_state.dstRect.x;
local->y = (g_state.dstRect.y + g_state.dstRect.h) -
point.x / g_cursor.scale.x;
break;
}
}
inline static void localCurToGuest(struct DoublePoint *guest)
{
const struct DoublePoint point =
g_cursor.pos;
switch((g_state.rotate - params.winRotate) % LG_ROTATE_MAX)
{
case LG_ROTATE_0:
guest->x = (point.x - g_state.dstRect.x) * g_cursor.scale.x;
guest->y = (point.y - g_state.dstRect.y) * g_cursor.scale.y;
break;
case LG_ROTATE_90:
guest->x = (point.y - g_state.dstRect.y) * g_cursor.scale.y;
guest->y = (g_state.dstRect.w - point.x + g_state.dstRect.x)
* g_cursor.scale.x;
break;
case LG_ROTATE_180:
guest->x = (g_state.dstRect.w - point.x + g_state.dstRect.x)
* g_cursor.scale.x;
guest->y = (g_state.dstRect.h - point.y + g_state.dstRect.y)
* g_cursor.scale.y;
break;
case LG_ROTATE_270:
guest->x = (g_state.dstRect.h - point.y + g_state.dstRect.y)
* g_cursor.scale.y;
guest->y = (point.x - g_state.dstRect.x) * g_cursor.scale.x;
break;
}
}
void app_handleMouseNormal(double ex, double ey)
@ -1154,11 +1269,8 @@ void app_handleMouseNormal(double ex, double ey)
{
g_cursor.realign = false;
struct DoublePoint guest =
{
.x = (g_cursor.pos.x - g_state.dstRect.x) * g_cursor.scale.x,
.y = (g_cursor.pos.y - g_state.dstRect.y) * g_cursor.scale.y
};
struct DoublePoint guest;
localCurToGuest(&guest);
/* add the difference to the offset */
ex += guest.x - (g_cursor.guest.x + g_cursor.guest.hx);
@ -1174,23 +1286,29 @@ void app_handleMouseNormal(double ex, double ey)
(fabs(ex) > 100.0 / g_cursor.scale.x || fabs(ey) > 100.0 / g_cursor.scale.y))
testExit = false;
/* translate the guests position to our coordinate space */
struct DoublePoint local;
guestCurToLocal(&local);
/* if any buttons are held we should not allow exit to happen */
if (g_cursor.buttons)
testExit = false;
/* check if the move would push the cursor outside the guest's viewport */
if (testExit && (
local.x + ex < g_state.dstRect.x ||
local.y + ey < g_state.dstRect.y ||
local.x + ex >= g_state.dstRect.x + g_state.dstRect.w ||
local.y + ey >= g_state.dstRect.y + g_state.dstRect.h))
if (testExit)
{
local.x += ex;
local.y += ey;
/* translate the move to the guests orientation */
struct DoublePoint move = {.x = ex, .y = ey};
rotatePoint(&move);
/* translate the guests position to our coordinate space */
struct DoublePoint local;
guestCurToLocal(&local);
/* check if the move would push the cursor outside the guest's viewport */
if (
local.x + move.x < g_state.dstRect.x ||
local.y + move.y < g_state.dstRect.y ||
local.x + move.x >= g_state.dstRect.x + g_state.dstRect.w ||
local.y + move.y >= g_state.dstRect.y + g_state.dstRect.h)
{
local.x += move.x;
local.y += move.y;
const int tx = (local.x <= 0.0) ? floor(local.x) : ceil(local.x);
const int ty = (local.y <= 0.0) ? floor(local.y) : ceil(local.y);
@ -1211,6 +1329,7 @@ void app_handleMouseNormal(double ex, double ey)
return;
}
}
}
int x, y;
cursorToInt(ex, ey, &x, &y);

1
client/src/main.h
View File

@ -54,6 +54,7 @@ struct AppState
SDL_Point windowPos;
int windowW, windowH;
int windowCX, windowCY;
LG_RendererRotate rotate;
bool focused;
SDL_Rect border;
SDL_Point srcSize;