mirror
/
devilutionX
mirror of https://github.com/diasurgical/devilutionX.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

[Virtual Gamepad] Add menu panel to top-right corner

pull/3280/head
staphen 4 years ago committed by Anders Jenbo
parent
6e215a3cae
commit
ccd8f114f8
7 changed files with 224 additions and 56 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 16
      Source/controls/game_controls.cpp
  2. 46
      Source/controls/touch/event_handlers.cpp
  3. 31
      Source/controls/touch/event_handlers.h
  4. 86
      Source/controls/touch/gamepad.cpp
  5. 53
      Source/controls/touch/gamepad.h
  6. 28
      Source/controls/touch/renderers.cpp
  7. 20
      Source/controls/touch/renderers.h

16
Source/controls/game_controls.cpp
Unescape View File

@ -100,6 +100,22 @@ bool GetGameAction(const SDL_Event &event, ControllerButtonEvent ctrlEvent, Game
#if defined(VIRTUAL_GAMEPAD) && !defined(USE_SDL1) #if defined(VIRTUAL_GAMEPAD) && !defined(USE_SDL1)
if (event.type == SDL_FINGERDOWN) { if (event.type == SDL_FINGERDOWN) {
if (VirtualGamepadState.menuPanel.charButton.isHeld && VirtualGamepadState.menuPanel.charButton.didStateChange) {
*action = GameAction(GameActionType_TOGGLE_CHARACTER_INFO);
return true;
}
if (VirtualGamepadState.menuPanel.questsButton.isHeld && VirtualGamepadState.menuPanel.questsButton.didStateChange) {
*action = GameAction(GameActionType_TOGGLE_QUEST_LOG);
return true;
}
if (VirtualGamepadState.menuPanel.inventoryButton.isHeld && VirtualGamepadState.menuPanel.inventoryButton.didStateChange) {
*action = GameAction(GameActionType_TOGGLE_INVENTORY);
return true;
}
if (VirtualGamepadState.menuPanel.mapButton.isHeld && VirtualGamepadState.menuPanel.mapButton.didStateChange) {
*action = GameActionSendKey { DVL_VK_TAB, false };
return true;
}
if (VirtualGamepadState.primaryActionButton.isHeld && VirtualGamepadState.primaryActionButton.didStateChange) { if (VirtualGamepadState.primaryActionButton.isHeld && VirtualGamepadState.primaryActionButton.didStateChange) {
if (!inGameMenu && !QuestLogIsOpen && !sbookflag) if (!inGameMenu && !QuestLogIsOpen && !sbookflag)
*action = GameAction(GameActionType_PRIMARY_ACTION); *action = GameAction(GameActionType_PRIMARY_ACTION);

46
Source/controls/touch/event_handlers.cpp
Unescape View File

@ -127,6 +127,18 @@ bool VirtualGamepadEventHandler::Handle(const SDL_Event &event)
return false; return false;
} }
if (charMenuButtonEventHandler.Handle(event))
return true;
if (questsMenuButtonEventHandler.Handle(event))
return true;
if (inventoryMenuButtonEventHandler.Handle(event))
return true;
if (mapMenuButtonEventHandler.Handle(event))
return true;
if (directionPadEventHandler.Handle(event)) if (directionPadEventHandler.Handle(event))
return true; return true;
@ -210,15 +222,15 @@ bool VirtualDirectionPadEventHandler::HandleFingerMotion(const SDL_TouchFingerEv
return true; return true;
} }
bool VirtualPadButtonEventHandler::Handle(const SDL_Event &event) bool VirtualButtonEventHandler::Handle(const SDL_Event &event)
{ {
if (!virtualPadButton->isUsable()) { if (!virtualButton->isUsable()) {
virtualPadButton->didStateChange = virtualPadButton->isHeld; virtualButton->didStateChange = virtualButton->isHeld;
virtualPadButton->isHeld = false; virtualButton->isHeld = false;
return false; return false;
} }
virtualPadButton->didStateChange = false; virtualButton->didStateChange = false;
switch (event.type) { switch (event.type) {
case SDL_FINGERDOWN: case SDL_FINGERDOWN:
@ -235,7 +247,7 @@ bool VirtualPadButtonEventHandler::Handle(const SDL_Event &event)
} }
} }
bool VirtualPadButtonEventHandler::HandleFingerDown(const SDL_TouchFingerEvent &event) bool VirtualButtonEventHandler::HandleFingerDown(const SDL_TouchFingerEvent &event)
{ {
if (isActive) if (isActive)
return false; return false;
@ -244,30 +256,30 @@ bool VirtualPadButtonEventHandler::HandleFingerDown(const SDL_TouchFingerEvent &
float y = event.y; float y = event.y;
Point touchCoordinates = ScaleToScreenCoordinates(x, y); Point touchCoordinates = ScaleToScreenCoordinates(x, y);
if (!virtualPadButton->area.Contains(touchCoordinates)) if (!virtualButton->Contains(touchCoordinates))
return false; return false;
virtualPadButton->isHeld = true; virtualButton->isHeld = true;
virtualPadButton->didStateChange = true; virtualButton->didStateChange = true;
activeFinger = event.fingerId; activeFinger = event.fingerId;
isActive = true; isActive = true;
return true; return true;
} }
bool VirtualPadButtonEventHandler::HandleFingerUp(const SDL_TouchFingerEvent &event) bool VirtualButtonEventHandler::HandleFingerUp(const SDL_TouchFingerEvent &event)
{ {
if (!isActive || event.fingerId != activeFinger) if (!isActive || event.fingerId != activeFinger)
return false; return false;
if (virtualPadButton->isHeld) if (virtualButton->isHeld)
virtualPadButton->didStateChange = true; virtualButton->didStateChange = true;
virtualPadButton->isHeld = false; virtualButton->isHeld = false;
isActive = false; isActive = false;
return true; return true;
} }
bool VirtualPadButtonEventHandler::HandleFingerMotion(const SDL_TouchFingerEvent &event) bool VirtualButtonEventHandler::HandleFingerMotion(const SDL_TouchFingerEvent &event)
{ {
if (!isActive || event.fingerId != activeFinger) if (!isActive || event.fingerId != activeFinger)
return false; return false;
@ -276,9 +288,9 @@ bool VirtualPadButtonEventHandler::HandleFingerMotion(const SDL_TouchFingerEvent
float y = event.y; float y = event.y;
Point touchCoordinates = ScaleToScreenCoordinates(x, y); Point touchCoordinates = ScaleToScreenCoordinates(x, y);
bool wasHeld = virtualPadButton->isHeld; bool wasHeld = virtualButton->isHeld;
virtualPadButton->isHeld = virtualPadButton->area.Contains(touchCoordinates); virtualButton->isHeld = virtualButton->Contains(touchCoordinates);
virtualPadButton->didStateChange = virtualPadButton->isHeld != wasHeld; virtualButton->didStateChange = virtualButton->isHeld != wasHeld;
return true; return true;
} }

31
Source/controls/touch/event_handlers.h
Unescape View File

@ -29,10 +29,10 @@ private:
bool HandleFingerMotion(const SDL_TouchFingerEvent &event); bool HandleFingerMotion(const SDL_TouchFingerEvent &event);
}; };
class VirtualPadButtonEventHandler { class VirtualButtonEventHandler {
public: public:
VirtualPadButtonEventHandler(VirtualPadButton *virtualPadButton) VirtualButtonEventHandler(VirtualButton *virtualButton)
: virtualPadButton(virtualPadButton) : virtualButton(virtualButton)
, activeFinger(0) , activeFinger(0)
, isActive(false) , isActive(false)
{ {
@ -41,7 +41,7 @@ public:
bool Handle(const SDL_Event &event); bool Handle(const SDL_Event &event);
private: private:
VirtualPadButton *virtualPadButton; VirtualButton *virtualButton;
SDL_FingerID activeFinger; SDL_FingerID activeFinger;
bool isActive; bool isActive;
@ -53,7 +53,11 @@ private:
class VirtualGamepadEventHandler { class VirtualGamepadEventHandler {
public: public:
VirtualGamepadEventHandler(VirtualGamepad *virtualGamepad) VirtualGamepadEventHandler(VirtualGamepad *virtualGamepad)
: directionPadEventHandler(&virtualGamepad->directionPad) : charMenuButtonEventHandler(&virtualGamepad->menuPanel.charButton)
, questsMenuButtonEventHandler(&virtualGamepad->menuPanel.questsButton)
, inventoryMenuButtonEventHandler(&virtualGamepad->menuPanel.inventoryButton)
, mapMenuButtonEventHandler(&virtualGamepad->menuPanel.mapButton)
, directionPadEventHandler(&virtualGamepad->directionPad)
, primaryActionButtonEventHandler(&virtualGamepad->primaryActionButton) , primaryActionButtonEventHandler(&virtualGamepad->primaryActionButton)
, secondaryActionButtonEventHandler(&virtualGamepad->secondaryActionButton) , secondaryActionButtonEventHandler(&virtualGamepad->secondaryActionButton)
, spellActionButtonEventHandler(&virtualGamepad->spellActionButton) , spellActionButtonEventHandler(&virtualGamepad->spellActionButton)
@ -66,15 +70,20 @@ public:
bool Handle(const SDL_Event &event); bool Handle(const SDL_Event &event);
private: private:
VirtualButtonEventHandler charMenuButtonEventHandler;
VirtualButtonEventHandler questsMenuButtonEventHandler;
VirtualButtonEventHandler inventoryMenuButtonEventHandler;
VirtualButtonEventHandler mapMenuButtonEventHandler;
VirtualDirectionPadEventHandler directionPadEventHandler; VirtualDirectionPadEventHandler directionPadEventHandler;
VirtualPadButtonEventHandler primaryActionButtonEventHandler; VirtualButtonEventHandler primaryActionButtonEventHandler;
VirtualPadButtonEventHandler secondaryActionButtonEventHandler; VirtualButtonEventHandler secondaryActionButtonEventHandler;
VirtualPadButtonEventHandler spellActionButtonEventHandler; VirtualButtonEventHandler spellActionButtonEventHandler;
VirtualPadButtonEventHandler cancelButtonEventHandler; VirtualButtonEventHandler cancelButtonEventHandler;
VirtualPadButtonEventHandler healthButtonEventHandler; VirtualButtonEventHandler healthButtonEventHandler;
VirtualPadButtonEventHandler manaButtonEventHandler; VirtualButtonEventHandler manaButtonEventHandler;
}; };
void HandleTouchEvent(const SDL_Event &event); void HandleTouchEvent(const SDL_Event &event);

86
Source/controls/touch/gamepad.cpp
Unescape View File

@ -51,6 +51,7 @@ void InitializeVirtualGamepad()
{ {
int screenPixels = std::min(gnScreenWidth, gnScreenHeight); int screenPixels = std::min(gnScreenWidth, gnScreenHeight);
int inputMargin = screenPixels / 10; int inputMargin = screenPixels / 10;
int menuButtonWidth = screenPixels / 10;
int directionPadSize = screenPixels / 4; int directionPadSize = screenPixels / 4;
int padButtonSize = round(1.1 * screenPixels / 10); int padButtonSize = round(1.1 * screenPixels / 10);
int padButtonSpacing = inputMargin / 3; int padButtonSpacing = inputMargin / 3;
@ -67,11 +68,20 @@ void InitializeVirtualGamepad()
float dpi = std::min(hdpi, vdpi); float dpi = std::min(hdpi, vdpi);
inputMargin = round(0.25 * dpi); inputMargin = round(0.25 * dpi);
menuButtonWidth = round(0.2 * dpi);
directionPadSize = round(dpi); directionPadSize = round(dpi);
padButtonSize = round(0.3 * dpi); padButtonSize = round(0.3 * dpi);
padButtonSpacing = round(0.1 * dpi); padButtonSpacing = round(0.1 * dpi);
} }
int menuPanelTopMargin = 30;
int menuPanelButtonSpacing = 4;
Size menuPanelButtonSize = { 64, 62 };
int rightMarginMenuButton4 = menuPanelButtonSpacing + menuPanelButtonSize.width;
int rightMarginMenuButton3 = rightMarginMenuButton4 + menuPanelButtonSpacing + menuPanelButtonSize.width;
int rightMarginMenuButton2 = rightMarginMenuButton3 + menuPanelButtonSpacing + menuPanelButtonSize.width;
int rightMarginMenuButton1 = rightMarginMenuButton2 + menuPanelButtonSpacing + menuPanelButtonSize.width;
int padButtonAreaWidth = round(std::sqrt(2) * (padButtonSize + padButtonSpacing)); int padButtonAreaWidth = round(std::sqrt(2) * (padButtonSize + padButtonSpacing));
int padButtonRight = gnScreenWidth - inputMargin - padButtonSize / 2; int padButtonRight = gnScreenWidth - inputMargin - padButtonSize / 2;
@ -79,42 +89,74 @@ void InitializeVirtualGamepad()
int padButtonBottom = gnScreenHeight - inputMargin - padButtonSize / 2; int padButtonBottom = gnScreenHeight - inputMargin - padButtonSize / 2;
int padButtonTop = padButtonBottom - padButtonAreaWidth; int padButtonTop = padButtonBottom - padButtonAreaWidth;
Rectangle &charButtonArea = VirtualGamepadState.menuPanel.charButton.area;
charButtonArea.position.x = gnScreenWidth - rightMarginMenuButton1 * menuButtonWidth / menuPanelButtonSize.width;
charButtonArea.position.y = menuPanelTopMargin * menuButtonWidth / menuPanelButtonSize.width;
charButtonArea.size.width = menuButtonWidth;
charButtonArea.size.height = menuPanelButtonSize.height * menuButtonWidth / menuPanelButtonSize.width;
Rectangle &questsButtonArea = VirtualGamepadState.menuPanel.questsButton.area;
questsButtonArea.position.x = gnScreenWidth - rightMarginMenuButton2 * menuButtonWidth / menuPanelButtonSize.width;
questsButtonArea.position.y = menuPanelTopMargin * menuButtonWidth / menuPanelButtonSize.width;
questsButtonArea.size.width = menuButtonWidth;
questsButtonArea.size.height = menuPanelButtonSize.height * menuButtonWidth / menuPanelButtonSize.width;
Rectangle &inventoryButtonArea = VirtualGamepadState.menuPanel.inventoryButton.area;
inventoryButtonArea.position.x = gnScreenWidth - rightMarginMenuButton3 * menuButtonWidth / menuPanelButtonSize.width;
inventoryButtonArea.position.y = menuPanelTopMargin * menuButtonWidth / menuPanelButtonSize.width;
inventoryButtonArea.size.width = menuButtonWidth;
inventoryButtonArea.size.height = menuPanelButtonSize.height * menuButtonWidth / menuPanelButtonSize.width;
Rectangle &mapButtonArea = VirtualGamepadState.menuPanel.mapButton.area;
mapButtonArea.position.x = gnScreenWidth - rightMarginMenuButton4 * menuButtonWidth / menuPanelButtonSize.width;
mapButtonArea.position.y = menuPanelTopMargin * menuButtonWidth / menuPanelButtonSize.width;
mapButtonArea.size.width = menuButtonWidth;
mapButtonArea.size.height = menuPanelButtonSize.height * menuButtonWidth / menuPanelButtonSize.width;
Rectangle &menuPanelArea = VirtualGamepadState.menuPanel.area;
menuPanelArea.position.x = gnScreenWidth - 399 * menuButtonWidth / menuPanelButtonSize.width;
menuPanelArea.position.y = 0;
menuPanelArea.size.width = 399 * menuButtonWidth / menuPanelButtonSize.width;
menuPanelArea.size.height = 162 * menuButtonWidth / menuPanelButtonSize.width;
VirtualDirectionPad &directionPad = VirtualGamepadState.directionPad; VirtualDirectionPad &directionPad = VirtualGamepadState.directionPad;
directionPad.area.position.x = inputMargin + directionPadSize / 2; directionPad.area.position.x = inputMargin + directionPadSize / 2;
directionPad.area.position.y = gnScreenHeight - inputMargin - directionPadSize / 2; directionPad.area.position.y = gnScreenHeight - inputMargin - directionPadSize / 2;
directionPad.area.radius = directionPadSize / 2; directionPad.area.radius = directionPadSize / 2;
directionPad.position = directionPad.area.position; directionPad.position = directionPad.area.position;
VirtualPadButton &primaryActionButton = VirtualGamepadState.primaryActionButton; Circle &primaryActionButtonArea = VirtualGamepadState.primaryActionButton.area;
primaryActionButton.area.position.x = padButtonRight; primaryActionButtonArea.position.x = padButtonRight;
primaryActionButton.area.position.y = (padButtonTop + padButtonBottom) / 2; primaryActionButtonArea.position.y = (padButtonTop + padButtonBottom) / 2;
primaryActionButton.area.radius = padButtonSize / 2; primaryActionButtonArea.radius = padButtonSize / 2;
VirtualPadButton &secondaryActionButton = VirtualGamepadState.secondaryActionButton; Circle &secondaryActionButtonArea = VirtualGamepadState.secondaryActionButton.area;
secondaryActionButton.area.position.x = (padButtonLeft + padButtonRight) / 2; secondaryActionButtonArea.position.x = (padButtonLeft + padButtonRight) / 2;
secondaryActionButton.area.position.y = padButtonTop; secondaryActionButtonArea.position.y = padButtonTop;
secondaryActionButton.area.radius = padButtonSize / 2; secondaryActionButtonArea.radius = padButtonSize / 2;
VirtualPadButton &spellActionButton = VirtualGamepadState.spellActionButton; Circle &spellActionButtonArea = VirtualGamepadState.spellActionButton.area;
spellActionButton.area.position.x = padButtonLeft; spellActionButtonArea.position.x = padButtonLeft;
spellActionButton.area.position.y = (padButtonTop + padButtonBottom) / 2; spellActionButtonArea.position.y = (padButtonTop + padButtonBottom) / 2;
spellActionButton.area.radius = padButtonSize / 2; spellActionButtonArea.radius = padButtonSize / 2;
VirtualPadButton &cancelButton = VirtualGamepadState.cancelButton; Circle &cancelButtonArea = VirtualGamepadState.cancelButton.area;
cancelButton.area.position.x = (padButtonLeft + padButtonRight) / 2; cancelButtonArea.position.x = (padButtonLeft + padButtonRight) / 2;
cancelButton.area.position.y = padButtonBottom; cancelButtonArea.position.y = padButtonBottom;
cancelButton.area.radius = padButtonSize / 2; cancelButtonArea.radius = padButtonSize / 2;
VirtualPadButton &healthButton = VirtualGamepadState.healthButton; VirtualPadButton &healthButton = VirtualGamepadState.healthButton;
healthButton.area.position.x = directionPad.area.position.x - (padButtonSize + padButtonSpacing) / 2; Circle &healthButtonArea = healthButton.area;
healthButton.area.position.y = directionPad.area.position.y - (directionPadSize + padButtonSize + padButtonSpacing) / 2; healthButtonArea.position.x = directionPad.area.position.x - (padButtonSize + padButtonSpacing) / 2;
healthButton.area.radius = padButtonSize / 2; healthButtonArea.position.y = directionPad.area.position.y - (directionPadSize + padButtonSize + padButtonSpacing) / 2;
healthButtonArea.radius = padButtonSize / 2;
healthButton.isUsable = []() { return !chrflag && !QuestLogIsOpen; }; healthButton.isUsable = []() { return !chrflag && !QuestLogIsOpen; };
VirtualPadButton &manaButton = VirtualGamepadState.manaButton; VirtualPadButton &manaButton = VirtualGamepadState.manaButton;
manaButton.area.position.x = directionPad.area.position.x + (padButtonSize + padButtonSpacing) / 2; Circle &manaButtonArea = manaButton.area;
manaButton.area.position.y = directionPad.area.position.y - (directionPadSize + padButtonSize + padButtonSpacing) / 2; manaButtonArea.position.x = directionPad.area.position.x + (padButtonSize + padButtonSpacing) / 2;
manaButton.area.radius = padButtonSize / 2; manaButtonArea.position.y = directionPad.area.position.y - (directionPadSize + padButtonSize + padButtonSpacing) / 2;
manaButtonArea.radius = padButtonSize / 2;
manaButton.isUsable = []() { return !chrflag && !QuestLogIsOpen; }; manaButton.isUsable = []() { return !chrflag && !QuestLogIsOpen; };
} }

53
Source/controls/touch/gamepad.h
Unescape View File

@ -7,6 +7,7 @@
#include "controls/controller_buttons.h" #include "controls/controller_buttons.h"
#include "engine/circle.hpp" #include "engine/circle.hpp"
#include "engine/point.hpp" #include "engine/point.hpp"
#include "engine/rectangle.hpp"
namespace devilution { namespace devilution {
@ -31,22 +32,64 @@ struct VirtualDirectionPad {
void UpdatePosition(Point touchCoordinates); void UpdatePosition(Point touchCoordinates);
}; };
struct VirtualPadButton { struct VirtualButton {
Circle area;
bool isHeld; bool isHeld;
bool didStateChange; bool didStateChange;
std::function<bool()> isUsable; std::function<bool()> isUsable;
VirtualPadButton() VirtualButton()
: area({ { 0, 0 }, 0 }) : isHeld(false)
, isHeld(false)
, didStateChange(false) , didStateChange(false)
, isUsable([]() { return true; }) , isUsable([]() { return true; })
{ {
} }
virtual bool Contains(Point point) = 0;
};
struct VirtualMenuButton : VirtualButton {
Rectangle area;
VirtualMenuButton()
: area({ { 0, 0 }, { 0, 0 } })
{
}
bool Contains(Point point) override
{
return area.Contains(point);
}
};
struct VirtualPadButton : VirtualButton {
Circle area;
VirtualPadButton()
: area({ { 0, 0 }, 0 })
{
}
bool Contains(Point point) override
{
return area.Contains(point);
}
};
struct VirtualMenuPanel {
VirtualMenuButton charButton;
VirtualMenuButton questsButton;
VirtualMenuButton inventoryButton;
VirtualMenuButton mapButton;
Rectangle area;
VirtualMenuPanel()
: area({ { 0, 0 }, { 0, 0 } })
{
}
}; };
struct VirtualGamepad { struct VirtualGamepad {
VirtualMenuPanel menuPanel;
VirtualDirectionPad directionPad; VirtualDirectionPad directionPad;
VirtualPadButton primaryActionButton; VirtualPadButton primaryActionButton;

28
Source/controls/touch/renderers.cpp
Unescape View File

@ -190,11 +190,22 @@ void RenderVirtualGamepad(SDL_Surface *surface)
void VirtualGamepadRenderer::LoadArt(SDL_Renderer *renderer) void VirtualGamepadRenderer::LoadArt(SDL_Renderer *renderer)
{ {
menuPanelRenderer.LoadArt(renderer);
directionPadRenderer.LoadArt(renderer); directionPadRenderer.LoadArt(renderer);
LoadButtonArt(&buttonArt, renderer); LoadButtonArt(&buttonArt, renderer);
LoadPotionArt(&potionArt, renderer); LoadPotionArt(&potionArt, renderer);
} }
void VirtualMenuPanelRenderer::LoadArt(SDL_Renderer *renderer)
{
menuArt.surface.reset(LoadPNG("ui_art\\menu.png"));
if (renderer != nullptr) {
menuArt.texture.reset(SDL_CreateTextureFromSurface(renderer, menuArt.surface.get()));
menuArt.surface = nullptr;
}
}
void VirtualDirectionPadRenderer::LoadArt(SDL_Renderer *renderer) void VirtualDirectionPadRenderer::LoadArt(SDL_Renderer *renderer)
{ {
padArt.surface.reset(LoadPNG("ui_art\\directions.png")); padArt.surface.reset(LoadPNG("ui_art\\directions.png"));
@ -225,6 +236,17 @@ void VirtualGamepadRenderer::Render(RenderFunction renderFunction)
manaButtonRenderer.RenderPotion(renderFunction, potionArt); manaButtonRenderer.RenderPotion(renderFunction, potionArt);
directionPadRenderer.Render(renderFunction); directionPadRenderer.Render(renderFunction);
menuPanelRenderer.Render(renderFunction);
}
void VirtualMenuPanelRenderer::Render(RenderFunction renderFunction)
{
int x = virtualMenuPanel->area.position.x;
int y = virtualMenuPanel->area.position.y;
int width = virtualMenuPanel->area.size.width;
int height = virtualMenuPanel->area.size.height;
SDL_Rect rect { x, y, width, height };
renderFunction(menuArt, nullptr, &rect);
} }
void VirtualDirectionPadRenderer::Render(RenderFunction renderFunction) void VirtualDirectionPadRenderer::Render(RenderFunction renderFunction)
@ -450,11 +472,17 @@ VirtualGamepadButtonType PotionButtonRenderer::GetButtonType()
void VirtualGamepadRenderer::UnloadArt() void VirtualGamepadRenderer::UnloadArt()
{ {
menuPanelRenderer.UnloadArt();
directionPadRenderer.UnloadArt(); directionPadRenderer.UnloadArt();
buttonArt.Unload(); buttonArt.Unload();
potionArt.Unload(); potionArt.Unload();
} }
void VirtualMenuPanelRenderer::UnloadArt()
{
menuArt.Unload();
}
void VirtualDirectionPadRenderer::UnloadArt() void VirtualDirectionPadRenderer::UnloadArt()
{ {
padArt.Unload(); padArt.Unload();

20
Source/controls/touch/renderers.h
Unescape View File

@ -51,6 +51,22 @@ enum VirtualGamepadPotionType {
typedef std::function<void(Art &art, SDL_Rect *src, SDL_Rect *dst)> RenderFunction; typedef std::function<void(Art &art, SDL_Rect *src, SDL_Rect *dst)> RenderFunction;
class VirtualMenuPanelRenderer {
public:
VirtualMenuPanelRenderer(VirtualMenuPanel *virtualMenuPanel)
: virtualMenuPanel(virtualMenuPanel)
{
}
void LoadArt(SDL_Renderer *renderer);
void Render(RenderFunction renderFunction);
void UnloadArt();
private:
VirtualMenuPanel *virtualMenuPanel;
Art menuArt;
};
class VirtualDirectionPadRenderer { class VirtualDirectionPadRenderer {
public: public:
VirtualDirectionPadRenderer(VirtualDirectionPad *virtualDirectionPad) VirtualDirectionPadRenderer(VirtualDirectionPad *virtualDirectionPad)
@ -153,7 +169,8 @@ private:
class VirtualGamepadRenderer { class VirtualGamepadRenderer {
public: public:
VirtualGamepadRenderer(VirtualGamepad *virtualGamepad) VirtualGamepadRenderer(VirtualGamepad *virtualGamepad)
: directionPadRenderer(&virtualGamepad->directionPad) : menuPanelRenderer(&virtualGamepad->menuPanel)
, directionPadRenderer(&virtualGamepad->directionPad)
, primaryActionButtonRenderer(&virtualGamepad->primaryActionButton) , primaryActionButtonRenderer(&virtualGamepad->primaryActionButton)
, secondaryActionButtonRenderer(&virtualGamepad->secondaryActionButton) , secondaryActionButtonRenderer(&virtualGamepad->secondaryActionButton)
, spellActionButtonRenderer(&virtualGamepad->spellActionButton) , spellActionButtonRenderer(&virtualGamepad->spellActionButton)
@ -168,6 +185,7 @@ public:
void UnloadArt(); void UnloadArt();
private: private:
VirtualMenuPanelRenderer menuPanelRenderer;
VirtualDirectionPadRenderer directionPadRenderer; VirtualDirectionPadRenderer directionPadRenderer;
PrimaryActionButtonRenderer primaryActionButtonRenderer; PrimaryActionButtonRenderer primaryActionButtonRenderer;

Write Preview
Loading…
Cancel
Save