Xargon/ES-DE
1
0
Fork 0
mirror of https://github.com/RetroDECK/ES-DE.git synced 2024-11-25 15:45:38 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge branch 'glm-rewrite'

Browse source
This commit is contained in:
Leon Styhre 2021-08-17 19:00:17 +02:00
parent ffc9814636 7b5d673050
commit 85444c0ee6
124 changed files with 2332 additions and 2384 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
.clang-format
View file

@ -66,7 +66,7 @@ CompactNamespaces: false
ConstructorInitializerAllOnOneLineOrOnePerLine: false
ConstructorInitializerIndentWidth: 4
ContinuationIndentWidth: 4
Cpp11BracedListStyle: false
Cpp11BracedListStyle: true
DeriveLineEnding: true
DerivePointerAlignment: false
DisableFormat: false
@ -119,7 +119,7 @@ SpaceAfterCStyleCast: false
SpaceAfterLogicalNot: false
SpaceAfterTemplateKeyword: true
SpaceBeforeAssignmentOperators: true
SpaceBeforeCpp11BracedList: true
SpaceBeforeCpp11BracedList: false
SpaceBeforeCtorInitializerColon: true
SpaceBeforeInheritanceColon: true
SpaceBeforeParens: ControlStatements

4
CMakeLists.txt
View file

@ -196,6 +196,10 @@ if(DEFINED libCEC_FOUND)
add_definitions(-DHAVE_LIBCEC)
endif()
# GLM library options.
add_definitions(-DGLM_FORCE_CXX14)
add_definitions(-DGLM_FORCE_XYZW_ONLY)
# For Unix systems, assign the installation prefix. If it's not explicitly set,
# we use /usr on Linux, /usr/pkg on NetBSD and /usr/local on FreeBSD and OpenBSD.
if(NOT WIN32 AND NOT APPLE)

3
es-app/src/FileFilterIndex.cpp
View file

@ -425,8 +425,7 @@ bool FileFilterIndex::isKeyBeingFilteredBy(std::string key, FilterIndexType type
std::vector<std::string> filterKeysList[9] = {
mFavoritesIndexFilteredKeys, mGenreIndexFilteredKeys, mPlayersIndexFilteredKeys,
mPubDevIndexFilteredKeys, mRatingsIndexFilteredKeys, mKidGameIndexFilteredKeys,
mCompletedIndexFilteredKeys, mBrokenIndexFilteredKeys, mHiddenIndexFilteredKeys
};
mCompletedIndexFilteredKeys, mBrokenIndexFilteredKeys, mHiddenIndexFilteredKeys};
for (int i = 0; i < 9; i++) {
if (filterTypes[i] == type) {

3
es-app/src/FileSorts.cpp
View file

@ -45,8 +45,7 @@ namespace FileSorts
FileData::SortType(&compareTimesPlayedDescending, "times played, descending"),
FileData::SortType(&compareSystem, "system, ascending"),
FileData::SortType(&compareSystemDescending, "system, descending")
};
FileData::SortType(&compareSystemDescending, "system, descending")};
const std::vector<FileData::SortType> SortTypes(typesArr,
typesArr +

12
es-app/src/MediaViewer.cpp
View file

@ -83,19 +83,19 @@ void MediaViewer::update(int deltaTime)
void MediaViewer::render()
{
Transform4x4f transform = Transform4x4f::Identity();
Renderer::setMatrix(transform);
glm::mat4 trans{Renderer::getIdentity()};
Renderer::setMatrix(trans);
// Render a black background below the game media.
Renderer::drawRect(0.0f, 0.0f, static_cast<float>(Renderer::getScreenWidth()),
static_cast<float>(Renderer::getScreenHeight()), 0x000000FF, 0x000000FF);
if (mVideo && !mDisplayingImage) {
mVideo->render(transform);
mVideo->render(trans);
#if defined(USE_OPENGL_21)
Renderer::shaderParameters videoParameters;
unsigned int shaders = 0;
unsigned int shaders{0};
if (Settings::getInstance()->getBool("MediaViewerVideoScanlines"))
shaders = Renderer::SHADER_SCANLINES;
if (Settings::getInstance()->getBool("MediaViewerVideoBlur")) {
@ -121,8 +121,8 @@ void MediaViewer::render()
Renderer::shaderPostprocessing(shaders, videoParameters);
#endif
}
else if (mImage && mImage->hasImage() && mImage->getSize() != 0) {
mImage->render(transform);
else if (mImage && mImage->hasImage() && mImage->getSize() != glm::vec2{}) {
mImage->render(trans);
#if defined(USE_OPENGL_21)
if (mCurrentImageIndex == mScreenShotIndex &&

25
es-app/src/SystemScreensaver.cpp
View file

@ -248,19 +248,19 @@ void SystemScreensaver::renderScreensaver()
if (mVideoScreensaver && screensaverType == "video") {
// Render a black background below the video.
Renderer::setMatrix(Transform4x4f::Identity());
Renderer::setMatrix(Renderer::getIdentity());
Renderer::drawRect(0.0f, 0.0f, static_cast<float>(Renderer::getScreenWidth()),
static_cast<float>(Renderer::getScreenHeight()), 0x000000FF, 0x000000FF);
// Only render the video if the state requires it.
if (static_cast<int>(mState) >= STATE_FADE_IN_VIDEO) {
Transform4x4f transform = Transform4x4f::Identity();
mVideoScreensaver->render(transform);
glm::mat4 trans{Renderer::getIdentity()};
mVideoScreensaver->render(trans);
}
}
else if (mImageScreensaver && screensaverType == "slideshow") {
// Render a black background below the image.
Renderer::setMatrix(Transform4x4f::Identity());
Renderer::setMatrix(Renderer::getIdentity());
Renderer::drawRect(0.0f, 0.0f, static_cast<float>(Renderer::getScreenWidth()),
static_cast<float>(Renderer::getScreenHeight()), 0x000000FF, 0x000000FF);
@ -268,15 +268,14 @@ void SystemScreensaver::renderScreensaver()
if (static_cast<int>(mState) >= STATE_FADE_IN_VIDEO) {
if (mImageScreensaver->hasImage()) {
mImageScreensaver->setOpacity(255 - static_cast<unsigned char>(mOpacity * 255));
Transform4x4f transform = Transform4x4f::Identity();
mImageScreensaver->render(transform);
glm::mat4 trans{Renderer::getIdentity()};
mImageScreensaver->render(trans);
}
}
}
if (isScreensaverActive()) {
Renderer::setMatrix(Transform4x4f::Identity());
Renderer::setMatrix(Renderer::getIdentity());
if (Settings::getInstance()->getString("ScreensaverType") == "slideshow") {
if (mHasMediaFiles) {
#if defined(USE_OPENGL_21)
@ -609,18 +608,18 @@ void SystemScreensaver::generateOverlayInfo()
mGameOverlayFont.at(0)->buildTextCache(overlayText, posX, posY, 0xFFFFFFFF));
float textSizeX;
float textSizeY = mGameOverlayFont[0].get()->sizeText(overlayText).y();
float textSizeY = mGameOverlayFont[0].get()->sizeText(overlayText).y;
// There is a weird issue with sizeText() where the X size value is returned
// as too large if there are two rows in a string and the second row is longer
// than the first row. Possibly it's the newline character that is somehow
// injected in the size calculation. Regardless, this workaround is working
// fine for the time being.
if (mGameOverlayFont[0].get()->sizeText(gameName).x() >
mGameOverlayFont[0].get()->sizeText(systemName).x())
textSizeX = mGameOverlayFont[0].get()->sizeText(gameName).x();
if (mGameOverlayFont[0].get()->sizeText(gameName).x >
mGameOverlayFont[0].get()->sizeText(systemName).x)
textSizeX = mGameOverlayFont[0].get()->sizeText(gameName).x;
else
textSizeX = mGameOverlayFont[0].get()->sizeText(systemName).x();
textSizeX = mGameOverlayFont[0].get()->sizeText(systemName).x;
float marginX = Renderer::getWindowWidth() * 0.01f;

18
es-app/src/animations/MoveCameraAnimation.h
View file

@ -10,14 +10,15 @@
#define ES_APP_ANIMATIONS_MOVE_CAMERA_ANIMATION_H
#include "animations/Animation.h"
#include "math/Misc.h"
class MoveCameraAnimation : public Animation
{
public:
MoveCameraAnimation(Transform4x4f& camera, const Vector3f& target)
MoveCameraAnimation(glm::mat4& camera, const glm::vec3& target)
: mCameraStart(camera)
, mTarget(target)
, cameraOut(camera)
, cameraPosition(camera)
{
}
@ -25,17 +26,16 @@ public:
void apply(float t) override
{
// Cubic ease out.
t -= 1;
cameraOut.translation() =
-Vector3f().lerp(-mCameraStart.translation(), mTarget, t * t * t + 1);
cameraPosition[3].x = -Math::lerp(-mCameraStart[3].x, mTarget.x, t * t * t + 1);
cameraPosition[3].y = -Math::lerp(-mCameraStart[3].y, mTarget.y, t * t * t + 1);
cameraPosition[3].z = -Math::lerp(-mCameraStart[3].z, mTarget.z, t * t * t + 1);
}
private:
Transform4x4f mCameraStart;
Vector3f mTarget;
Transform4x4f& cameraOut;
glm::mat4 mCameraStart;
glm::mat4& cameraPosition;
glm::vec3 mTarget;
};
#endif // ES_APP_ANIMATIONS_MOVE_CAMERA_ANIMATION_H

8
es-app/src/guis/GuiCollectionSystemsOptions.cpp
View file

@ -158,7 +158,7 @@ GuiCollectionSystemsOptions::GuiCollectionSystemsOptions(Window* window, std::st
auto bracketThemeCollection = std::make_shared<ImageComponent>(mWindow);
bracketThemeCollection->setImage(":/graphics/arrow.svg");
bracketThemeCollection->setResize(
Vector2f(0, Font::get(FONT_SIZE_MEDIUM)->getLetterHeight()));
glm::vec2{0.0f, Font::get(FONT_SIZE_MEDIUM)->getLetterHeight()});
row.addElement(themeCollection, true);
row.addElement(bracketThemeCollection, false);
row.makeAcceptInputHandler([this, unusedFolders] {
@ -195,7 +195,8 @@ GuiCollectionSystemsOptions::GuiCollectionSystemsOptions(Window* window, std::st
Font::get(FONT_SIZE_MEDIUM), 0x777777FF);
auto bracketNewCollection = std::make_shared<ImageComponent>(mWindow);
bracketNewCollection->setImage(":/graphics/arrow.svg");
bracketNewCollection->setResize(Vector2f(0, Font::get(FONT_SIZE_MEDIUM)->getLetterHeight()));
bracketNewCollection->setResize(
glm::vec2{0.0f, Font::get(FONT_SIZE_MEDIUM)->getLetterHeight()});
row.addElement(newCollection, true);
row.addElement(bracketNewCollection, false);
auto createCollectionCall = [this](const std::string& newVal) {
@ -219,7 +220,8 @@ GuiCollectionSystemsOptions::GuiCollectionSystemsOptions(Window* window, std::st
mWindow, "DELETE CUSTOM COLLECTION", Font::get(FONT_SIZE_MEDIUM), 0x777777FF);
auto bracketDeleteCollection = std::make_shared<ImageComponent>(mWindow);
bracketDeleteCollection->setImage(":/graphics/arrow.svg");
bracketDeleteCollection->setResize(Vector2f(0, Font::get(FONT_SIZE_MEDIUM)->getLetterHeight()));
bracketDeleteCollection->setResize(
glm::vec2{0.0f, Font::get(FONT_SIZE_MEDIUM)->getLetterHeight()});
row.addElement(deleteCollection, true);
row.addElement(bracketDeleteCollection, false);
row.makeAcceptInputHandler([this, customSystems] {

24
es-app/src/guis/GuiGameScraper.cpp
View file

@ -22,7 +22,7 @@ GuiGameScraper::GuiGameScraper(Window* window,
ScraperSearchParams params,
std::function<void(const ScraperSearchResult&)> doneFunc)
: GuiComponent(window)
, mGrid(window, Vector2i(1, 7))
, mGrid(window, glm::ivec2{1, 7})
, mBox(window, ":/graphics/frame.svg")
, mSearchParams(params)
, mClose(false)
@ -52,20 +52,20 @@ GuiGameScraper::GuiGameScraper(Window* window,
scrapeName +
((mSearchParams.game->getType() == FOLDER) ? " " + ViewController::FOLDER_CHAR : ""),
Font::get(FONT_SIZE_MEDIUM), 0x777777FF, ALIGN_CENTER);
mGrid.setEntry(mGameName, Vector2i(0, 1), false, true);
mGrid.setEntry(mGameName, glm::ivec2{0, 1}, false, true);
// Row 2 is a spacer.
mSystemName = std::make_shared<TextComponent>(
mWindow, Utils::String::toUpper(mSearchParams.system->getFullName()),
Font::get(FONT_SIZE_SMALL), 0x888888FF, ALIGN_CENTER);
mGrid.setEntry(mSystemName, Vector2i(0, 3), false, true);
mGrid.setEntry(mSystemName, glm::ivec2{0, 3}, false, true);
// Row 4 is a spacer.
// GuiScraperSearch.
mSearch = std::make_shared<GuiScraperSearch>(window, GuiScraperSearch::NEVER_AUTO_ACCEPT, 1);
mGrid.setEntry(mSearch, Vector2i(0, 5), true);
mGrid.setEntry(mSearch, glm::ivec2{0, 5}, true);
// Buttons
std::vector<std::shared_ptr<ButtonComponent>> buttons;
@ -92,7 +92,7 @@ GuiGameScraper::GuiGameScraper(Window* window,
}));
mButtonGrid = makeButtonGrid(mWindow, buttons);
mGrid.setEntry(mButtonGrid, Vector2i(0, 6), true, false);
mGrid.setEntry(mButtonGrid, glm::ivec2{0, 6}, true, false);
mSearch->setAcceptCallback([this, doneFunc](const ScraperSearchResult& result) {
doneFunc(result);
@ -106,8 +106,8 @@ GuiGameScraper::GuiGameScraper(Window* window,
float width = Math::clamp(0.95f * aspectValue, 0.70f, 0.95f) * Renderer::getScreenWidth();
setSize(width, Renderer::getScreenHeight() * 0.747f);
setPosition((Renderer::getScreenWidth() - mSize.x()) / 2.0f,
(Renderer::getScreenHeight() - mSize.y()) / 2.0f);
setPosition((Renderer::getScreenWidth() - mSize.x) / 2.0f,
(Renderer::getScreenHeight() - mSize.y) / 2.0f);
mGrid.resetCursor();
mSearch->search(params); // Start the search.
@ -115,16 +115,14 @@ GuiGameScraper::GuiGameScraper(Window* window,
void GuiGameScraper::onSizeChanged()
{
mBox.fitTo(mSize, Vector3f::Zero(), Vector2f(-32.0f, -32.0f));
mBox.fitTo(mSize, glm::vec3{}, glm::vec2{-32.0f, -32.0f});
mGrid.setRowHeightPerc(0, 0.04f, false);
mGrid.setRowHeightPerc(1, mGameName->getFont()->getLetterHeight() / mSize.y(),
false); // Game name.
mGrid.setRowHeightPerc(1, mGameName->getFont()->getLetterHeight() / mSize.y, false);
mGrid.setRowHeightPerc(2, 0.04f, false);
mGrid.setRowHeightPerc(3, mSystemName->getFont()->getLetterHeight() / mSize.y(),
false); // System name.
mGrid.setRowHeightPerc(3, mSystemName->getFont()->getLetterHeight() / mSize.y, false);
mGrid.setRowHeightPerc(4, 0.04f, false);
mGrid.setRowHeightPerc(6, mButtonGrid->getSize().y() / mSize.y(), false); // Buttons.
mGrid.setRowHeightPerc(6, mButtonGrid->getSize().y / mSize.y, false);
mGrid.setSize(mSize);
}

6
es-app/src/guis/GuiGamelistFilter.cpp
View file

@ -50,7 +50,7 @@ void GuiGamelistFilter::initializeMenu()
mMenu.addButton("BACK", "back", std::bind(&GuiGamelistFilter::applyFilters, this));
mMenu.setPosition((Renderer::getScreenWidth() - mMenu.getSize().x()) / 2.0f,
mMenu.setPosition((Renderer::getScreenWidth() - mMenu.getSize().x) / 2.0f,
Renderer::getScreenHeight() * 0.13f);
// Save the initial filter values to be able to check later if any changes were made.
@ -101,12 +101,12 @@ void GuiGamelistFilter::addFiltersToMenu()
row.addElement(mTextFilterField, true);
auto spacer = std::make_shared<GuiComponent>(mWindow);
spacer->setSize(Renderer::getScreenWidth() * 0.005f, 0);
spacer->setSize(Renderer::getScreenWidth() * 0.005f, 0.0f);
row.addElement(spacer, false);
auto bracket = std::make_shared<ImageComponent>(mWindow);
bracket->setImage(":/graphics/arrow.svg");
bracket->setResize(Vector2f(0, lbl->getFont()->getLetterHeight()));
bracket->setResize(glm::vec2{0.0f, lbl->getFont()->getLetterHeight()});
row.addElement(bracket, false);
mTextFilterField->setValue(mFilterIndex->getTextFilter());

3
es-app/src/guis/GuiGamelistOptions.cpp
View file

@ -240,8 +240,7 @@ GuiGamelistOptions::GuiGamelistOptions(Window* window, SystemData* system)
// Center the menu.
setSize(static_cast<float>(Renderer::getScreenWidth()),
static_cast<float>(Renderer::getScreenHeight()));
mMenu.setPosition((mSize.x() - mMenu.getSize().x()) / 2.0f,
(mSize.y() - mMenu.getSize().y()) / 2.0f);
mMenu.setPosition((mSize.x - mMenu.getSize().x) / 2.0f, (mSize.y - mMenu.getSize().y) / 2.0f);
}
GuiGamelistOptions::~GuiGamelistOptions()

30
es-app/src/guis/GuiInfoPopup.cpp
View file

@ -33,36 +33,36 @@ GuiInfoPopup::GuiInfoPopup(Window* window, std::string message, int duration)
mSize = s->getSize();
// Confirm that the size isn't larger than the screen width, otherwise cap it.
if (mSize.x() > maxWidth) {
s->setSize(maxWidth, mSize[1]);
mSize[0] = maxWidth;
if (mSize.x > maxWidth) {
s->setSize(maxWidth, mSize.y);
mSize.x = maxWidth;
}
if (mSize.y() > maxHeight) {
s->setSize(mSize[0], maxHeight);
mSize[1] = maxHeight;
if (mSize.y > maxHeight) {
s->setSize(mSize.x, maxHeight);
mSize.y = maxHeight;
}
// Add a padding to the box.
int paddingX = static_cast<int>(Renderer::getScreenWidth() * 0.03f);
int paddingY = static_cast<int>(Renderer::getScreenHeight() * 0.02f);
mSize[0] = mSize.x() + paddingX;
mSize[1] = mSize.y() + paddingY;
mSize.x = mSize.x + paddingX;
mSize.y = mSize.y + paddingY;
float posX = Renderer::getScreenWidth() * 0.5f - mSize.x() * 0.5f;
float posX = Renderer::getScreenWidth() * 0.5f - mSize.x * 0.5f;
float posY = Renderer::getScreenHeight() * 0.02f;
setPosition(posX, posY, 0);
mFrame->setImagePath(":/graphics/frame.svg");
mFrame->fitTo(mSize, Vector3f::Zero(), Vector2f(-32.0f, -32.0f));
mFrame->fitTo(mSize, glm::vec3{}, glm::vec2{-32.0f, -32.0f});
addChild(mFrame);
// We only initialize the actual time when we first start to render.
mStartTime = 0;
mGrid = new ComponentGrid(window, Vector2i(1, 3));
mGrid = new ComponentGrid(window, glm::ivec2{1, 3});
mGrid->setSize(mSize);
mGrid->setEntry(s, Vector2i(0, 1), false, true);
mGrid->setEntry(s, glm::ivec2{0, 1}, false, true);
addChild(mGrid);
}
@ -72,10 +72,10 @@ GuiInfoPopup::~GuiInfoPopup()
delete mFrame;
}
void GuiInfoPopup::render(const Transform4x4f& /*parentTrans*/)
void GuiInfoPopup::render(const glm::mat4& /*parentTrans*/)
{
// We use Identity() as we want to render on a specific window position, not on the view.
Transform4x4f trans = getTransform() * Transform4x4f::Identity();
// We use getIdentity() as we want to render on a specific window position, not on the view.
glm::mat4 trans{getTransform() * Renderer::getIdentity()};
if (mRunning && updateState()) {
// If we're still supposed to be rendering it.
Renderer::setMatrix(trans);

2
es-app/src/guis/GuiInfoPopup.h
View file

@ -21,7 +21,7 @@ public:
GuiInfoPopup(Window* window, std::string message, int duration);
~GuiInfoPopup();
void render(const Transform4x4f& parentTrans) override;
void render(const glm::mat4& parentTrans) override;
void stop() override { mRunning = false; }
private:

58
es-app/src/guis/GuiLaunchScreen.cpp
View file

@ -34,7 +34,7 @@ GuiLaunchScreen::~GuiLaunchScreen()
void GuiLaunchScreen::displayLaunchScreen(FileData* game)
{
mGrid = new ComponentGrid(mWindow, Vector2i(3, 8));
mGrid = new ComponentGrid(mWindow, glm::ivec2{3, 8});
addChild(mGrid);
mImagePath = game->getMarqueePath();
@ -51,8 +51,8 @@ void GuiLaunchScreen::displayLaunchScreen(FileData* game)
const float gameNameFontSize = 0.073f;
// Spacer row.
mGrid->setEntry(std::make_shared<GuiComponent>(mWindow), Vector2i(1, 0), false, false,
Vector2i(1, 1));
mGrid->setEntry(std::make_shared<GuiComponent>(mWindow), glm::ivec2{1, 0}, false, false,
glm::ivec2{1, 1});
// Title.
mTitle = std::make_shared<TextComponent>(
@ -60,19 +60,19 @@ void GuiLaunchScreen::displayLaunchScreen(FileData* game)
Font::get(static_cast<int>(
titleFontSize * std::min(Renderer::getScreenHeight(), Renderer::getScreenWidth()))),
0x666666FF, ALIGN_CENTER);
mGrid->setEntry(mTitle, Vector2i(1, 1), false, true, Vector2i(1, 1));
mGrid->setEntry(mTitle, glm::ivec2{1, 1}, false, true, glm::ivec2{1, 1});
// Spacer row.
mGrid->setEntry(std::make_shared<GuiComponent>(mWindow), Vector2i(1, 2), false, false,
Vector2i(1, 1));
mGrid->setEntry(std::make_shared<GuiComponent>(mWindow), glm::ivec2{1, 2}, false, false,
glm::ivec2{1, 1});
// Row for the marquee.
mGrid->setEntry(std::make_shared<GuiComponent>(mWindow), Vector2i(1, 3), false, false,
Vector2i(1, 1));
mGrid->setEntry(std::make_shared<GuiComponent>(mWindow), glm::ivec2{1, 3}, false, false,
glm::ivec2{1, 1});
// Spacer row.
mGrid->setEntry(std::make_shared<GuiComponent>(mWindow), Vector2i(1, 4), false, false,
Vector2i(1, 1));
mGrid->setEntry(std::make_shared<GuiComponent>(mWindow), glm::ivec2{1, 4}, false, false,
glm::ivec2{1, 1});
// Game name.
mGameName = std::make_shared<TextComponent>(
@ -80,24 +80,24 @@ void GuiLaunchScreen::displayLaunchScreen(FileData* game)
Font::get(static_cast<int>(
gameNameFontSize * std::min(Renderer::getScreenHeight(), Renderer::getScreenWidth()))),
0x444444FF, ALIGN_CENTER);
mGrid->setEntry(mGameName, Vector2i(1, 5), false, true, Vector2i(1, 1));
mGrid->setEntry(mGameName, glm::ivec2{1, 5}, false, true, glm::ivec2{1, 1});
// System name.
mSystemName = std::make_shared<TextComponent>(
mWindow, "SYSTEM NAME", Font::get(FONT_SIZE_MEDIUM), 0x666666FF, ALIGN_CENTER);
mGrid->setEntry(mSystemName, Vector2i(1, 6), false, true, Vector2i(1, 1));
mGrid->setEntry(mSystemName, glm::ivec2{1, 6}, false, true, glm::ivec2{1, 1});
// Spacer row.
mGrid->setEntry(std::make_shared<GuiComponent>(mWindow), Vector2i(1, 7), false, false,
Vector2i(1, 1));
mGrid->setEntry(std::make_shared<GuiComponent>(mWindow), glm::ivec2{1, 7}, false, false,
glm::ivec2{1, 1});
// Left spacer.
mGrid->setEntry(std::make_shared<GuiComponent>(mWindow), Vector2i(0, 0), false, false,
Vector2i(1, 8));
mGrid->setEntry(std::make_shared<GuiComponent>(mWindow), glm::ivec2{0, 0}, false, false,
glm::ivec2{1, 8});
// Right spacer.
mGrid->setEntry(std::make_shared<GuiComponent>(mWindow), Vector2i(2, 0), false, false,
Vector2i(1, 8));
mGrid->setEntry(std::make_shared<GuiComponent>(mWindow), glm::ivec2{2, 0}, false, false,
glm::ivec2{1, 8});
// Adjust the width depending on the aspect ratio of the screen, to make the screen look
// somewhat coherent regardless of screen type. The 1.778 aspect ratio value is the 16:9
@ -114,7 +114,7 @@ void GuiLaunchScreen::displayLaunchScreen(FileData* game)
Font::get(static_cast<int>(gameNameFontSize * std::min(Renderer::getScreenHeight(),
Renderer::getScreenWidth())))
->sizeText(Utils::String::toUpper(game->getName()))
.x();
.x;
// Add a bit of width to compensate for the left and right spacers.
fontWidth += static_cast<float>(Renderer::getScreenWidth()) * 0.05f;
@ -131,15 +131,15 @@ void GuiLaunchScreen::displayLaunchScreen(FileData* game)
mGrid->setRowHeightPerc(0, 0.09f, false);
else
mGrid->setRowHeightPerc(0, 0.15f, false);
mGrid->setRowHeightPerc(1, mTitle->getFont()->getLetterHeight() * 1.70f / mSize.y(), false);
mGrid->setRowHeightPerc(1, mTitle->getFont()->getLetterHeight() * 1.70f / mSize.y, false);
mGrid->setRowHeightPerc(2, 0.05f, false);
if (mImagePath != "")
mGrid->setRowHeightPerc(3, 0.35f, false);
else
mGrid->setRowHeightPerc(3, 0.01f, false);
mGrid->setRowHeightPerc(4, 0.05f, false);
mGrid->setRowHeightPerc(5, mGameName->getFont()->getHeight() * 0.80f / mSize.y(), false);
mGrid->setRowHeightPerc(6, mSystemName->getFont()->getHeight() * 0.90f / mSize.y(), false);
mGrid->setRowHeightPerc(5, mGameName->getFont()->getHeight() * 0.80f / mSize.y, false);
mGrid->setRowHeightPerc(6, mSystemName->getFont()->getHeight() * 0.90f / mSize.y, false);
// Set left and right spacers column widths.
mGrid->setColWidthPerc(0, 0.025f);
@ -153,7 +153,7 @@ void GuiLaunchScreen::displayLaunchScreen(FileData* game)
for (int i = 0; i < 7; i++)
totalRowHeight += mGrid->getRowHeight(i);
setSize(mSize.x(), totalRowHeight);
setSize(mSize.x, totalRowHeight);
mGameName->setText(Utils::String::toUpper(game->getName()));
mSystemName->setText(Utils::String::toUpper(game->getSystem()->getFullName()));
@ -169,12 +169,12 @@ void GuiLaunchScreen::displayLaunchScreen(FileData* game)
mGrid->getRowHeight(3));
mMarquee->setOrigin(0.5f, 0.5f);
Vector3f currentPos = mMarquee->getPosition();
Vector2f currentSize = mMarquee->getSize();
glm::vec3 currentPos{mMarquee->getPosition()};
glm::vec2 currentSize{mMarquee->getSize()};
// Position the image in the middle of row four.
currentPos.x() = mSize.x() / 2.0f;
currentPos.y() = mGrid->getRowHeight(0) + mGrid->getRowHeight(1) + mGrid->getRowHeight(2) +
currentPos.x = mSize.x / 2.0f;
currentPos.y = mGrid->getRowHeight(0) + mGrid->getRowHeight(1) + mGrid->getRowHeight(2) +
mGrid->getRowHeight(3) / 2.0f;
mMarquee->setPosition(currentPos);
}
@ -185,7 +185,7 @@ void GuiLaunchScreen::displayLaunchScreen(FileData* game)
setPosition(static_cast<float>(Renderer::getScreenWidth()) / 2.0f,
static_cast<float>(Renderer::getScreenHeight()) / 2.25f);
mBackground.fitTo(mSize, Vector3f::Zero(), Vector2f(-32.0f, -32.0f));
mBackground.fitTo(mSize, glm::vec3{}, glm::vec2{-32.0f, -32.0f});
mBackground.setEdgeColor(0xEEEEEEFF);
}
@ -228,7 +228,7 @@ void GuiLaunchScreen::render()
if (mScaleUp < 1.0f)
setScale(mScaleUp);
Transform4x4f trans = Transform4x4f::Identity() * getTransform();
glm::mat4 trans{Renderer::getIdentity() * getTransform()};
Renderer::setMatrix(trans);
GuiComponent::renderChildren(trans);

21
es-app/src/guis/GuiMenu.cpp
View file

@ -75,8 +75,7 @@ GuiMenu::GuiMenu(Window* window)
addChild(&mMenu);
addVersionInfo();
setSize(mMenu.getSize());
setPosition((Renderer::getScreenWidth() - mSize.x()) / 2.0f,
Renderer::getScreenHeight() * 0.13f);
setPosition((Renderer::getScreenWidth() - mSize.x) / 2.0f, Renderer::getScreenHeight() * 0.13f);
}
GuiMenu::~GuiMenu()
@ -97,17 +96,16 @@ void GuiMenu::openUIOptions()
auto startup_system = std::make_shared<OptionListComponent<std::string>>(
mWindow, getHelpStyle(), "GAMELIST ON STARTUP", false);
startup_system->add("NONE", "", Settings::getInstance()->getString("StartupSystem") == "");
float dotsSize = Font::get(FONT_SIZE_MEDIUM)->sizeText("...").x();
float dotsSize = Font::get(FONT_SIZE_MEDIUM)->sizeText("...").x;
for (auto it = SystemData::sSystemVector.cbegin(); it != SystemData::sSystemVector.cend();
it++) {
if ((*it)->getName() != "retropie") {
// If required, abbreviate the system name so it doesn't overlap the setting name.
std::string abbreviatedString =
Font::get(FONT_SIZE_MEDIUM)
->getTextMaxWidth((*it)->getFullName(), mSize.x() * 0.47f);
float sizeDifference = Font::get(FONT_SIZE_MEDIUM)->sizeText((*it)->getFullName()).x() -
Font::get(FONT_SIZE_MEDIUM)->sizeText(abbreviatedString).x();
if (sizeDifference > 0) {
Font::get(FONT_SIZE_MEDIUM)->getTextMaxWidth((*it)->getFullName(), mSize.x * 0.47f);
float sizeDifference = Font::get(FONT_SIZE_MEDIUM)->sizeText((*it)->getFullName()).x -
Font::get(FONT_SIZE_MEDIUM)->sizeText(abbreviatedString).x;
if (sizeDifference > 0.0f) {
// It doesn't make sense to abbreviate if the number of pixels removed by
// the abbreviation is less or equal to the size of the three dots that
// would be appended to the string.
@ -899,7 +897,8 @@ void GuiMenu::openOtherOptions()
Font::get(FONT_SIZE_MEDIUM), 0x777777FF);
auto bracketMediaDirectory = std::make_shared<ImageComponent>(mWindow);
bracketMediaDirectory->setImage(":/graphics/arrow.svg");
bracketMediaDirectory->setResize(Vector2f(0, Font::get(FONT_SIZE_MEDIUM)->getLetterHeight()));
bracketMediaDirectory->setResize(
glm::vec2{0.0f, Font::get(FONT_SIZE_MEDIUM)->getLetterHeight()});
rowMediaDir.addElement(media_directory, true);
rowMediaDir.addElement(bracketMediaDirectory, false);
std::string titleMediaDir = "ENTER GAME MEDIA DIRECTORY";
@ -1259,8 +1258,8 @@ void GuiMenu::openCollectionSystemOptions()
void GuiMenu::onSizeChanged()
{
mVersion.setSize(mSize.x(), 0);
mVersion.setPosition(0, mSize.y() - mVersion.getSize().y());
mVersion.setSize(mSize.x, 0.0f);
mVersion.setPosition(0.0f, mSize.y - mVersion.getSize().y);
}
void GuiMenu::addEntry(const std::string& name,

64
es-app/src/guis/GuiMetaDataEd.cpp
View file

@ -42,7 +42,7 @@ GuiMetaDataEd::GuiMetaDataEd(Window* window,
: GuiComponent(window)
, mScraperParams(scraperParams)
, mBackground(window, ":/graphics/frame.svg")
, mGrid(window, Vector2i(1, 3))
, mGrid(window, glm::ivec2{1, 3})
, mMetaDataDecl(mdd)
, mMetaData(md)
, mSavedCallback(saveCallback)
@ -53,7 +53,7 @@ GuiMetaDataEd::GuiMetaDataEd(Window* window,
addChild(&mBackground);
addChild(&mGrid);
mHeaderGrid = std::make_shared<ComponentGrid>(mWindow, Vector2i(1, 5));
mHeaderGrid = std::make_shared<ComponentGrid>(mWindow, glm::ivec2{1, 5});
mTitle = std::make_shared<TextComponent>(mWindow, "EDIT METADATA", Font::get(FONT_SIZE_LARGE),
0x555555FF, ALIGN_CENTER);
@ -78,15 +78,15 @@ GuiMetaDataEd::GuiMetaDataEd(Window* window,
folderPath + Utils::FileSystem::getFileName(scraperParams.game->getPath()) + " [" +
Utils::String::toUpper(scraperParams.system->getName()) + "]" +
(scraperParams.game->getType() == FOLDER ? " " + ViewController::FOLDER_CHAR : ""),
Font::get(FONT_SIZE_SMALL), 0x777777FF, ALIGN_CENTER, Vector3f(0.0f, 0.0f, 0.0f),
Vector2f(0.0f, 0.0f), 0x00000000, 0.05f);
mHeaderGrid->setEntry(mTitle, Vector2i(0, 1), false, true);
mHeaderGrid->setEntry(mSubtitle, Vector2i(0, 3), false, true);
Font::get(FONT_SIZE_SMALL), 0x777777FF, ALIGN_CENTER, glm::vec3{}, glm::vec2{}, 0x00000000,
0.05f);
mHeaderGrid->setEntry(mTitle, glm::ivec2{0, 1}, false, true);
mHeaderGrid->setEntry(mSubtitle, glm::ivec2{0, 3}, false, true);
mGrid.setEntry(mHeaderGrid, Vector2i(0, 0), false, true);
mGrid.setEntry(mHeaderGrid, glm::ivec2{0, 0}, false, true);
mList = std::make_shared<ComponentList>(mWindow);
mGrid.setEntry(mList, Vector2i(0, 1), true, true);
mGrid.setEntry(mList, glm::ivec2{0, 1}, true, true);
// Populate list.
for (auto iter = mdd.cbegin(); iter != mdd.cend(); iter++) {
@ -123,8 +123,8 @@ GuiMetaDataEd::GuiMetaDataEd(Window* window,
case MD_BOOL: {
ed = std::make_shared<SwitchComponent>(window);
// Make the switches slightly smaller.
auto switchSize = ed->getSize() * 0.9f;
ed->setResize(switchSize.x(), switchSize.y());
glm::vec2 switchSize{ed->getSize() * 0.9f};
ed->setResize(switchSize.x, switchSize.y);
ed->setOrigin(-0.05f, -0.09f);
ed->setChangedColor(ICONCOLOR_USERMARKED);
@ -138,8 +138,8 @@ GuiMetaDataEd::GuiMetaDataEd(Window* window,
ed = std::make_shared<RatingComponent>(window, true);
ed->setChangedColor(ICONCOLOR_USERMARKED);
const float height = lbl->getSize().y() * 0.71f;
ed->setSize(0, height);
const float height = lbl->getSize().y * 0.71f;
ed->setSize(0.0f, height);
row.addElement(ed, false, true);
auto ratingSpacer = std::make_shared<GuiComponent>(mWindow);
@ -182,7 +182,7 @@ GuiMetaDataEd::GuiMetaDataEd(Window* window,
auto bracket = std::make_shared<ImageComponent>(mWindow);
bracket->setImage(":/graphics/arrow.svg");
bracket->setResize(Vector2f(0, lbl->getFont()->getLetterHeight()));
bracket->setResize(glm::vec2{0.0f, lbl->getFont()->getLetterHeight()});
row.addElement(bracket, false);
bool multiLine = false;
@ -223,7 +223,7 @@ GuiMetaDataEd::GuiMetaDataEd(Window* window,
auto bracket = std::make_shared<ImageComponent>(mWindow);
bracket->setImage(":/graphics/arrow.svg");
bracket->setResize(Vector2f(0, lbl->getFont()->getLetterHeight()));
bracket->setResize(glm::vec2{0.0f, lbl->getFont()->getLetterHeight()});
row.addElement(bracket, false);
bool multiLine = iter->type == MD_MULTILINE_STRING;
@ -346,15 +346,15 @@ GuiMetaDataEd::GuiMetaDataEd(Window* window,
}
mButtons = makeButtonGrid(mWindow, buttons);
mGrid.setEntry(mButtons, Vector2i(0, 2), true, false);
mGrid.setEntry(mButtons, glm::ivec2{0, 2}, true, false);
// Resize + center.
float width =
static_cast<float>(std::min(static_cast<int>(Renderer::getScreenHeight() * 1.05f),
static_cast<int>(Renderer::getScreenWidth() * 0.90f)));
setSize(width, Renderer::getScreenHeight() * 0.83f);
setPosition((Renderer::getScreenWidth() - mSize.x()) / 2.0f,
(Renderer::getScreenHeight() - mSize.y()) / 2.0f);
setPosition((Renderer::getScreenWidth() - mSize.x) / 2.0f,
(Renderer::getScreenHeight() - mSize.y) / 2.0f);
}
void GuiMetaDataEd::onSizeChanged()
@ -363,19 +363,19 @@ void GuiMetaDataEd::onSizeChanged()
const float titleHeight = mTitle->getFont()->getLetterHeight();
const float subtitleHeight = mSubtitle->getFont()->getLetterHeight();
const float titleSubtitleSpacing = mSize.y() * 0.03f;
const float titleSubtitleSpacing = mSize.y * 0.03f;
mGrid.setRowHeightPerc(
0, (titleHeight + titleSubtitleSpacing + subtitleHeight + TITLE_VERT_PADDING) / mSize.y());
mGrid.setRowHeightPerc(2, mButtons->getSize().y() / mSize.y());
0, (titleHeight + titleSubtitleSpacing + subtitleHeight + TITLE_VERT_PADDING) / mSize.y);
mGrid.setRowHeightPerc(2, mButtons->getSize().y / mSize.y);
// Snap list size to the row height to prevent a fraction of a row from being displayed.
float listHeight = 0;
float listSize = mList->getSize().y();
float listHeight = 0.0f;
float listSize = mList->getSize().y;
int i = 0;
while (i < mList->size()) {
// Add the separator height to the row height so that it also gets properly rendered.
float rowHeight = mList->getRowHeight(i) + (1 * Renderer::getScreenHeightModifier());
float rowHeight = mList->getRowHeight(i) + Renderer::getScreenHeightModifier();
if (listHeight + rowHeight < listSize)
listHeight += rowHeight;
else
@ -385,19 +385,19 @@ void GuiMetaDataEd::onSizeChanged()
// Adjust the size of the list and window.
float heightAdjustment = listSize - listHeight;
mList->setSize(mList->getSize().x(), listHeight);
Vector2f newWindowSize = mSize;
newWindowSize.y() -= heightAdjustment;
mBackground.fitTo(newWindowSize, Vector3f::Zero(), Vector2f(-32.0f, -32.0f));
mList->setSize(mList->getSize().x, listHeight);
glm::vec2 newWindowSize{mSize};
newWindowSize.y -= heightAdjustment;
mBackground.fitTo(newWindowSize, glm::vec3{}, glm::vec2{-32.0f, -32.0f});
// Move the buttons up as well to make the layout align correctly after the resize.
Vector3f newButtonPos = mButtons->getPosition();
newButtonPos.y() -= heightAdjustment;
glm::vec3 newButtonPos{mButtons->getPosition()};
newButtonPos.y -= heightAdjustment;
mButtons->setPosition(newButtonPos);
mHeaderGrid->setRowHeightPerc(1, titleHeight / mHeaderGrid->getSize().y());
mHeaderGrid->setRowHeightPerc(2, titleSubtitleSpacing / mHeaderGrid->getSize().y());
mHeaderGrid->setRowHeightPerc(3, subtitleHeight / mHeaderGrid->getSize().y());
mHeaderGrid->setRowHeightPerc(1, titleHeight / mHeaderGrid->getSize().y);
mHeaderGrid->setRowHeightPerc(2, titleSubtitleSpacing / mHeaderGrid->getSize().y);
mHeaderGrid->setRowHeightPerc(3, subtitleHeight / mHeaderGrid->getSize().y);
}
void GuiMetaDataEd::save()

70
es-app/src/guis/GuiOfflineGenerator.cpp
View file

@ -16,7 +16,7 @@
GuiOfflineGenerator::GuiOfflineGenerator(Window* window, const std::queue<FileData*>& gameQueue)
: GuiComponent(window)
, mBackground(window, ":/graphics/frame.svg")
, mGrid(window, Vector2i(6, 13))
, mGrid(window, glm::ivec2{6, 13})
, mGameQueue(gameQueue)
{
addChild(&mBackground);
@ -38,100 +38,100 @@ GuiOfflineGenerator::GuiOfflineGenerator(Window* window, const std::queue<FileDa
// Header.
mTitle = std::make_shared<TextComponent>(mWindow, "MIXIMAGE OFFLINE GENERATOR",
Font::get(FONT_SIZE_LARGE), 0x555555FF, ALIGN_CENTER);
mGrid.setEntry(mTitle, Vector2i(0, 0), false, true, Vector2i(6, 1));
mGrid.setEntry(mTitle, glm::ivec2{0, 0}, false, true, glm::ivec2{6, 1});
mStatus = std::make_shared<TextComponent>(mWindow, "NOT STARTED", Font::get(FONT_SIZE_MEDIUM),
0x777777FF, ALIGN_CENTER);
mGrid.setEntry(mStatus, Vector2i(0, 1), false, true, Vector2i(6, 1));
mGrid.setEntry(mStatus, glm::ivec2{0, 1}, false, true, glm::ivec2{6, 1});
mGameCounter = std::make_shared<TextComponent>(
mWindow,
std::to_string(mGamesProcessed) + " OF " + std::to_string(mTotalGames) +
(mTotalGames == 1 ? " GAME " : " GAMES ") + "PROCESSED",
Font::get(FONT_SIZE_SMALL), 0x888888FF, ALIGN_CENTER);
mGrid.setEntry(mGameCounter, Vector2i(0, 2), false, true, Vector2i(6, 1));
mGrid.setEntry(mGameCounter, glm::ivec2{0, 2}, false, true, glm::ivec2{6, 1});
// Spacer row with top border.
mGrid.setEntry(std::make_shared<GuiComponent>(mWindow), Vector2i(0, 3), false, false,
Vector2i(6, 1), GridFlags::BORDER_TOP);
mGrid.setEntry(std::make_shared<GuiComponent>(mWindow), glm::ivec2{0, 3}, false, false,
glm::ivec2{6, 1}, GridFlags::BORDER_TOP);
// Left spacer.
mGrid.setEntry(std::make_shared<GuiComponent>(mWindow), Vector2i(0, 4), false, false,
Vector2i(1, 7));
mGrid.setEntry(std::make_shared<GuiComponent>(mWindow), glm::ivec2{0, 4}, false, false,
glm::ivec2{1, 7});
// Generated label.
mGeneratedLbl = std::make_shared<TextComponent>(
mWindow, "Generated:", Font::get(FONT_SIZE_SMALL), 0x888888FF, ALIGN_LEFT);
mGrid.setEntry(mGeneratedLbl, Vector2i(1, 4), false, true, Vector2i(1, 1));
mGrid.setEntry(mGeneratedLbl, glm::ivec2{1, 4}, false, true, glm::ivec2{1, 1});
// Generated value/counter.
mGeneratedVal =
std::make_shared<TextComponent>(mWindow, std::to_string(mGamesProcessed),
Font::get(FONT_SIZE_SMALL), 0x888888FF, ALIGN_LEFT);
mGrid.setEntry(mGeneratedVal, Vector2i(2, 4), false, true, Vector2i(1, 1));
mGrid.setEntry(mGeneratedVal, glm::ivec2{2, 4}, false, true, glm::ivec2{1, 1});
// Overwritten label.
mOverwrittenLbl = std::make_shared<TextComponent>(
mWindow, "Overwritten:", Font::get(FONT_SIZE_SMALL), 0x888888FF, ALIGN_LEFT);
mGrid.setEntry(mOverwrittenLbl, Vector2i(1, 5), false, true, Vector2i(1, 1));
mGrid.setEntry(mOverwrittenLbl, glm::ivec2{1, 5}, false, true, glm::ivec2{1, 1});
// Overwritten value/counter.
mOverwrittenVal =
std::make_shared<TextComponent>(mWindow, std::to_string(mImagesOverwritten),
Font::get(FONT_SIZE_SMALL), 0x888888FF, ALIGN_LEFT);
mGrid.setEntry(mOverwrittenVal, Vector2i(2, 5), false, true, Vector2i(1, 1));
mGrid.setEntry(mOverwrittenVal, glm::ivec2{2, 5}, false, true, glm::ivec2{1, 1});
// Skipping label.
mSkippedLbl = std::make_shared<TextComponent>(
mWindow, "Skipped (existing):", Font::get(FONT_SIZE_SMALL), 0x888888FF, ALIGN_LEFT);
mGrid.setEntry(mSkippedLbl, Vector2i(1, 6), false, true, Vector2i(1, 1));
mGrid.setEntry(mSkippedLbl, glm::ivec2{1, 6}, false, true, glm::ivec2{1, 1});
// Skipping value/counter.
mSkippedVal = std::make_shared<TextComponent>(
mWindow, std::to_string(mGamesSkipped), Font::get(FONT_SIZE_SMALL), 0x888888FF, ALIGN_LEFT);
mGrid.setEntry(mSkippedVal, Vector2i(2, 6), false, true, Vector2i(1, 1));
mGrid.setEntry(mSkippedVal, glm::ivec2{2, 6}, false, true, glm::ivec2{1, 1});
// Failed label.
mFailedLbl = std::make_shared<TextComponent>(mWindow, "Failed:", Font::get(FONT_SIZE_SMALL),
0x888888FF, ALIGN_LEFT);
mGrid.setEntry(mFailedLbl, Vector2i(1, 7), false, true, Vector2i(1, 1));
mGrid.setEntry(mFailedLbl, glm::ivec2{1, 7}, false, true, glm::ivec2{1, 1});
// Failed value/counter.
mFailedVal = std::make_shared<TextComponent>(
mWindow, std::to_string(mGamesFailed), Font::get(FONT_SIZE_SMALL), 0x888888FF, ALIGN_LEFT);
mGrid.setEntry(mFailedVal, Vector2i(2, 7), false, true, Vector2i(1, 1));
mGrid.setEntry(mFailedVal, glm::ivec2{2, 7}, false, true, glm::ivec2{1, 1});
// Processing label.
mProcessingLbl = std::make_shared<TextComponent>(
mWindow, "Processing: ", Font::get(FONT_SIZE_SMALL), 0x888888FF, ALIGN_LEFT);
mGrid.setEntry(mProcessingLbl, Vector2i(3, 4), false, true, Vector2i(1, 1));
mGrid.setEntry(mProcessingLbl, glm::ivec2{3, 4}, false, true, glm::ivec2{1, 1});
// Processing value.
mProcessingVal = std::make_shared<TextComponent>(mWindow, "", Font::get(FONT_SIZE_SMALL),
0x888888FF, ALIGN_LEFT);
mGrid.setEntry(mProcessingVal, Vector2i(4, 4), false, true, Vector2i(1, 1));
mGrid.setEntry(mProcessingVal, glm::ivec2{4, 4}, false, true, glm::ivec2{1, 1});
// Spacer row.
mGrid.setEntry(std::make_shared<GuiComponent>(mWindow), Vector2i(1, 8), false, false,
Vector2i(4, 1));
mGrid.setEntry(std::make_shared<GuiComponent>(mWindow), glm::ivec2{1, 8}, false, false,
glm::ivec2{4, 1});
// Last error message label.
mLastErrorLbl = std::make_shared<TextComponent>(
mWindow, "Last error message:", Font::get(FONT_SIZE_SMALL), 0x888888FF, ALIGN_LEFT);
mGrid.setEntry(mLastErrorLbl, Vector2i(1, 9), false, true, Vector2i(4, 1));
mGrid.setEntry(mLastErrorLbl, glm::ivec2{1, 9}, false, true, glm::ivec2{4, 1});
// Last error message value.
mLastErrorVal = std::make_shared<TextComponent>(mWindow, "", Font::get(FONT_SIZE_SMALL),
0x888888FF, ALIGN_LEFT);
mGrid.setEntry(mLastErrorVal, Vector2i(1, 10), false, true, Vector2i(4, 1));
mGrid.setEntry(mLastErrorVal, glm::ivec2{1, 10}, false, true, glm::ivec2{4, 1});
// Right spacer.
mGrid.setEntry(std::make_shared<GuiComponent>(mWindow), Vector2i(5, 4), false, false,
Vector2i(1, 7));
mGrid.setEntry(std::make_shared<GuiComponent>(mWindow), glm::ivec2{5, 4}, false, false,
glm::ivec2{1, 7});
// Spacer row with bottom border.
mGrid.setEntry(std::make_shared<GuiComponent>(mWindow), Vector2i(0, 11), false, false,
Vector2i(6, 1), GridFlags::BORDER_BOTTOM);
mGrid.setEntry(std::make_shared<GuiComponent>(mWindow), glm::ivec2{0, 11}, false, false,
glm::ivec2{6, 1}, GridFlags::BORDER_BOTTOM);
// Buttons.
std::vector<std::shared_ptr<ButtonComponent>> buttons;
@ -177,7 +177,7 @@ GuiOfflineGenerator::GuiOfflineGenerator(Window* window, const std::queue<FileDa
buttons.push_back(mCloseButton);
mButtonGrid = makeButtonGrid(mWindow, buttons);
mGrid.setEntry(mButtonGrid, Vector2i(0, 12), true, false, Vector2i(6, 1));
mGrid.setEntry(mButtonGrid, glm::ivec2{0, 12}, true, false, glm::ivec2{6, 1});
// For narrower displays (e.g. in 4:3 ratio), allow the window to fill 95% of the screen
// width rather than the 85% allowed for wider displays.
@ -185,8 +185,8 @@ GuiOfflineGenerator::GuiOfflineGenerator(Window* window, const std::queue<FileDa
Renderer::getScreenWidth() * ((Renderer::getScreenAspectRatio() < 1.4f) ? 0.95f : 0.85f);
setSize(width, Renderer::getScreenHeight() * 0.75f);
setPosition((Renderer::getScreenWidth() - mSize.x()) / 2.0f,
(Renderer::getScreenHeight() - mSize.y()) / 2.0f);
setPosition((Renderer::getScreenWidth() - mSize.x) / 2.0f,
(Renderer::getScreenHeight() - mSize.y) / 2.0f);
}
GuiOfflineGenerator::~GuiOfflineGenerator()
@ -203,13 +203,13 @@ GuiOfflineGenerator::~GuiOfflineGenerator()
void GuiOfflineGenerator::onSizeChanged()
{
mBackground.fitTo(mSize, Vector3f::Zero(), Vector2f(-32.0f, -32.0f));
mBackground.fitTo(mSize, glm::vec3{}, glm::vec2{-32.0f, -32.0f});
// Set row heights.
mGrid.setRowHeightPerc(0, mTitle->getFont()->getLetterHeight() * 1.9725f / mSize.y(), false);
mGrid.setRowHeightPerc(1, (mStatus->getFont()->getLetterHeight() + 2.0f) / mSize.y(), false);
mGrid.setRowHeightPerc(2, mGameCounter->getFont()->getHeight() * 1.75f / mSize.y(), false);
mGrid.setRowHeightPerc(3, (mStatus->getFont()->getLetterHeight() + 3.0f) / mSize.y(), false);
mGrid.setRowHeightPerc(0, mTitle->getFont()->getLetterHeight() * 1.9725f / mSize.y, false);
mGrid.setRowHeightPerc(1, (mStatus->getFont()->getLetterHeight() + 2.0f) / mSize.y, false);
mGrid.setRowHeightPerc(2, mGameCounter->getFont()->getHeight() * 1.75f / mSize.y, false);
mGrid.setRowHeightPerc(3, (mStatus->getFont()->getLetterHeight() + 3.0f) / mSize.y, false);
mGrid.setRowHeightPerc(4, 0.07f, false);
mGrid.setRowHeightPerc(5, 0.07f, false);
mGrid.setRowHeightPerc(6, 0.07f, false);
@ -217,7 +217,7 @@ void GuiOfflineGenerator::onSizeChanged()
mGrid.setRowHeightPerc(8, 0.02f, false);
mGrid.setRowHeightPerc(9, 0.07f, false);
mGrid.setRowHeightPerc(10, 0.07f, false);
mGrid.setRowHeightPerc(12, mButtonGrid->getSize().y() / mSize.y(), false);
mGrid.setRowHeightPerc(12, mButtonGrid->getSize().y / mSize.y, false);
// Set column widths.
mGrid.setColWidthPerc(0, 0.03f);

3
es-app/src/guis/GuiScraperMenu.cpp
View file

@ -140,8 +140,7 @@ GuiScraperMenu::GuiScraperMenu(Window* window, std::string title)
setSize(mMenu.getSize());
setPosition((Renderer::getScreenWidth() - mSize.x()) / 2.0f,
Renderer::getScreenHeight() * 0.13f);
setPosition((Renderer::getScreenWidth() - mSize.x) / 2.0f, Renderer::getScreenHeight() * 0.13f);
}
GuiScraperMenu::~GuiScraperMenu()

26
es-app/src/guis/GuiScraperMulti.cpp
View file

@ -28,7 +28,7 @@ GuiScraperMulti::GuiScraperMulti(Window* window,
bool approveResults)
: GuiComponent(window)
, mBackground(window, ":/graphics/frame.svg")
, mGrid(window, Vector2i(1, 5))
, mGrid(window, glm::ivec2{1, 5})
, mSearchQueue(searches)
, mApproveResults(approveResults)
{
@ -47,15 +47,15 @@ GuiScraperMulti::GuiScraperMulti(Window* window,
// Set up grid.
mTitle = std::make_shared<TextComponent>(mWindow, "SCRAPING IN PROGRESS",
Font::get(FONT_SIZE_LARGE), 0x555555FF, ALIGN_CENTER);
mGrid.setEntry(mTitle, Vector2i(0, 0), false, true);
mGrid.setEntry(mTitle, glm::ivec2{0, 0}, false, true);
mSystem = std::make_shared<TextComponent>(mWindow, "SYSTEM", Font::get(FONT_SIZE_MEDIUM),
0x777777FF, ALIGN_CENTER);
mGrid.setEntry(mSystem, Vector2i(0, 1), false, true);
mGrid.setEntry(mSystem, glm::ivec2{0, 1}, false, true);
mSubtitle = std::make_shared<TextComponent>(
mWindow, "subtitle text", Font::get(FONT_SIZE_SMALL), 0x888888FF, ALIGN_CENTER);
mGrid.setEntry(mSubtitle, Vector2i(0, 2), false, true);
mGrid.setEntry(mSubtitle, glm::ivec2{0, 2}, false, true);
if (mApproveResults && !Settings::getInstance()->getBool("ScraperSemiautomatic"))
mSearchComp = std::make_shared<GuiScraperSearch>(
@ -70,7 +70,7 @@ GuiScraperMulti::GuiScraperMulti(Window* window,
std::bind(&GuiScraperMulti::acceptResult, this, std::placeholders::_1));
mSearchComp->setSkipCallback(std::bind(&GuiScraperMulti::skip, this));
mSearchComp->setCancelCallback(std::bind(&GuiScraperMulti::finish, this));
mGrid.setEntry(mSearchComp, Vector2i(0, 3),
mGrid.setEntry(mSearchComp, glm::ivec2{0, 3},
mSearchComp->getSearchType() != GuiScraperSearch::ALWAYS_ACCEPT_FIRST_RESULT,
true);
@ -102,7 +102,7 @@ GuiScraperMulti::GuiScraperMulti(Window* window,
std::bind(&GuiScraperMulti::finish, this)));
mButtonGrid = makeButtonGrid(mWindow, buttons);
mGrid.setEntry(mButtonGrid, Vector2i(0, 4), true, false);
mGrid.setEntry(mButtonGrid, glm::ivec2{0, 4}, true, false);
// Limit the width of the GUI on ultrawide monitors. The 1.778 aspect ratio value is
// the 16:9 reference.
@ -110,8 +110,8 @@ GuiScraperMulti::GuiScraperMulti(Window* window,
float width = Math::clamp(0.95f * aspectValue, 0.70f, 0.95f) * Renderer::getScreenWidth();
setSize(width, Renderer::getScreenHeight() * 0.849f);
setPosition((Renderer::getScreenWidth() - mSize.x()) / 2.0f,
(Renderer::getScreenHeight() - mSize.y()) / 2.0f);
setPosition((Renderer::getScreenWidth() - mSize.x) / 2.0f,
(Renderer::getScreenHeight() - mSize.y) / 2.0f);
doNextSearch();
}
@ -130,12 +130,12 @@ GuiScraperMulti::~GuiScraperMulti()
void GuiScraperMulti::onSizeChanged()
{
mBackground.fitTo(mSize, Vector3f::Zero(), Vector2f(-32.0f, -32.0f));
mBackground.fitTo(mSize, glm::vec3{}, glm::vec2{-32.0f, -32.0f});
mGrid.setRowHeightPerc(0, mTitle->getFont()->getLetterHeight() * 1.9725f / mSize.y(), false);
mGrid.setRowHeightPerc(1, (mSystem->getFont()->getLetterHeight() + 2.0f) / mSize.y(), false);
mGrid.setRowHeightPerc(2, mSubtitle->getFont()->getHeight() * 1.75f / mSize.y(), false);
mGrid.setRowHeightPerc(4, mButtonGrid->getSize().y() / mSize.y(), false);
mGrid.setRowHeightPerc(0, mTitle->getFont()->getLetterHeight() * 1.9725f / mSize.y, false);
mGrid.setRowHeightPerc(1, (mSystem->getFont()->getLetterHeight() + 2.0f) / mSize.y, false);
mGrid.setRowHeightPerc(2, mSubtitle->getFont()->getHeight() * 1.75f / mSize.y, false);
mGrid.setRowHeightPerc(4, mButtonGrid->getSize().y / mSize.y, false);
mGrid.setSize(mSize);
}

85
es-app/src/guis/GuiScraperSearch.cpp
View file

@ -38,7 +38,7 @@
GuiScraperSearch::GuiScraperSearch(Window* window, SearchType type, unsigned int scrapeCount)
: GuiComponent(window)
, mGrid(window, Vector2i(4, 3))
, mGrid(window, glm::ivec2{4, 3})
, mBusyAnim(window)
, mSearchType(type)
, mScrapeCount(scrapeCount)
@ -54,8 +54,8 @@ GuiScraperSearch::GuiScraperSearch(Window* window, SearchType type, unsigned int
mRetryCount = 0;
// Left spacer (empty component, needed for borders).
mGrid.setEntry(std::make_shared<GuiComponent>(mWindow), Vector2i(0, 0), false, false,
Vector2i(1, 3), GridFlags::BORDER_TOP | GridFlags::BORDER_BOTTOM);
mGrid.setEntry(std::make_shared<GuiComponent>(mWindow), glm::ivec2{0, 0}, false, false,
glm::ivec2{1, 3}, GridFlags::BORDER_TOP | GridFlags::BORDER_BOTTOM);
// Selected result name.
mResultName = std::make_shared<TextComponent>(mWindow, "Result name",
@ -63,7 +63,7 @@ GuiScraperSearch::GuiScraperSearch(Window* window, SearchType type, unsigned int
// Selected result thumbnail.
mResultThumbnail = std::make_shared<ImageComponent>(mWindow);
mGrid.setEntry(mResultThumbnail, Vector2i(1, 1), false, false, Vector2i(1, 1));
mGrid.setEntry(mResultThumbnail, glm::ivec2{1, 1}, false, false, glm::ivec2{1, 1});
// Selected result description and container.
mDescContainer = std::make_shared<ScrollableContainer>(mWindow);
@ -87,18 +87,14 @@ GuiScraperSearch::GuiScraperSearch(Window* window, SearchType type, unsigned int
mMD_ReleaseDate = std::make_shared<DateTimeEditComponent>(mWindow);
mMD_ReleaseDate->setColor(mdColor);
mMD_ReleaseDate->setUppercase(true);
mMD_Developer =
std::make_shared<TextComponent>(mWindow, "", font, mdColor, ALIGN_LEFT, Vector3f::Zero(),
Vector2f::Zero(), 0x00000000, 0.02f);
mMD_Publisher =
std::make_shared<TextComponent>(mWindow, "", font, mdColor, ALIGN_LEFT, Vector3f::Zero(),
Vector2f::Zero(), 0x00000000, 0.02f);
mMD_Genre =
std::make_shared<TextComponent>(mWindow, "", font, mdColor, ALIGN_LEFT, Vector3f::Zero(),
Vector2f::Zero(), 0x00000000, 0.02f);
mMD_Players =
std::make_shared<TextComponent>(mWindow, "", font, mdColor, ALIGN_LEFT, Vector3f::Zero(),
Vector2f::Zero(), 0x00000000, 0.02f);
mMD_Developer = std::make_shared<TextComponent>(mWindow, "", font, mdColor, ALIGN_LEFT,
glm::vec3{}, glm::vec2{}, 0x00000000, 0.02f);
mMD_Publisher = std::make_shared<TextComponent>(mWindow, "", font, mdColor, ALIGN_LEFT,
glm::vec3{}, glm::vec2{}, 0x00000000, 0.02f);
mMD_Genre = std::make_shared<TextComponent>(mWindow, "", font, mdColor, ALIGN_LEFT, glm::vec3{},
glm::vec2{}, 0x00000000, 0.02f);
mMD_Players = std::make_shared<TextComponent>(mWindow, "", font, mdColor, ALIGN_LEFT,
glm::vec3{}, glm::vec2{}, 0x00000000, 0.02f);
mMD_Filler = std::make_shared<TextComponent>(mWindow, "", font, mdColor);
if (Settings::getInstance()->getString("Scraper") != "thegamesdb")
@ -127,15 +123,15 @@ GuiScraperSearch::GuiScraperSearch(Window* window, SearchType type, unsigned int
std::make_shared<TextComponent>(mWindow, "", font, mdLblColor), mMD_Filler));
mMD_Grid = std::make_shared<ComponentGrid>(
mWindow, Vector2i(2, static_cast<int>(mMD_Pairs.size() * 2 - 1)));
mWindow, glm::ivec2{2, static_cast<int>(mMD_Pairs.size() * 2 - 1)});
unsigned int i = 0;
for (auto it = mMD_Pairs.cbegin(); it != mMD_Pairs.cend(); it++) {
mMD_Grid->setEntry(it->first, Vector2i(0, i), false, true);
mMD_Grid->setEntry(it->second, Vector2i(1, i), false, it->resize);
mMD_Grid->setEntry(it->first, glm::ivec2{0, i}, false, true);
mMD_Grid->setEntry(it->second, glm::ivec2{1, i}, false, it->resize);
i += 2;
}
mGrid.setEntry(mMD_Grid, Vector2i(2, 1), false, false);
mGrid.setEntry(mMD_Grid, glm::ivec2{2, 1}, false, false);
// Result list.
mResultList = std::make_shared<ComponentList>(mWindow);
@ -184,7 +180,7 @@ void GuiScraperSearch::onSizeChanged()
{
mGrid.setSize(mSize);
if (mSize.x() == 0 || mSize.y() == 0)
if (mSize.x == 0 || mSize.y == 0)
return;
// Column widths.
@ -203,7 +199,7 @@ void GuiScraperSearch::onSizeChanged()
// Row heights.
if (mSearchType == ALWAYS_ACCEPT_FIRST_RESULT) // Show name.
mGrid.setRowHeightPerc(0, (mResultName->getFont()->getHeight() * 1.6f) /
mGrid.getSize().y()); // Result name.
mGrid.getSize().y); // Result name.
else
mGrid.setRowHeightPerc(0, 0.0825f); // Hide name but do padding.
@ -230,11 +226,11 @@ void GuiScraperSearch::onSizeChanged()
mResultDesc->getFont()->getHeight() * 6.0f);
// Make description text wrap at edge of container.
mResultDesc->setSize(mDescContainer->getSize().x(), 0);
mResultDesc->setSize(mDescContainer->getSize().x, 0.0f);
// Set the width of mResultName to the cell width so that text abbreviation will work correctly.
Vector2f resultNameSize = mResultName->getSize();
mResultName->setSize(mGrid.getColWidth(3), resultNameSize.y());
glm::vec2 resultNameSize{mResultName->getSize()};
mResultName->setSize(mGrid.getColWidth(3), resultNameSize.y);
mGrid.onSizeChanged();
mBusyAnim.setSize(mSize);
@ -243,8 +239,8 @@ void GuiScraperSearch::onSizeChanged()
void GuiScraperSearch::resizeMetadata()
{
mMD_Grid->setSize(mGrid.getColWidth(2), mGrid.getRowHeight(1));
if (mMD_Grid->getSize().y() > mMD_Pairs.size()) {
const int fontHeight = static_cast<int>(mMD_Grid->getSize().y() / mMD_Pairs.size() * 0.8f);
if (mMD_Grid->getSize().y > mMD_Pairs.size()) {
const int fontHeight = static_cast<int>(mMD_Grid->getSize().y / mMD_Pairs.size() * 0.8f);
auto fontLbl = Font::get(fontHeight, FONT_PATH_REGULAR);
auto fontComp = Font::get(fontHeight, FONT_PATH_LIGHT);
@ -253,15 +249,14 @@ void GuiScraperSearch::resizeMetadata()
for (auto it = mMD_Pairs.cbegin(); it != mMD_Pairs.cend(); it++) {
it->first->setFont(fontLbl);
it->first->setSize(0, 0);
if (it->first->getSize().x() > maxLblWidth)
maxLblWidth =
it->first->getSize().x() + (16.0f * Renderer::getScreenWidthModifier());
if (it->first->getSize().x > maxLblWidth)
maxLblWidth = it->first->getSize().x + (16.0f * Renderer::getScreenWidthModifier());
}
for (unsigned int i = 0; i < mMD_Pairs.size(); i++)
mMD_Grid->setRowHeightPerc(
i * 2, (fontLbl->getLetterHeight() + (2.0f * Renderer::getScreenHeightModifier())) /
mMD_Grid->getSize().y());
mMD_Grid->getSize().y);
// Update component fonts.
mMD_ReleaseDate->setFont(fontComp);
@ -270,7 +265,7 @@ void GuiScraperSearch::resizeMetadata()
mMD_Genre->setFont(fontComp);
mMD_Players->setFont(fontComp);
mMD_Grid->setColWidthPerc(0, maxLblWidth / mMD_Grid->getSize().x());
mMD_Grid->setColWidthPerc(0, maxLblWidth / mMD_Grid->getSize().x);
if (mScrapeRatings) {
// Rating is manually sized.
@ -293,33 +288,33 @@ void GuiScraperSearch::updateViewStyle()
// Add them back depending on search type.
if (mSearchType == ALWAYS_ACCEPT_FIRST_RESULT) {
// Show name.
mGrid.setEntry(mResultName, Vector2i(1, 0), false, false, Vector2i(2, 1),
mGrid.setEntry(mResultName, glm::ivec2{1, 0}, false, false, glm::ivec2{2, 1},
GridFlags::BORDER_TOP);
// Need a border on the bottom left.
mGrid.setEntry(std::make_shared<GuiComponent>(mWindow), Vector2i(0, 2), false, false,
Vector2i(3, 1), GridFlags::BORDER_BOTTOM);
mGrid.setEntry(std::make_shared<GuiComponent>(mWindow), glm::ivec2{0, 2}, false, false,
glm::ivec2{3, 1}, GridFlags::BORDER_BOTTOM);
// Show description on the right.
mGrid.setEntry(mDescContainer, Vector2i(3, 0), false, false, Vector2i(1, 3),
mGrid.setEntry(mDescContainer, glm::ivec2{3, 0}, false, false, glm::ivec2{1, 3},
GridFlags::BORDER_TOP | GridFlags::BORDER_BOTTOM);
// Make description text wrap at edge of container.
mResultDesc->setSize(mDescContainer->getSize().x(), 0.0f);
mResultDesc->setSize(mDescContainer->getSize().x, 0.0f);
}
else {
// Fake row where name would be.
mGrid.setEntry(std::make_shared<GuiComponent>(mWindow), Vector2i(1, 0), false, true,
Vector2i(2, 1), GridFlags::BORDER_TOP);
mGrid.setEntry(std::make_shared<GuiComponent>(mWindow), glm::ivec2{1, 0}, false, true,
glm::ivec2{2, 1}, GridFlags::BORDER_TOP);
// Show result list on the right.
mGrid.setEntry(mResultList, Vector2i(3, 0), true, true, Vector2i(1, 3),
mGrid.setEntry(mResultList, glm::ivec2{3, 0}, true, true, glm::ivec2{1, 3},
GridFlags::BORDER_LEFT | GridFlags::BORDER_TOP | GridFlags::BORDER_BOTTOM);
// Show description under image/info.
mGrid.setEntry(mDescContainer, Vector2i(1, 2), false, false, Vector2i(2, 1),
mGrid.setEntry(mDescContainer, glm::ivec2{1, 2}, false, false, glm::ivec2{2, 1},
GridFlags::BORDER_BOTTOM);
// Make description text wrap at edge of container.
mResultDesc->setSize(mDescContainer->getSize().x(), 0);
mResultDesc->setSize(mDescContainer->getSize().x, 0);
}
}
@ -565,12 +560,12 @@ bool GuiScraperSearch::input(InputConfig* config, Input input)
return GuiComponent::input(config, input);
}
void GuiScraperSearch::render(const Transform4x4f& parentTrans)
void GuiScraperSearch::render(const glm::mat4& parentTrans)
{
Transform4x4f trans = parentTrans * getTransform();
glm::mat4 trans{parentTrans * getTransform()};
renderChildren(trans);
Renderer::drawRect(0.0f, 0.0f, mSize.x(), mSize.y(), 0x00000009, 0x00000009);
Renderer::drawRect(0.0f, 0.0f, mSize.x, mSize.y, 0x00000009, 0x00000009);
if (mBlockAccept) {
Renderer::setMatrix(trans);

2
es-app/src/guis/GuiScraperSearch.h
View file

@ -75,7 +75,7 @@ public:
bool input(InputConfig* config, Input input) override;
void update(int deltaTime) override;
void render(const Transform4x4f& parentTrans) override;
void render(const glm::mat4& parentTrans) override;
std::vector<HelpPrompt> getHelpPrompts() override;
HelpStyle getHelpStyle() override;
void onSizeChanged() override;

5
es-app/src/guis/GuiSettings.cpp
View file

@ -41,8 +41,7 @@ GuiSettings::GuiSettings(Window* window, std::string title)
setSize(static_cast<float>(Renderer::getScreenWidth()),
static_cast<float>(Renderer::getScreenHeight()));
mMenu.setPosition((mSize.x() - mMenu.getSize().x()) / 2.0f,
Renderer::getScreenHeight() * 0.13f);
mMenu.setPosition((mSize.x - mMenu.getSize().x) / 2.0f, Renderer::getScreenHeight() * 0.13f);
}
GuiSettings::~GuiSettings()
@ -171,7 +170,7 @@ void GuiSettings::addEditableTextComponent(const std::string label,
auto bracket = std::make_shared<ImageComponent>(mWindow);
bracket->setImage(":/graphics/arrow.svg");
bracket->setResize(Vector2f(0, lbl->getFont()->getLetterHeight()));
bracket->setResize(glm::vec2{0.0f, lbl->getFont()->getLetterHeight()});
row.addElement(bracket, false);
// OK callback (apply new value to ed).

3
es-app/src/scrapers/Scraper.cpp
View file

@ -28,8 +28,7 @@
const std::map<std::string, generate_scraper_requests_func> scraper_request_funcs{
{"thegamesdb", &thegamesdb_generate_json_scraper_requests},
{ "screenscraper", &screenscraper_generate_scraper_requests }
};
{"screenscraper", &screenscraper_generate_scraper_requests}};
std::unique_ptr<ScraperSearchHandle> startScraperSearch(const ScraperSearchParams& params)
{

13
es-app/src/scrapers/ScreenScraper.cpp
View file

@ -127,8 +127,7 @@ const std::map<PlatformId, unsigned short> screenscraper_platformid_map {
{THOMSON_MOTO, 141},
{UZEBOX, 216},
{SPECTRAVIDEO, 218},
{ PALM_OS, 219 }
};
{PALM_OS, 219}};
// Helper XML parsing method, finding a node-by-name recursively.
pugi::xml_node find_node_by_name_re(const pugi::xml_node& node,
@ -333,8 +332,7 @@ void ScreenScraperRequest::processGame(const pugi::xml_document& xmldoc,
Utils::String::toLower(Settings::getInstance()->getString("ScraperLanguage"));
// Name fallback: US, WOR(LD). (Xpath: Data/jeu[0]/noms/nom[*]).
result.mdl.set("name",
find_child_by_attribute_list(game.child("noms"), "nom", "region",
result.mdl.set("name", find_child_by_attribute_list(game.child("noms"), "nom", "region",
{region, "wor", "us", "ss", "eu", "jp"})
.text()
.get());
@ -411,8 +409,8 @@ void ScreenScraperRequest::processGame(const pugi::xml_document& xmldoc,
}
// Genre fallback language: EN. (Xpath: Data/jeu[0]/genres/genre[*]).
std::string genre = find_child_by_attribute_list(game.child("genres"), "genre", "langue",
{ language, "en" })
std::string genre =
find_child_by_attribute_list(game.child("genres"), "genre", "langue", {language, "en"})
.text()
.get();
if (!genre.empty()) {
@ -482,8 +480,7 @@ void ScreenScraperRequest::processMedia(ScraperSearchResult& result,
}
else {
// Region fallback: WOR(LD), US, CUS(TOM?), JP, EU.
for (auto _region :
std::vector<std::string> { region, "wor", "us", "cus", "jp", "eu" }) {
for (auto _region : std::vector<std::string>{region, "wor", "us", "cus", "jp", "eu"}) {
if (art)
break;

150
es-app/src/views/SystemView.cpp
View file

@ -123,8 +123,8 @@ void SystemView::populate()
e.data.logo->setOrigin(0.5, 0.5);
}
Vector2f denormalized = mCarousel.logoSize * e.data.logo->getOrigin();
e.data.logo->setPosition(denormalized.x(), denormalized.y(), 0.0);
glm::vec2 denormalized{mCarousel.logoSize * e.data.logo->getOrigin()};
e.data.logo->setPosition(denormalized.x, denormalized.y, 0.0f);
// Make background extras.
e.data.backgroundExtras = ThemeData::makeExtras((*it)->getTheme(), "system", mWindow);
@ -396,12 +396,12 @@ void SystemView::onCursorChanged(const CursorState& /*state*/)
setAnimation(anim, 0, nullptr, false, 0);
}
void SystemView::render(const Transform4x4f& parentTrans)
void SystemView::render(const glm::mat4& parentTrans)
{
if (size() == 0)
return; // Nothing to render.
Transform4x4f trans = getTransform() * parentTrans;
glm::mat4 trans{getTransform() * parentTrans};
renderExtras(trans, INT16_MIN, INT16_MAX);
@ -449,7 +449,6 @@ void SystemView::onThemeChanged(const std::shared_ptr<ThemeData>& /*theme*/)
populate();
}
// Get the ThemeElements that make up the SystemView.
void SystemView::getViewElements(const std::shared_ptr<ThemeData>& theme)
{
LOG(LogDebug) << "SystemView::getViewElements()";
@ -473,83 +472,78 @@ void SystemView::getViewElements(const std::shared_ptr<ThemeData>& theme)
mViewNeedsReload = false;
}
// Render system carousel.
void SystemView::renderCarousel(const Transform4x4f& trans)
void SystemView::renderCarousel(const glm::mat4& trans)
{
// Background box behind logos.
Transform4x4f carouselTrans = trans;
carouselTrans.translate(Vector3f(mCarousel.pos.x(), mCarousel.pos.y(), 0.0));
carouselTrans.translate(Vector3f(mCarousel.origin.x() * mCarousel.size.x() * -1.0f,
mCarousel.origin.y() * mCarousel.size.y() * -1.0f, 0.0f));
glm::mat4 carouselTrans{trans};
carouselTrans =
glm::translate(carouselTrans, glm::vec3{mCarousel.pos.x, mCarousel.pos.y, 0.0f});
carouselTrans = glm::translate(carouselTrans,
glm::vec3{mCarousel.origin.x * mCarousel.size.x * -1.0f,
mCarousel.origin.y * mCarousel.size.y * -1.0f, 0.0f});
Vector2f clipPos(carouselTrans.translation().x(), carouselTrans.translation().y());
glm::vec2 clipPos{carouselTrans[3].x, carouselTrans[3].y};
Renderer::pushClipRect(
Vector2i(static_cast<int>(clipPos.x()), static_cast<int>(clipPos.y())),
Vector2i(static_cast<int>(mCarousel.size.x()), static_cast<int>(mCarousel.size.y())));
glm::ivec2{static_cast<int>(clipPos.x), static_cast<int>(clipPos.y)},
glm::ivec2{static_cast<int>(mCarousel.size.x), static_cast<int>(mCarousel.size.y)});
Renderer::setMatrix(carouselTrans);
Renderer::drawRect(0.0f, 0.0f, mCarousel.size.x(), mCarousel.size.y(), mCarousel.color,
Renderer::drawRect(0.0f, 0.0f, mCarousel.size.x, mCarousel.size.y, mCarousel.color,
mCarousel.colorEnd, mCarousel.colorGradientHorizontal);
// Draw logos.
// Note: logoSpacing will also include the size of the logo itself.
Vector2f logoSpacing(0.0f, 0.0f);
glm::vec2 logoSpacing{};
float xOff = 0.0f;
float yOff = 0.0f;
switch (mCarousel.type) {
case VERTICAL_WHEEL: {
yOff = (mCarousel.size.y() - mCarousel.logoSize.y()) / 2.0f -
(mCamOffset * logoSpacing[1]);
yOff = (mCarousel.size.y - mCarousel.logoSize.y) / 2.0f - (mCamOffset * logoSpacing.y);
if (mCarousel.logoAlignment == ALIGN_LEFT)
xOff = mCarousel.logoSize.x() / 10.0f;
xOff = mCarousel.logoSize.x / 10.0f;
else if (mCarousel.logoAlignment == ALIGN_RIGHT)
xOff = mCarousel.size.x() - (mCarousel.logoSize.x() * 1.1f);
xOff = mCarousel.size.x - (mCarousel.logoSize.x * 1.1f);
else
xOff = (mCarousel.size.x() - mCarousel.logoSize.x()) / 2.0f;
xOff = (mCarousel.size.x - mCarousel.logoSize.x) / 2.0f;
break;
}
case VERTICAL: {
logoSpacing[1] =
((mCarousel.size.y() - (mCarousel.logoSize.y() * mCarousel.maxLogoCount)) /
logoSpacing.y = ((mCarousel.size.y - (mCarousel.logoSize.y * mCarousel.maxLogoCount)) /
(mCarousel.maxLogoCount)) +
mCarousel.logoSize.y();
yOff = (mCarousel.size.y() - mCarousel.logoSize.y()) / 2.0f -
(mCamOffset * logoSpacing[1]);
mCarousel.logoSize.y;
yOff = (mCarousel.size.y - mCarousel.logoSize.y) / 2.0f - (mCamOffset * logoSpacing.y);
if (mCarousel.logoAlignment == ALIGN_LEFT)
xOff = mCarousel.logoSize.x() / 10.0f;
xOff = mCarousel.logoSize.x / 10.0f;
else if (mCarousel.logoAlignment == ALIGN_RIGHT)
xOff = mCarousel.size.x() - (mCarousel.logoSize.x() * 1.1f);
xOff = mCarousel.size.x - (mCarousel.logoSize.x * 1.1f);
else
xOff = (mCarousel.size.x() - mCarousel.logoSize.x()) / 2.0f;
xOff = (mCarousel.size.x - mCarousel.logoSize.x) / 2.0f;
break;
}
case HORIZONTAL_WHEEL: {
xOff = (mCarousel.size.x() - mCarousel.logoSize.x()) / 2.0f -
(mCamOffset * logoSpacing[1]);
xOff = (mCarousel.size.x - mCarousel.logoSize.x) / 2.0f - (mCamOffset * logoSpacing.y);
if (mCarousel.logoAlignment == ALIGN_TOP)
yOff = mCarousel.logoSize.y() / 10.0f;
yOff = mCarousel.logoSize.y / 10.0f;
else if (mCarousel.logoAlignment == ALIGN_BOTTOM)
yOff = mCarousel.size.y() - (mCarousel.logoSize.y() * 1.1f);
yOff = mCarousel.size.y - (mCarousel.logoSize.y * 1.1f);
else
yOff = (mCarousel.size.y() - mCarousel.logoSize.y()) / 2.0f;
yOff = (mCarousel.size.y - mCarousel.logoSize.y) / 2.0f;
break;
}
case HORIZONTAL: {
}
default: {
logoSpacing[0] =
((mCarousel.size.x() - (mCarousel.logoSize.x() * mCarousel.maxLogoCount)) /
logoSpacing.x = ((mCarousel.size.x - (mCarousel.logoSize.x * mCarousel.maxLogoCount)) /
(mCarousel.maxLogoCount)) +
mCarousel.logoSize.x();
xOff = (mCarousel.size.x() - mCarousel.logoSize.x()) / 2.0f -
(mCamOffset * logoSpacing[0]);
mCarousel.logoSize.x;
xOff = (mCarousel.size.x - mCarousel.logoSize.x) / 2.0f - (mCamOffset * logoSpacing.x);
if (mCarousel.logoAlignment == ALIGN_TOP)
yOff = mCarousel.logoSize.y() / 10.0f;
yOff = mCarousel.logoSize.y / 10.0f;
else if (mCarousel.logoAlignment == ALIGN_BOTTOM)
yOff = mCarousel.size.y() - (mCarousel.logoSize.y() * 1.1f);
yOff = mCarousel.size.y - (mCarousel.logoSize.y * 1.1f);
else
yOff = (mCarousel.size.y() - mCarousel.logoSize.y()) / 2.0f;
yOff = (mCarousel.size.y - mCarousel.logoSize.y) / 2.0f;
break;
}
}
@ -575,8 +569,9 @@ void SystemView::renderCarousel(const Transform4x4f& trans)
while (index >= static_cast<int>(mEntries.size()))
index -= static_cast<int>(mEntries.size());
Transform4x4f logoTrans = carouselTrans;
logoTrans.translate(Vector3f(i * logoSpacing[0] + xOff, i * logoSpacing[1] + yOff, 0));
glm::mat4 logoTrans{carouselTrans};
logoTrans = glm::translate(
logoTrans, glm::vec3{i * logoSpacing.x + xOff, i * logoSpacing.y + yOff, 0.0f});
float distance = i - mCamOffset;
@ -600,16 +595,15 @@ void SystemView::renderCarousel(const Transform4x4f& trans)
Renderer::popClipRect();
}
// Draw background extras.
void SystemView::renderExtras(const Transform4x4f& trans, float lower, float upper)
void SystemView::renderExtras(const glm::mat4& trans, float lower, float upper)
{
int extrasCenter = static_cast<int>(mExtrasCamOffset);
// Adding texture loading buffers depending on scrolling speed and status.
int bufferIndex = getScrollingVelocity() + 1;
int bufferIndex{getScrollingVelocity() + 1};
Renderer::pushClipRect(Vector2i::Zero(),
Vector2i(static_cast<int>(mSize.x()), static_cast<int>(mSize.y())));
Renderer::pushClipRect(glm::ivec2{},
glm::ivec2{static_cast<int>(mSize.x), static_cast<int>(mSize.y)});
for (int i = extrasCenter + logoBuffersLeft[bufferIndex];
i <= extrasCenter + logoBuffersRight[bufferIndex]; i++) {
@ -621,16 +615,17 @@ void SystemView::renderExtras(const Transform4x4f& trans, float lower, float upp
// Only render selected system when not showing.
if (mShowing || index == mCursor) {
Transform4x4f extrasTrans = trans;
glm::mat4 extrasTrans{trans};
if (mCarousel.type == HORIZONTAL || mCarousel.type == HORIZONTAL_WHEEL)
extrasTrans.translate(Vector3f((i - mExtrasCamOffset) * mSize.x(), 0, 0));
extrasTrans = glm::translate(
extrasTrans, glm::vec3{(i - mExtrasCamOffset) * mSize.x, 0.0f, 0.0f});
else
extrasTrans.translate(Vector3f(0, (i - mExtrasCamOffset) * mSize.y(), 0));
extrasTrans = glm::translate(
extrasTrans, glm::vec3{0.0f, (i - mExtrasCamOffset) * mSize.y, 0.0f});
Renderer::pushClipRect(
Vector2i(static_cast<int>(extrasTrans.translation()[0]),
static_cast<int>(extrasTrans.translation()[1])),
Vector2i(static_cast<int>(mSize.x()), static_cast<int>(mSize.y())));
glm::ivec2{static_cast<int>(extrasTrans[3].x), static_cast<int>(extrasTrans[3].y)},
glm::ivec2{static_cast<int>(mSize.x), static_cast<int>(mSize.y)});
SystemViewData data = mEntries.at(index).data;
for (unsigned int j = 0; j < data.backgroundExtras.size(); j++) {
GuiComponent* extra = data.backgroundExtras[j];
@ -644,46 +639,45 @@ void SystemView::renderExtras(const Transform4x4f& trans, float lower, float upp
Renderer::popClipRect();
}
void SystemView::renderFade(const Transform4x4f& trans)
void SystemView::renderFade(const glm::mat4& trans)
{
unsigned int fadeColor = 0x00000000 | static_cast<unsigned char>(mExtrasFadeOpacity * 255.0f);
Renderer::setMatrix(trans);
Renderer::drawRect(0.0f, 0.0f, mSize.x(), mSize.y(), fadeColor, fadeColor);
Renderer::drawRect(0.0f, 0.0f, mSize.x, mSize.y, fadeColor, fadeColor);
}
// Populate the system carousel with the legacy values.
void SystemView::getDefaultElements(void)
{
// Carousel.
mCarousel.type = HORIZONTAL;
mCarousel.logoAlignment = ALIGN_CENTER;
mCarousel.size.x() = mSize.x();
mCarousel.size.y() = floorf(0.2325f * mSize.y());
mCarousel.pos.x() = 0.0f;
mCarousel.pos.y() = floorf(0.5f * (mSize.y() - mCarousel.size.y()));
mCarousel.origin.x() = 0.0f;
mCarousel.origin.y() = 0.0f;
mCarousel.size.x = mSize.x;
mCarousel.size.y = floorf(0.2325f * mSize.y);
mCarousel.pos.x = 0.0f;
mCarousel.pos.y = floorf(0.5f * (mSize.y - mCarousel.size.y));
mCarousel.origin.x = 0.0f;
mCarousel.origin.y = 0.0f;
mCarousel.color = 0xFFFFFFD8;
mCarousel.colorEnd = 0xFFFFFFD8;
mCarousel.colorGradientHorizontal = true;
mCarousel.logoScale = 1.2f;
mCarousel.logoRotation = 7.5f;
mCarousel.logoRotationOrigin.x() = -5.0f;
mCarousel.logoRotationOrigin.y() = 0.5f;
mCarousel.logoSize.x() = 0.25f * mSize.x();
mCarousel.logoSize.y() = 0.155f * mSize.y();
mCarousel.logoRotationOrigin.x = -5.0f;
mCarousel.logoRotationOrigin.y = 0.5f;
mCarousel.logoSize.x = 0.25f * mSize.x;
mCarousel.logoSize.y = 0.155f * mSize.y;
mCarousel.maxLogoCount = 3;
mCarousel.zIndex = 40.0f;
// System info bar.
mSystemInfo.setSize(mSize.x(), mSystemInfo.getFont()->getLetterHeight() * 2.2f);
mSystemInfo.setPosition(0, mCarousel.pos.y() + mCarousel.size.y());
mSystemInfo.setSize(mSize.x, mSystemInfo.getFont()->getLetterHeight() * 2.2f);
mSystemInfo.setPosition(0.0f, mCarousel.pos.y + mCarousel.size.y);
mSystemInfo.setBackgroundColor(0xDDDDDDD8);
mSystemInfo.setRenderBackground(true);
mSystemInfo.setFont(Font::get(static_cast<int>(0.035f * mSize.y()), Font::getDefaultPath()));
mSystemInfo.setFont(Font::get(static_cast<int>(0.035f * mSize.y), Font::getDefaultPath()));
mSystemInfo.setColor(0x000000FF);
mSystemInfo.setZIndex(50);
mSystemInfo.setDefaultZIndex(50);
mSystemInfo.setZIndex(50.0f);
mSystemInfo.setDefaultZIndex(50.0f);
}
void SystemView::getCarouselFromTheme(const ThemeData::ThemeElement* elem)
@ -699,11 +693,11 @@ void SystemView::getCarouselFromTheme(const ThemeData::ThemeElement* elem)
mCarousel.type = HORIZONTAL;
}
if (elem->has("size"))
mCarousel.size = elem->get<Vector2f>("size") * mSize;
mCarousel.size = elem->get<glm::vec2>("size") * mSize;
if (elem->has("pos"))
mCarousel.pos = elem->get<Vector2f>("pos") * mSize;
mCarousel.pos = elem->get<glm::vec2>("pos") * mSize;
if (elem->has("origin"))
mCarousel.origin = elem->get<Vector2f>("origin");
mCarousel.origin = elem->get<glm::vec2>("origin");
if (elem->has("color")) {
mCarousel.color = elem->get<unsigned int>("color");
mCarousel.colorEnd = mCarousel.color;
@ -716,7 +710,7 @@ void SystemView::getCarouselFromTheme(const ThemeData::ThemeElement* elem)
if (elem->has("logoScale"))
mCarousel.logoScale = elem->get<float>("logoScale");
if (elem->has("logoSize"))
mCarousel.logoSize = elem->get<Vector2f>("logoSize") * mSize;
mCarousel.logoSize = elem->get<glm::vec2>("logoSize") * mSize;
if (elem->has("maxLogoCount"))
mCarousel.maxLogoCount = static_cast<int>(std::round(elem->get<float>("maxLogoCount")));
if (elem->has("zIndex"))
@ -724,7 +718,7 @@ void SystemView::getCarouselFromTheme(const ThemeData::ThemeElement* elem)
if (elem->has("logoRotation"))
mCarousel.logoRotation = elem->get<float>("logoRotation");
if (elem->has("logoRotationOrigin"))
mCarousel.logoRotationOrigin = elem->get<Vector2f>("logoRotationOrigin");
mCarousel.logoRotationOrigin = elem->get<glm::vec2>("logoRotationOrigin");
if (elem->has("logoAlignment")) {
if (!(elem->get<std::string>("logoAlignment").compare("left")))
mCarousel.logoAlignment = ALIGN_LEFT;

22
es-app/src/views/SystemView.h
View file

@ -34,18 +34,18 @@ struct SystemViewData {
struct SystemViewCarousel {
CarouselType type;
Vector2f pos;
Vector2f size;
Vector2f origin;
glm::vec2 pos;
glm::vec2 size;
glm::vec2 origin;
float logoScale;
float logoRotation;
Vector2f logoRotationOrigin;
glm::vec2 logoRotationOrigin;
Alignment logoAlignment;
unsigned int color;
unsigned int colorEnd;
bool colorGradientHorizontal;
int maxLogoCount; // Number of logos shown on the carousel.
Vector2f logoSize;
glm::vec2 logoSize;
float zIndex;
};
@ -62,7 +62,7 @@ public:
bool input(InputConfig* config, Input input) override;
void update(int deltaTime) override;
void render(const Transform4x4f& parentTrans) override;
void render(const glm::mat4& parentTrans) override;
void onThemeChanged(const std::shared_ptr<ThemeData>& theme);
@ -81,13 +81,17 @@ protected:
private:
void populate();
void updateGameCount();
// Get the ThemeElements that make up the SystemView.
void getViewElements(const std::shared_ptr<ThemeData>& theme);
// Populate the system carousel with the legacy values.
void getDefaultElements(void);
void getCarouselFromTheme(const ThemeData::ThemeElement* elem);
void renderCarousel(const Transform4x4f& parentTrans);
void renderExtras(const Transform4x4f& parentTrans, float lower, float upper);
void renderFade(const Transform4x4f& trans);
// Render system carousel.
void renderCarousel(const glm::mat4& parentTrans);
// Draw background extras.
void renderExtras(const glm::mat4& parentTrans, float lower, float upper);
void renderFade(const glm::mat4& trans);
SystemViewCarousel mCarousel;
TextComponent mSystemInfo;

4
es-app/src/views/UIModeController.h
View file

@ -58,9 +58,7 @@ private:
int mPassKeyCounter;
// These are Xbox button names, so they may be different in pracise on non-Xbox controllers.
const std::vector<std::string> mInputVals = {
"up", "down", "left", "right", "a", "b", "x", "y"
};
const std::vector<std::string> mInputVals = {"up", "down", "left", "right", "a", "b", "x", "y"};
};
#endif // ES_APP_VIEWS_UI_MODE_CONTROLLER_H

102
es-app/src/views/ViewController.cpp
View file

@ -66,7 +66,7 @@ ViewController::ViewController(Window* window)
, mCurrentView(nullptr)
, mPreviousView(nullptr)
, mSkipView(nullptr)
, mCamera(Transform4x4f::Identity())
, mCamera(Renderer::getIdentity())
, mSystemViewTransition(false)
, mWrappedViews(false)
, mFadeOpacity(0)
@ -234,8 +234,8 @@ void ViewController::ReloadAndGoToStart()
bool ViewController::isCameraMoving()
{
if (mCurrentView) {
if (mCamera.r3().x() - -mCurrentView->getPosition().x() != 0 ||
mCamera.r3().y() - -mCurrentView->getPosition().y() != 0)
if (mCamera[3].x - -mCurrentView->getPosition().x != 0.0f ||
mCamera[3].y - -mCurrentView->getPosition().y != 0.0f)
return true;
}
return false;
@ -245,8 +245,8 @@ void ViewController::cancelViewTransitions()
{
if (Settings::getInstance()->getString("TransitionStyle") == "slide") {
if (isCameraMoving()) {
mCamera.r3().x() = -mCurrentView->getPosition().x();
mCamera.r3().y() = -mCurrentView->getPosition().y();
mCamera[3].x = -mCurrentView->getPosition().x;
mCamera[3].y = -mCurrentView->getPosition().y;
stopAllAnimations();
}
// mSkipView is used when skipping through the gamelists in quick succession.
@ -285,8 +285,8 @@ int ViewController::getSystemId(SystemData* system)
void ViewController::restoreViewPosition()
{
if (mPreviousView) {
Vector3f restorePosition = mPreviousView->getPosition();
restorePosition.x() = mWrapPreviousPositionX;
glm::vec3 restorePosition{mPreviousView->getPosition()};
restorePosition.x = mWrapPreviousPositionX;
mPreviousView->setPosition(restorePosition);
mWrapPreviousPositionX = 0;
mWrappedViews = false;
@ -320,7 +320,7 @@ void ViewController::goToSystemView(SystemData* system, bool playTransition)
auto systemList = getSystemListView();
systemList->setPosition(getSystemId(system) * static_cast<float>(Renderer::getScreenWidth()),
systemList->getPosition().y());
systemList->getPosition().y);
systemList->goToSystem(system, false);
mCurrentView = systemList;
@ -328,21 +328,21 @@ void ViewController::goToSystemView(SystemData* system, bool playTransition)
// Application startup animation.
if (applicationStartup) {
mCamera.translation() = -mCurrentView->getPosition();
mCamera = glm::translate(mCamera, -mCurrentView->getPosition());
if (Settings::getInstance()->getString("TransitionStyle") == "slide") {
if (getSystemListView()->getCarouselType() == CarouselType::HORIZONTAL ||
getSystemListView()->getCarouselType() == CarouselType::HORIZONTAL_WHEEL)
mCamera.translation().y() += Renderer::getScreenHeight();
mCamera[3].y += static_cast<float>(Renderer::getScreenHeight());
else
mCamera.translation().x() -= Renderer::getScreenWidth();
mCamera[3].x -= static_cast<float>(Renderer::getScreenWidth());
updateHelpPrompts();
}
else if (Settings::getInstance()->getString("TransitionStyle") == "fade") {
if (getSystemListView()->getCarouselType() == CarouselType::HORIZONTAL ||
getSystemListView()->getCarouselType() == CarouselType::HORIZONTAL_WHEEL)
mCamera.translation().y() += Renderer::getScreenHeight();
mCamera[3].y += static_cast<float>(Renderer::getScreenHeight());
else
mCamera.translation().x() += Renderer::getScreenWidth();
mCamera[3].x += static_cast<float>(Renderer::getScreenWidth());
}
else {
updateHelpPrompts();
@ -444,13 +444,13 @@ void ViewController::goToGameList(SystemData* system)
if (mState.viewing == SYSTEM_SELECT) {
// Move the system list.
auto sysList = getSystemListView();
float offsetX = sysList->getPosition().x();
float offsetX = sysList->getPosition().x;
int sysId = getSystemId(system);
sysList->setPosition(sysId * static_cast<float>(Renderer::getScreenWidth()),
sysList->getPosition().y());
offsetX = sysList->getPosition().x() - offsetX;
mCamera.translation().x() -= offsetX;
sysList->getPosition().y);
offsetX = sysList->getPosition().x - offsetX;
mCamera[3].x -= offsetX;
}
// If we are wrapping around, either from the first to last system, or the other way
@ -458,30 +458,30 @@ void ViewController::goToGameList(SystemData* system)
// movements will be correct. This is accomplished by simply offsetting the X position
// with the position of the first or last system plus the screen width.
if (wrapFirstToLast) {
Vector3f currentPosition = mCurrentView->getPosition();
mWrapPreviousPositionX = currentPosition.x();
float offsetX = getGameListView(system)->getPosition().x();
glm::vec3 currentPosition{mCurrentView->getPosition()};
mWrapPreviousPositionX = currentPosition.x;
float offsetX{getGameListView(system)->getPosition().x};
// This is needed to move the camera in the correct direction if there are only two systems.
if (SystemData::sSystemVector.size() == 2 && mNextSystem)
offsetX -= Renderer::getScreenWidth();
else
offsetX += Renderer::getScreenWidth();
currentPosition.x() = offsetX;
currentPosition.x = offsetX;
mCurrentView->setPosition(currentPosition);
mCamera.translation().x() -= offsetX;
mCamera[3].x -= offsetX;
mWrappedViews = true;
}
else if (wrapLastToFirst) {
Vector3f currentPosition = mCurrentView->getPosition();
mWrapPreviousPositionX = currentPosition.x();
float offsetX = getGameListView(system)->getPosition().x();
glm::vec3 currentPosition{mCurrentView->getPosition()};
mWrapPreviousPositionX = currentPosition.x;
float offsetX{getGameListView(system)->getPosition().x};
if (SystemData::sSystemVector.size() == 2 && !mNextSystem)
offsetX += Renderer::getScreenWidth();
else
offsetX -= Renderer::getScreenWidth();
currentPosition.x() = offsetX;
currentPosition.x = offsetX;
mCurrentView->setPosition(currentPosition);
mCamera.translation().x() = -offsetX;
mCamera[3].x = -offsetX;
mWrappedViews = true;
}
@ -489,13 +489,13 @@ void ViewController::goToGameList(SystemData* system)
// Application startup animation, if starting in a gamelist rather than in the system view.
if (mState.viewing == NOTHING) {
mCamera.translation() = -mCurrentView->getPosition();
mCamera = glm::translate(mCamera, -mCurrentView->getPosition());
if (Settings::getInstance()->getString("TransitionStyle") == "slide") {
mCamera.translation().y() -= Renderer::getScreenHeight();
mCamera[3].y -= static_cast<float>(Renderer::getScreenHeight());
updateHelpPrompts();
}
else if (Settings::getInstance()->getString("TransitionStyle") == "fade") {
mCamera.translation().y() += Renderer::getScreenHeight() * 2;
mCamera[3].y += static_cast<float>(Renderer::getScreenHeight() * 2);
}
else {
updateHelpPrompts();
@ -528,21 +528,23 @@ void ViewController::playViewTransition(bool instant)
{
mCancelledTransition = false;
Vector3f target(Vector3f::Zero());
glm::vec3 target{};
if (mCurrentView)
target = mCurrentView->getPosition();
// No need to animate, we're not going anywhere (probably due to goToNextGamelist()
// or goToPrevGamelist() being called when there's only 1 system).
if (target == -mCamera.translation() && !isAnimationPlaying(0))
if (target == static_cast<glm::vec3>(-mCamera[3]) && !isAnimationPlaying(0))
return;
std::string transition_style = Settings::getInstance()->getString("TransitionStyle");
std::string transition_style{Settings::getInstance()->getString("TransitionStyle")};
if (instant || transition_style == "instant") {
setAnimation(new LambdaAnimation(
[this, target](float /*t*/) {
this->mCamera.translation() = -target;
this->mCamera[3].x = -target.x;
this->mCamera[3].y = -target.y;
this->mCamera[3].z = -target.z;
if (mPreviousView)
mPreviousView->onHide();
},
@ -571,14 +573,16 @@ void ViewController::playViewTransition(bool instant)
const static int FADE_WAIT = 200; // Time to wait between in/out.
setAnimation(new LambdaAnimation(fadeFunc, FADE_DURATION), 0,
[this, fadeFunc, fadeCallback, target] {
this->mCamera.translation() = -target;
this->mCamera[3].x = -target.x;
this->mCamera[3].y = -target.y;
this->mCamera[3].z = -target.z;
updateHelpPrompts();
setAnimation(new LambdaAnimation(fadeFunc, FADE_DURATION), FADE_WAIT,
fadeCallback, true);
});
// Fast-forward animation if we're partway faded.
if (target == -mCamera.translation()) {
if (target == static_cast<glm::vec3>(-mCamera[3])) {
// Not changing screens, so cancel the first half entirely.
advanceAnimation(0, FADE_DURATION);
advanceAnimation(0, FADE_WAIT);
@ -848,16 +852,16 @@ void ViewController::update(int deltaTime)
}
}
void ViewController::render(const Transform4x4f& parentTrans)
void ViewController::render(const glm::mat4& parentTrans)
{
Transform4x4f trans = mCamera * parentTrans;
Transform4x4f transInverse;
transInverse.invert(trans);
glm::mat4 trans{mCamera * parentTrans};
glm::mat4 transInverse{glm::inverse(trans)};
// Camera position, position + size.
Vector3f viewStart = transInverse.translation();
Vector3f viewEnd = transInverse * Vector3f(static_cast<float>(Renderer::getScreenWidth()),
static_cast<float>(Renderer::getScreenHeight(), 0));
glm::vec3 viewStart{transInverse[3]};
glm::vec3 viewEnd{std::fabs(trans[3].x) + static_cast<float>(Renderer::getScreenWidth()),
std::fabs(trans[3].y) + static_cast<float>(Renderer::getScreenHeight()),
0.0f};
// Keep track of UI mode changes.
UIModeController::getInstance()->monitorUIMode();
@ -872,12 +876,12 @@ void ViewController::render(const Transform4x4f& parentTrans)
// Same thing as for the system view, limit the rendering only to what needs to be drawn.
if (it->second == mCurrentView || (it->second == mPreviousView && isCameraMoving())) {
// Clipping.
Vector3f guiStart = it->second->getPosition();
Vector3f guiEnd = it->second->getPosition() +
Vector3f(it->second->getSize().x(), it->second->getSize().y(), 0);
glm::vec3 guiStart{it->second->getPosition()};
glm::vec3 guiEnd{it->second->getPosition() +
glm::vec3{it->second->getSize().x, it->second->getSize().y, 0.0f}};
if (guiEnd.x() >= viewStart.x() && guiEnd.y() >= viewStart.y() &&
guiStart.x() <= viewEnd.x() && guiStart.y() <= viewEnd.y())
if (guiEnd.x >= viewStart.x && guiEnd.y >= viewStart.y && guiStart.x <= viewEnd.x &&
guiStart.y <= viewEnd.y)
it->second->render(trans);
}
}
@ -1000,7 +1004,7 @@ void ViewController::reloadAll()
SystemData* system = mState.getSystem();
mSystemListView->goToSystem(system, false);
mCurrentView = mSystemListView;
mCamera.r3().x() = 0;
mCamera[3].x = 0.0f;
}
else {
goToSystemView(SystemData::sSystemVector.front(), false);

4
es-app/src/views/ViewController.h
View file

@ -78,7 +78,7 @@ public:
bool input(InputConfig* config, Input input) override;
void update(int deltaTime) override;
void render(const Transform4x4f& parentTrans) override;
void render(const glm::mat4& parentTrans) override;
enum ViewMode {
NOTHING, // Replace with AllowShortEnumsOnASingleLine: false (clang-format >=11.0).
@ -152,7 +152,7 @@ private:
FileData* mGameToLaunch;
State mState;
Transform4x4f mCamera;
glm::mat4 mCamera;
bool mSystemViewTransition;
bool mWrappedViews;
float mWrapPreviousPositionX;

6
es-app/src/views/gamelist/BasicGameListView.cpp
View file

@ -19,9 +19,9 @@ BasicGameListView::BasicGameListView(Window* window, FileData* root)
: ISimpleGameListView(window, root)
, mList(window)
{
mList.setSize(mSize.x(), mSize.y() * 0.8f);
mList.setPosition(0, mSize.y() * 0.2f);
mList.setDefaultZIndex(20);
mList.setSize(mSize.x, mSize.y * 0.8f);
mList.setPosition(0.0f, mSize.y * 0.2f);
mList.setDefaultZIndex(20.0f);
addChild(&mList);
populateList(root->getChildrenListToDisplay(), root);

74
es-app/src/views/gamelist/DetailedGameListView.cpp
View file

@ -45,8 +45,8 @@ DetailedGameListView::DetailedGameListView(Window* window, FileData* root)
{
const float padding = 0.01f;
mList.setPosition(mSize.x() * (0.50f + padding), mList.getPosition().y());
mList.setSize(mSize.x() * (0.50f - padding), mList.getSize().y());
mList.setPosition(mSize.x * (0.50f + padding), mList.getPosition().y);
mList.setSize(mSize.x * (0.50f - padding), mList.getSize().y);
mList.setAlignment(TextListComponent<FileData*>::ALIGN_LEFT);
mList.setCursorChangedCallback([&](const CursorState& /*state*/) { updateInfoPanel(); });
@ -54,8 +54,8 @@ DetailedGameListView::DetailedGameListView(Window* window, FileData* root)
mThumbnail.setOrigin(0.5f, 0.5f);
mThumbnail.setPosition(2.0f, 2.0f);
mThumbnail.setVisible(false);
mThumbnail.setMaxSize(mSize.x() * (0.25f - 2 * padding), mSize.y() * 0.10f);
mThumbnail.setDefaultZIndex(25);
mThumbnail.setMaxSize(mSize.x * (0.25f - 2.0f * padding), mSize.y * 0.10f);
mThumbnail.setDefaultZIndex(25.0f);
addChild(&mThumbnail);
// Marquee.
@ -63,15 +63,15 @@ DetailedGameListView::DetailedGameListView(Window* window, FileData* root)
// Default to off the screen.
mMarquee.setPosition(2.0f, 2.0f);
mMarquee.setVisible(false);
mMarquee.setMaxSize(mSize.x() * (0.5f - 2 * padding), mSize.y() * 0.18f);
mMarquee.setDefaultZIndex(35);
mMarquee.setMaxSize(mSize.x * (0.5f - 2.0f * padding), mSize.y * 0.18f);
mMarquee.setDefaultZIndex(35.0f);
addChild(&mMarquee);
// Image.
mImage.setOrigin(0.5f, 0.5f);
mImage.setPosition(mSize.x() * 0.25f, mList.getPosition().y() + mSize.y() * 0.2125f);
mImage.setMaxSize(mSize.x() * (0.50f - 2 * padding), mSize.y() * 0.4f);
mImage.setDefaultZIndex(30);
mImage.setPosition(mSize.x * 0.25f, mList.getPosition().y + mSize.y * 0.2125f);
mImage.setMaxSize(mSize.x * (0.50f - 2.0f * padding), mSize.y * 0.4f);
mImage.setDefaultZIndex(30.0f);
addChild(&mImage);
// Metadata labels + values.
@ -101,27 +101,27 @@ DetailedGameListView::DetailedGameListView(Window* window, FileData* root)
addChild(&mLblPlayCount);
addChild(&mPlayCount);
mName.setPosition(mSize.x(), mSize.y());
mName.setDefaultZIndex(40);
mName.setPosition(mSize.x, mSize.y);
mName.setDefaultZIndex(40.0f);
mName.setColor(0xAAAAAAFF);
mName.setFont(Font::get(FONT_SIZE_MEDIUM));
mName.setHorizontalAlignment(ALIGN_CENTER);
addChild(&mName);
mDescContainer.setPosition(mSize.x() * padding, mSize.y() * 0.65f);
mDescContainer.setSize(mSize.x() * (0.50f - 2.0f * padding),
mSize.y() - mDescContainer.getPosition().y());
mDescContainer.setPosition(mSize.x * padding, mSize.y * 0.65f);
mDescContainer.setSize(mSize.x * (0.50f - 2.0f * padding),
mSize.y - mDescContainer.getPosition().y);
mDescContainer.setAutoScroll(true);
mDescContainer.setDefaultZIndex(40);
mDescContainer.setDefaultZIndex(40.0f);
addChild(&mDescContainer);
mDescription.setFont(Font::get(FONT_SIZE_SMALL));
mDescription.setSize(mDescContainer.getSize().x(), 0);
mDescription.setSize(mDescContainer.getSize().x, 0.0f);
mDescContainer.addChild(&mDescription);
mGamelistInfo.setOrigin(0.5f, 0.5f);
mGamelistInfo.setFont(Font::get(FONT_SIZE_SMALL));
mGamelistInfo.setDefaultZIndex(50);
mGamelistInfo.setDefaultZIndex(50.0f);
mGamelistInfo.setVisible(true);
addChild(&mGamelistInfo);
@ -145,10 +145,9 @@ void DetailedGameListView::onThemeChanged(const std::shared_ptr<ThemeData>& them
initMDLabels();
std::vector<TextComponent*> labels = getMDLabels();
assert(labels.size() == 8);
std::vector<std::string> lblElements = { "md_lbl_rating", "md_lbl_releasedate",
"md_lbl_developer", "md_lbl_publisher",
"md_lbl_genre", "md_lbl_players",
"md_lbl_lastplayed", "md_lbl_playcount" };
std::vector<std::string> lblElements = {
"md_lbl_rating", "md_lbl_releasedate", "md_lbl_developer", "md_lbl_publisher",
"md_lbl_genre", "md_lbl_players", "md_lbl_lastplayed", "md_lbl_playcount"};
for (unsigned int i = 0; i < labels.size(); i++)
labels[i]->applyTheme(theme, getName(), lblElements[i], ALL);
@ -165,14 +164,14 @@ void DetailedGameListView::onThemeChanged(const std::shared_ptr<ThemeData>& them
mDescContainer.applyTheme(theme, getName(), "md_description",
POSITION | ThemeFlags::SIZE | Z_INDEX | VISIBLE);
mDescription.setSize(mDescContainer.getSize().x(), 0);
mDescription.setSize(mDescContainer.getSize().x, 0.0f);
mDescription.applyTheme(
theme, getName(), "md_description",
ALL ^ (POSITION | ThemeFlags::SIZE | ThemeFlags::ORIGIN | TEXT | ROTATION));
mGamelistInfo.applyTheme(theme, getName(), "gamelistInfo", ALL ^ ThemeFlags::TEXT);
// If there is no position defined in the theme for gamelistInfo, then hide it.
if (mGamelistInfo.getPosition() == 0)
if (mGamelistInfo.getPosition() == glm::vec3{})
mGamelistInfo.setVisible(false);
else
mGamelistInfo.setVisible(true);
@ -187,26 +186,26 @@ void DetailedGameListView::initMDLabels()
const unsigned int colCount = 2;
const unsigned int rowCount = static_cast<int>(components.size() / 2);
Vector3f start(mSize.x() * 0.01f, mSize.y() * 0.625f, 0.0f);
glm::vec3 start{mSize.x * 0.01f, mSize.y * 0.625f, 0.0f};
const float colSize = (mSize.x() * 0.48f) / colCount;
const float rowPadding = 0.01f * mSize.y();
const float colSize = (mSize.x * 0.48f) / colCount;
const float rowPadding = 0.01f * mSize.y;
for (unsigned int i = 0; i < components.size(); i++) {
const unsigned int row = i % rowCount;
Vector3f pos(0.0f, 0.0f, 0.0f);
glm::vec3 pos{};
if (row == 0) {
pos = start + Vector3f(colSize * (i / rowCount), 0, 0);
pos = start + glm::vec3{colSize * (i / rowCount), 0.0f, 0.0f};
}
else {
// Work from the last component.
GuiComponent* lc = components[i - 1];
pos = lc->getPosition() + Vector3f(0, lc->getSize().y() + rowPadding, 0);
pos = lc->getPosition() + glm::vec3{0.0f, lc->getSize().y + rowPadding, 0.0f};
}
components[i]->setFont(Font::get(FONT_SIZE_SMALL));
components[i]->setPosition(pos);
components[i]->setDefaultZIndex(40);
components[i]->setDefaultZIndex(40.0f);
}
}
@ -227,23 +226,22 @@ void DetailedGameListView::initMDValues()
float bottom = 0.0f;
const float colSize = (mSize.x() * 0.48f) / 2.0f;
const float colSize = (mSize.x * 0.48f) / 2.0f;
for (unsigned int i = 0; i < labels.size(); i++) {
const float heightDiff = (labels[i]->getSize().y() - values[i]->getSize().y()) / 2.0f;
const float heightDiff = (labels[i]->getSize().y - values[i]->getSize().y) / 2.0f;
values[i]->setPosition(labels[i]->getPosition() +
Vector3f(labels[i]->getSize().x(), heightDiff, 0));
values[i]->setSize(colSize - labels[i]->getSize().x(), values[i]->getSize().y());
glm::vec3{labels[i]->getSize().x, heightDiff, 0.0f});
values[i]->setSize(colSize - labels[i]->getSize().x, values[i]->getSize().y);
values[i]->setDefaultZIndex(40.0f);
float testBot = values[i]->getPosition().y() + values[i]->getSize().y();
float testBot = values[i]->getPosition().y + values[i]->getSize().y;
if (testBot > bottom)
bottom = testBot;
}
mDescContainer.setPosition(mDescContainer.getPosition().x(), bottom + mSize.y() * 0.01f);
mDescContainer.setSize(mDescContainer.getSize().x(),
mSize.y() - mDescContainer.getPosition().y());
mDescContainer.setPosition(mDescContainer.getPosition().x, bottom + mSize.y * 0.01f);
mDescContainer.setSize(mDescContainer.getSize().x, mSize.y - mDescContainer.getPosition().y);
}
void DetailedGameListView::updateInfoPanel()

72
es-app/src/views/gamelist/GridGameListView.cpp
View file

@ -47,8 +47,8 @@ GridGameListView::GridGameListView(Window* window, FileData* root)
{
const float padding = 0.01f;
mGrid.setPosition(mSize.x() * 0.1f, mSize.y() * 0.1f);
mGrid.setDefaultZIndex(20);
mGrid.setPosition(mSize.x * 0.1f, mSize.y * 0.1f);
mGrid.setDefaultZIndex(20.0f);
mGrid.setCursorChangedCallback([&](const CursorState& /*state*/) { updateInfoPanel(); });
addChild(&mGrid);
@ -81,41 +81,41 @@ GridGameListView::GridGameListView(Window* window, FileData* root)
addChild(&mLblPlayCount);
addChild(&mPlayCount);
mName.setPosition(mSize.x(), mSize.y());
mName.setDefaultZIndex(40);
mName.setPosition(mSize.x, mSize.y);
mName.setDefaultZIndex(40.0f);
mName.setColor(0xAAAAAAFF);
mName.setFont(Font::get(FONT_SIZE_MEDIUM));
mName.setHorizontalAlignment(ALIGN_CENTER);
addChild(&mName);
mDescContainer.setPosition(mSize.x() * padding, mSize.y() * 0.65f);
mDescContainer.setSize(mSize.x() * (0.50f - 2.0f * padding),
mSize.y() - mDescContainer.getPosition().y());
mDescContainer.setPosition(mSize.x * padding, mSize.y * 0.65f);
mDescContainer.setSize(mSize.x * (0.50f - 2.0f * padding),
mSize.y - mDescContainer.getPosition().y);
mDescContainer.setAutoScroll(true);
mDescContainer.setDefaultZIndex(40);
mDescContainer.setDefaultZIndex(40.0f);
addChild(&mDescContainer);
mDescription.setFont(Font::get(FONT_SIZE_SMALL));
mDescription.setSize(mDescContainer.getSize().x(), 0);
mDescription.setSize(mDescContainer.getSize().x, 0.0f);
mDescContainer.addChild(&mDescription);
mMarquee.setOrigin(0.5f, 0.5f);
mMarquee.setPosition(mSize.x() * 0.25f, mSize.y() * 0.10f);
mMarquee.setMaxSize(mSize.x() * (0.5f - 2.0f * padding), mSize.y() * 0.18f);
mMarquee.setDefaultZIndex(35);
mMarquee.setPosition(mSize.x * 0.25f, mSize.y * 0.10f);
mMarquee.setMaxSize(mSize.x * (0.5f - 2.0f * padding), mSize.y * 0.18f);
mMarquee.setDefaultZIndex(35.0f);
mMarquee.setVisible(false);
addChild(&mMarquee);
mImage.setOrigin(0.5f, 0.5f);
mImage.setPosition(2.0f, 2.0f);
mImage.setMaxSize(mSize.x() * (0.50f - 2 * padding), mSize.y() * 0.4f);
mImage.setDefaultZIndex(10);
mImage.setMaxSize(mSize.x * (0.50f - 2.0f * padding), mSize.y * 0.4f);
mImage.setDefaultZIndex(10.0f);
mImage.setVisible(false);
addChild(&mImage);
mGamelistInfo.setOrigin(0.5f, 0.5f);
mGamelistInfo.setFont(Font::get(FONT_SIZE_SMALL));
mGamelistInfo.setDefaultZIndex(50);
mGamelistInfo.setDefaultZIndex(50.0f);
mGamelistInfo.setVisible(true);
addChild(&mGamelistInfo);
@ -244,10 +244,9 @@ void GridGameListView::onThemeChanged(const std::shared_ptr<ThemeData>& theme)
initMDLabels();
std::vector<TextComponent*> labels = getMDLabels();
assert(labels.size() == 8);
std::vector<std::string> lblElements = { "md_lbl_rating", "md_lbl_releasedate",
"md_lbl_developer", "md_lbl_publisher",
"md_lbl_genre", "md_lbl_players",
"md_lbl_lastplayed", "md_lbl_playcount" };
std::vector<std::string> lblElements = {
"md_lbl_rating", "md_lbl_releasedate", "md_lbl_developer", "md_lbl_publisher",
"md_lbl_genre", "md_lbl_players", "md_lbl_lastplayed", "md_lbl_playcount"};
for (unsigned int i = 0; i < labels.size(); i++)
labels[i]->applyTheme(theme, getName(), lblElements[i], ALL);
@ -264,7 +263,7 @@ void GridGameListView::onThemeChanged(const std::shared_ptr<ThemeData>& theme)
mDescContainer.applyTheme(theme, getName(), "md_description",
POSITION | ThemeFlags::SIZE | Z_INDEX | VISIBLE);
mDescription.setSize(mDescContainer.getSize().x(), 0);
mDescription.setSize(mDescContainer.getSize().x, 0.0f);
mDescription.applyTheme(
theme, getName(), "md_description",
ALL ^ (POSITION | ThemeFlags::SIZE | ThemeFlags::ORIGIN | TEXT | ROTATION));
@ -277,7 +276,7 @@ void GridGameListView::onThemeChanged(const std::shared_ptr<ThemeData>& theme)
mGamelistInfo.applyTheme(theme, getName(), "gamelistInfo", ALL ^ ThemeFlags::TEXT);
// If there is no position defined in the theme for gamelistInfo, then hide it.
if (mGamelistInfo.getPosition() == 0)
if (mGamelistInfo.getPosition() == glm::vec3{})
mGamelistInfo.setVisible(false);
else
mGamelistInfo.setVisible(true);
@ -298,26 +297,26 @@ void GridGameListView::initMDLabels()
const unsigned int colCount = 2;
const unsigned int rowCount = static_cast<int>(components.size() / 2);
Vector3f start(mSize.x() * 0.01f, mSize.y() * 0.625f, 0.0f);
glm::vec3 start{mSize.x * 0.01f, mSize.y * 0.625f, 0.0f};
const float colSize = (mSize.x() * 0.48f) / colCount;
const float rowPadding = 0.01f * mSize.y();
const float colSize = (mSize.x * 0.48f) / colCount;
const float rowPadding = 0.01f * mSize.y;
for (unsigned int i = 0; i < components.size(); i++) {
const unsigned int row = i % rowCount;
Vector3f pos(0.0f, 0.0f, 0.0f);
glm::vec3 pos{};
if (row == 0) {
pos = start + Vector3f(colSize * (i / rowCount), 0, 0);
pos = start + glm::vec3{colSize * (i / rowCount), 0.0f, 0.0f};
}
else {
// Work from the last component.
GuiComponent* lc = components[i - 1];
pos = lc->getPosition() + Vector3f(0, lc->getSize().y() + rowPadding, 0);
pos = lc->getPosition() + glm::vec3{0.0f, lc->getSize().y + rowPadding, 0.0f};
}
components[i]->setFont(Font::get(FONT_SIZE_SMALL));
components[i]->setPosition(pos);
components[i]->setDefaultZIndex(40);
components[i]->setDefaultZIndex(40.0f);
}
}
@ -338,22 +337,21 @@ void GridGameListView::initMDValues()
float bottom = 0.0f;
const float colSize = (mSize.x() * 0.48f) / 2.0f;
const float colSize = (mSize.x * 0.48f) / 2.0f;
for (unsigned int i = 0; i < labels.size(); i++) {
const float heightDiff = (labels[i]->getSize().y() - values[i]->getSize().y()) / 2.0f;
const float heightDiff = (labels[i]->getSize().y - values[i]->getSize().y) / 2.0f;
values[i]->setPosition(labels[i]->getPosition() +
Vector3f(labels[i]->getSize().x(), heightDiff, 0));
values[i]->setSize(colSize - labels[i]->getSize().x(), values[i]->getSize().y());
values[i]->setDefaultZIndex(40);
glm::vec3{labels[i]->getSize().x, heightDiff, 0.0f});
values[i]->setSize(colSize - labels[i]->getSize().x, values[i]->getSize().y);
values[i]->setDefaultZIndex(40.0f);
float testBot = values[i]->getPosition().y() + values[i]->getSize().y();
float testBot = values[i]->getPosition().y + values[i]->getSize().y;
if (testBot > bottom)
bottom = testBot;
}
mDescContainer.setPosition(mDescContainer.getPosition().x(), bottom + mSize.y() * 0.01f);
mDescContainer.setSize(mDescContainer.getSize().x(),
mSize.y() - mDescContainer.getPosition().y());
mDescContainer.setPosition(mDescContainer.getPosition().x, bottom + mSize.y * 0.01f);
mDescContainer.setSize(mDescContainer.getSize().x, mSize.y - mDescContainer.getPosition().y);
}
void GridGameListView::updateInfoPanel()

16
es-app/src/views/gamelist/IGameListView.cpp
View file

@ -60,17 +60,17 @@ HelpStyle IGameListView::getHelpStyle()
return style;
}
void IGameListView::render(const Transform4x4f& parentTrans)
void IGameListView::render(const glm::mat4& parentTrans)
{
Transform4x4f trans = parentTrans * getTransform();
glm::mat4 trans{parentTrans * getTransform()};
float scaleX = trans.r0().x();
float scaleY = trans.r1().y();
float scaleX = trans[0].x;
float scaleY = trans[1].y;
Vector2i pos(static_cast<int>(std::round(trans.translation()[0])),
static_cast<int>(std::round(trans.translation()[1])));
Vector2i size(static_cast<int>(std::round(mSize.x() * scaleX)),
static_cast<int>(std::round(mSize.y() * scaleY)));
glm::ivec2 pos{static_cast<int>(std::round(trans[3].x)),
static_cast<int>(std::round(trans[3].y))};
glm::ivec2 size{static_cast<int>(std::round(mSize.x * scaleX)),
static_cast<int>(std::round(mSize.y * scaleY))};
Renderer::pushClipRect(pos, size);
renderChildren(trans);

2
es-app/src/views/gamelist/IGameListView.h
View file

@ -54,7 +54,7 @@ public:
virtual HelpStyle getHelpStyle() override;
void render(const Transform4x4f& parentTrans) override;
void render(const glm::mat4& parentTrans) override;
protected:
FileData* mRoot;

16
es-app/src/views/gamelist/ISimpleGameListView.cpp
View file

@ -28,18 +28,18 @@ ISimpleGameListView::ISimpleGameListView(Window* window, FileData* root)
, mRandomGame(nullptr)
{
mHeaderText.setText("Logo Text");
mHeaderText.setSize(mSize.x(), 0);
mHeaderText.setPosition(0, 0);
mHeaderText.setSize(mSize.x, 0.0f);
mHeaderText.setPosition(0.0f, 0.0f);
mHeaderText.setHorizontalAlignment(ALIGN_CENTER);
mHeaderText.setDefaultZIndex(50);
mHeaderText.setDefaultZIndex(50.0f);
mHeaderImage.setResize(0, mSize.y() * 0.185f);
mHeaderImage.setResize(0.0f, mSize.y * 0.185f);
mHeaderImage.setOrigin(0.5f, 0.0f);
mHeaderImage.setPosition(mSize.x() / 2, 0);
mHeaderImage.setDefaultZIndex(50);
mHeaderImage.setPosition(mSize.x / 2.0f, 0.0f);
mHeaderImage.setDefaultZIndex(50.0f);
mBackground.setResize(mSize.x(), mSize.y());
mBackground.setDefaultZIndex(0);
mBackground.setResize(mSize.x, mSize.y);
mBackground.setDefaultZIndex(0.0f);
addChild(&mHeaderText);
addChild(&mBackground);

78
es-app/src/views/gamelist/VideoGameListView.cpp
View file

@ -64,8 +64,8 @@ VideoGameListView::VideoGameListView(Window* window, FileData* root)
mVideo = new VideoFFmpegComponent(window);
#endif
mList.setPosition(mSize.x() * (0.50f + padding), mList.getPosition().y());
mList.setSize(mSize.x() * (0.50f - padding), mList.getSize().y());
mList.setPosition(mSize.x * (0.50f + padding), mList.getPosition().y);
mList.setSize(mSize.x * (0.50f - padding), mList.getSize().y);
mList.setAlignment(TextListComponent<FileData*>::ALIGN_LEFT);
mList.setCursorChangedCallback([&](const CursorState& /*state*/) { updateInfoPanel(); });
@ -73,22 +73,22 @@ VideoGameListView::VideoGameListView(Window* window, FileData* root)
mThumbnail.setOrigin(0.5f, 0.5f);
mThumbnail.setPosition(2.0f, 2.0f);
mThumbnail.setVisible(false);
mThumbnail.setMaxSize(mSize.x() * (0.25f - 2.0f * padding), mSize.y() * 0.10f);
mThumbnail.setDefaultZIndex(35);
mThumbnail.setMaxSize(mSize.x * (0.25f - 2.0f * padding), mSize.y * 0.10f);
mThumbnail.setDefaultZIndex(35.0f);
addChild(&mThumbnail);
// Marquee.
mMarquee.setOrigin(0.5f, 0.5f);
mMarquee.setPosition(mSize.x() * 0.25f, mSize.y() * 0.10f);
mMarquee.setMaxSize(mSize.x() * (0.5f - 2.0f * padding), mSize.y() * 0.18f);
mMarquee.setDefaultZIndex(35);
mMarquee.setPosition(mSize.x * 0.25f, mSize.y * 0.10f);
mMarquee.setMaxSize(mSize.x * (0.5f - 2.0f * padding), mSize.y * 0.18f);
mMarquee.setDefaultZIndex(35.0f);
addChild(&mMarquee);
// Video.
mVideo->setOrigin(0.5f, 0.5f);
mVideo->setPosition(mSize.x() * 0.25f, mSize.y() * 0.4f);
mVideo->setSize(mSize.x() * (0.5f - 2.0f * padding), mSize.y() * 0.4f);
mVideo->setDefaultZIndex(30);
mVideo->setPosition(mSize.x * 0.25f, mSize.y * 0.4f);
mVideo->setSize(mSize.x * (0.5f - 2.0f * padding), mSize.y * 0.4f);
mVideo->setDefaultZIndex(30.0f);
addChild(mVideo);
// Metadata labels + values.
@ -118,27 +118,27 @@ VideoGameListView::VideoGameListView(Window* window, FileData* root)
addChild(&mLblPlayCount);
addChild(&mPlayCount);
mName.setPosition(mSize.x(), mSize.y());
mName.setDefaultZIndex(40);
mName.setPosition(mSize.x, mSize.y);
mName.setDefaultZIndex(40.0f);
mName.setColor(0xAAAAAAFF);
mName.setFont(Font::get(FONT_SIZE_MEDIUM));
mName.setHorizontalAlignment(ALIGN_CENTER);
addChild(&mName);
mDescContainer.setPosition(mSize.x() * padding, mSize.y() * 0.65f);
mDescContainer.setSize(mSize.x() * (0.50f - 2.0f * padding),
mSize.y() - mDescContainer.getPosition().y());
mDescContainer.setPosition(mSize.x * padding, mSize.y * 0.65f);
mDescContainer.setSize(mSize.x * (0.50f - 2.0f * padding),
mSize.y - mDescContainer.getPosition().y);
mDescContainer.setAutoScroll(true);
mDescContainer.setDefaultZIndex(40);
mDescContainer.setDefaultZIndex(40.0f);
addChild(&mDescContainer);
mDescription.setFont(Font::get(FONT_SIZE_SMALL));
mDescription.setSize(mDescContainer.getSize().x(), 0);
mDescription.setSize(mDescContainer.getSize().x, 0.0f);
mDescContainer.addChild(&mDescription);
mGamelistInfo.setOrigin(0.5f, 0.5f);
mGamelistInfo.setFont(Font::get(FONT_SIZE_SMALL));
mGamelistInfo.setDefaultZIndex(50);
mGamelistInfo.setDefaultZIndex(50.0f);
mGamelistInfo.setVisible(true);
addChild(&mGamelistInfo);
@ -167,10 +167,9 @@ void VideoGameListView::onThemeChanged(const std::shared_ptr<ThemeData>& theme)
initMDLabels();
std::vector<TextComponent*> labels = getMDLabels();
assert(labels.size() == 8);
std::vector<std::string> lblElements = { "md_lbl_rating", "md_lbl_releasedate",
"md_lbl_developer", "md_lbl_publisher",
"md_lbl_genre", "md_lbl_players",
"md_lbl_lastplayed", "md_lbl_playcount" };
std::vector<std::string> lblElements = {
"md_lbl_rating", "md_lbl_releasedate", "md_lbl_developer", "md_lbl_publisher",
"md_lbl_genre", "md_lbl_players", "md_lbl_lastplayed", "md_lbl_playcount"};
for (unsigned int i = 0; i < labels.size(); i++)
labels[i]->applyTheme(theme, getName(), lblElements[i], ALL);
@ -187,14 +186,14 @@ void VideoGameListView::onThemeChanged(const std::shared_ptr<ThemeData>& theme)
mDescContainer.applyTheme(theme, getName(), "md_description",
POSITION | ThemeFlags::SIZE | Z_INDEX | VISIBLE);
mDescription.setSize(mDescContainer.getSize().x(), 0);
mDescription.setSize(mDescContainer.getSize().x, 0.0f);
mDescription.applyTheme(
theme, getName(), "md_description",
ALL ^ (POSITION | ThemeFlags::SIZE | ThemeFlags::ORIGIN | TEXT | ROTATION));
mGamelistInfo.applyTheme(theme, getName(), "gamelistInfo", ALL ^ ThemeFlags::TEXT);
// If there is no position defined in the theme for gamelistInfo, then hide it.
if (mGamelistInfo.getPosition() == 0)
if (mGamelistInfo.getPosition() == glm::vec3{})
mGamelistInfo.setVisible(false);
else
mGamelistInfo.setVisible(true);
@ -209,26 +208,26 @@ void VideoGameListView::initMDLabels()
const unsigned int colCount = 2;
const unsigned int rowCount = static_cast<int>(components.size() / 2);
Vector3f start(mSize.x() * 0.01f, mSize.y() * 0.625f, 0.0f);
glm::vec3 start{mSize.x * 0.01f, mSize.y * 0.625f, 0.0f};
const float colSize = (mSize.x() * 0.48f) / colCount;
const float rowPadding = 0.01f * mSize.y();
const float colSize = (mSize.x * 0.48f) / colCount;
const float rowPadding = 0.01f * mSize.y;
for (unsigned int i = 0; i < components.size(); i++) {
const unsigned int row = i % rowCount;
Vector3f pos(0.0f, 0.0f, 0.0f);
glm::vec3 pos{};
if (row == 0) {
pos = start + Vector3f(colSize * (i / rowCount), 0, 0);
pos = start + glm::vec3{colSize * (i / rowCount), 0.0f, 0.0f};
}
else {
// Work from the last component.
GuiComponent* lc = components[i - 1];
pos = lc->getPosition() + Vector3f(0, lc->getSize().y() + rowPadding, 0);
pos = lc->getPosition() + glm::vec3{0.0f, lc->getSize().y + rowPadding, 0.0f};
}
components[i]->setFont(Font::get(FONT_SIZE_SMALL));
components[i]->setPosition(pos);
components[i]->setDefaultZIndex(40);
components[i]->setDefaultZIndex(40.0f);
}
}
@ -249,23 +248,22 @@ void VideoGameListView::initMDValues()
float bottom = 0.0f;
const float colSize = (mSize.x() * 0.48f) / 2.0f;
const float colSize = (mSize.x * 0.48f) / 2.0f;
for (unsigned int i = 0; i < labels.size(); i++) {
const float heightDiff = (labels[i]->getSize().y() - values[i]->getSize().y()) / 2.0f;
const float heightDiff = (labels[i]->getSize().y - values[i]->getSize().y) / 2.0f;
values[i]->setPosition(labels[i]->getPosition() +
Vector3f(labels[i]->getSize().x(), heightDiff, 0));
values[i]->setSize(colSize - labels[i]->getSize().x(), values[i]->getSize().y());
values[i]->setDefaultZIndex(40);
glm::vec3{labels[i]->getSize().x, heightDiff, 0.0f});
values[i]->setSize(colSize - labels[i]->getSize().x, values[i]->getSize().y);
values[i]->setDefaultZIndex(40.0f);
float testBot = values[i]->getPosition().y() + values[i]->getSize().y();
float testBot = values[i]->getPosition().y + values[i]->getSize().y;
if (testBot > bottom)
bottom = testBot;
}
mDescContainer.setPosition(mDescContainer.getPosition().x(), bottom + mSize.y() * 0.01f);
mDescContainer.setSize(mDescContainer.getSize().x(),
mSize.y() - mDescContainer.getPosition().y());
mDescContainer.setPosition(mDescContainer.getPosition().x, bottom + mSize.y * 0.01f);
mDescContainer.setSize(mDescContainer.getSize().x, mSize.y - mDescContainer.getPosition().y);
}
void VideoGameListView::updateInfoPanel()

67
es-core/src/GuiComponent.cpp
View file

@ -24,11 +24,11 @@ GuiComponent::GuiComponent(Window* window)
, mColorShiftEnd(0)
, mOpacity(255)
, mSaturation(1.0f)
, mPosition(Vector3f::Zero())
, mOrigin(Vector2f::Zero())
, mPosition({})
, mOrigin({})
, mRotationOrigin(0.5f, 0.5f)
, mSize(Vector2f::Zero())
, mTransform(Transform4x4f::Identity())
, mSize({})
, mTransform(Renderer::getIdentity())
, mIsProcessing(false)
, mVisible(true)
, mEnabled(true)
@ -78,16 +78,16 @@ void GuiComponent::update(int deltaTime)
updateChildren(deltaTime);
}
void GuiComponent::render(const Transform4x4f& parentTrans)
void GuiComponent::render(const glm::mat4& parentTrans)
{
if (!isVisible())
return;
Transform4x4f trans = parentTrans * getTransform();
glm::mat4 trans{parentTrans * getTransform()};
renderChildren(trans);
}
void GuiComponent::renderChildren(const Transform4x4f& transform) const
void GuiComponent::renderChildren(const glm::mat4& transform) const
{
for (unsigned int i = 0; i < getChildCount(); i++)
getChild(i)->render(transform);
@ -95,26 +95,26 @@ void GuiComponent::renderChildren(const Transform4x4f& transform) const
void GuiComponent::setPosition(float x, float y, float z)
{
mPosition = Vector3f(x, y, z);
mPosition = glm::vec3{x, y, z};
onPositionChanged();
}
void GuiComponent::setOrigin(float x, float y)
{
mOrigin = Vector2f(x, y);
mOrigin = glm::vec2{x, y};
onOriginChanged();
}
void GuiComponent::setSize(float w, float h)
{
mSize = Vector2f(w, h);
mSize = glm::vec2{w, h};
onSizeChanged();
}
Vector2f GuiComponent::getCenter() const
glm::vec2 GuiComponent::getCenter() const
{
return Vector2f(mPosition.x() - (getSize().x() * mOrigin.x()) + getSize().x() / 2.0f,
mPosition.y() - (getSize().y() * mOrigin.y()) + getSize().y() / 2.0f);
return glm::vec2{mPosition.x - (getSize().x * mOrigin.x) + getSize().x / 2.0f,
mPosition.y - (getSize().y * mOrigin.y) + getSize().y / 2.0f};
}
void GuiComponent::addChild(GuiComponent* cmp)
@ -171,33 +171,34 @@ void GuiComponent::setOpacity(unsigned char opacity)
(*it)->setOpacity(opacity);
}
const Transform4x4f& GuiComponent::getTransform()
const glm::mat4& GuiComponent::getTransform()
{
mTransform = Transform4x4f::Identity();
mTransform.translate(mPosition);
mTransform = Renderer::getIdentity();
mTransform = glm::translate(mTransform, mPosition);
if (mScale != 1.0f)
mTransform.scale(mScale);
mTransform = glm::scale(mTransform, glm::vec3{mScale});
if (mRotation != 0.0f) {
// Calculate offset as difference between origin and rotation origin.
Vector2f rotationSize = getRotationSize();
float xOff = (mOrigin.x() - mRotationOrigin.x()) * rotationSize.x();
float yOff = (mOrigin.y() - mRotationOrigin.y()) * rotationSize.y();
glm::vec2 rotationSize{getRotationSize()};
float xOff{(mOrigin.x - mRotationOrigin.x) * rotationSize.x};
float yOff{(mOrigin.y - mRotationOrigin.y) * rotationSize.y};
// Transform to offset point.
if (xOff != 0.0f || yOff != 0.0f)
mTransform.translate(Vector3f(xOff * -1.0f, yOff * -1.0f, 0.0f));
mTransform = glm::translate(mTransform, glm::vec3{xOff * -1.0f, yOff * -1.0f, 0.0f});
// Apply rotation transform.
mTransform.rotateZ(mRotation);
mTransform = glm::rotate(mTransform, mRotation, glm::vec3{0.0f, 0.0f, 1.0f});
// Transform back to original point.
if (xOff != 0.0f || yOff != 0.0f)
mTransform.translate(Vector3f(xOff, yOff, 0.0f));
mTransform = glm::translate(mTransform, glm::vec3{xOff, yOff, 0.0f});
}
mTransform.translate(
Vector3f(mOrigin.x() * mSize.x() * -1.0f, mOrigin.y() * mSize.y() * -1.0f, 0.0f));
mTransform = glm::translate(
mTransform, glm::vec3{mOrigin.x * mSize.x * -1.0f, mOrigin.y * mSize.y * -1.0f, 0.0f});
return mTransform;
}
@ -301,9 +302,9 @@ void GuiComponent::applyTheme(const std::shared_ptr<ThemeData>& theme,
const std::string& element,
unsigned int properties)
{
Vector2f scale = getParent() ? getParent()->getSize() :
Vector2f(static_cast<float>(Renderer::getScreenWidth()),
static_cast<float>(Renderer::getScreenHeight()));
glm::vec2 scale{getParent() ? getParent()->getSize() :
glm::vec2{static_cast<float>(Renderer::getScreenWidth()),
static_cast<float>(Renderer::getScreenHeight())}};
const ThemeData::ThemeElement* elem = theme->getElement(view, element, "");
if (!elem)
@ -311,24 +312,24 @@ void GuiComponent::applyTheme(const std::shared_ptr<ThemeData>& theme,
using namespace ThemeFlags;
if (properties & POSITION && elem->has("pos")) {
Vector2f denormalized = elem->get<Vector2f>("pos") * scale;
setPosition(Vector3f(denormalized.x(), denormalized.y(), 0));
glm::vec2 denormalized{elem->get<glm::vec2>("pos") * scale};
setPosition(glm::vec3{denormalized.x, denormalized.y, 0.0f});
}
if (properties & ThemeFlags::SIZE && elem->has("size"))
setSize(elem->get<Vector2f>("size") * scale);
setSize(elem->get<glm::vec2>("size") * scale);
// Position + size also implies origin.
if ((properties & ORIGIN || (properties & POSITION && properties & ThemeFlags::SIZE)) &&
elem->has("origin")) {
setOrigin(elem->get<Vector2f>("origin"));
setOrigin(elem->get<glm::vec2>("origin"));
}
if (properties & ThemeFlags::ROTATION) {
if (elem->has("rotation"))
setRotationDegrees(elem->get<float>("rotation"));
if (elem->has("rotationOrigin"))
setRotationOrigin(elem->get<Vector2f>("rotationOrigin"));
setRotationOrigin(elem->get<glm::vec2>("rotationOrigin"));
}
if (properties & ThemeFlags::Z_INDEX && elem->has("zIndex"))

62
es-core/src/GuiComponent.h
View file

@ -14,7 +14,6 @@
#include "InputConfig.h"
#include "animations/AnimationController.h"
#include "math/Misc.h"
#include "math/Transform4x4f.h"
#include <functional>
#include <memory>
@ -45,8 +44,8 @@ public:
virtual void textInput(const std::string& text);
// Called when input is received.
// Return true if the input is consumed, false if
// it should continue to be passed to other children.
// Return true if the input is consumed, false if it should continue to be passed
// to other children.
virtual bool input(InputConfig* config, Input input);
// Called when time passes.
@ -56,49 +55,50 @@ public:
virtual void update(int deltaTime);
// Called when it's time to render.
// By default, just calls renderChildren(parentTrans * getTransform()).
// You probably want to override this like so:
// 1. Calculate the new transform that your control will draw at with
// Transform4x4f t = parentTrans * getTransform().
// By default, just calls renderChildren(parentTrans * getTransform())
// Normally the following steps are required:
// 1. Calculate the new transform that your component will draw at
// glm::mat4 trans {parentTrans * getTransform()};
// 2. Set the renderer to use that new transform as the model matrix
// Renderer::setMatrix(t);
// 3. Draw your component.
// 4. Tell your children to render, based on your component's transform - renderChildren(t).
virtual void render(const Transform4x4f& parentTrans);
// Renderer::setMatrix(trans);
// 3. Draw your component
// 4. Tell your children to render, based on your component's transform
// renderChildren(trans);
virtual void render(const glm::mat4& parentTrans);
Vector3f getPosition() const { return mPosition; }
void setPosition(const Vector3f& offset) { setPosition(offset.x(), offset.y(), offset.z()); }
glm::vec3 getPosition() const { return mPosition; }
void setPosition(const glm::vec3& offset) { setPosition(offset.x, offset.y, offset.z); }
void setPosition(float x, float y, float z = 0.0f);
virtual void onPositionChanged() {}
Vector2f getOrigin() const { return mOrigin; }
glm::vec2 getOrigin() const { return mOrigin; }
// Sets the origin as a percentage of this image.
// (e.g. (0, 0) is top left, (0.5, 0.5) is the center.)
void setOrigin(float originX, float originY);
void setOrigin(Vector2f origin) { setOrigin(origin.x(), origin.y()); }
void setOrigin(glm::vec2 origin) { setOrigin(origin.x, origin.y); }
virtual void onOriginChanged() {}
Vector2f getRotationOrigin() const { return mRotationOrigin; }
glm::vec2 getRotationOrigin() const { return mRotationOrigin; }
// Sets the rotation origin as a percentage of this image.
// (e.g. (0, 0) is top left, (0.5, 0.5) is the center.)
void setRotationOrigin(float originX, float originY)
{
mRotationOrigin = Vector2f(originX, originY);
mRotationOrigin = glm::vec2{originX, originY};
}
void setRotationOrigin(Vector2f origin) { setRotationOrigin(origin.x(), origin.y()); }
void setRotationOrigin(glm::vec2 origin) { setRotationOrigin(origin.x, origin.y); }
virtual Vector2f getSize() const { return mSize; }
void setSize(const Vector2f& size) { setSize(size.x(), size.y()); }
virtual glm::vec2 getSize() const { return mSize; }
void setSize(const glm::vec2& size) { setSize(size.x, size.y); }
void setSize(float w, float h);
virtual void setResize(float width, float height) {}
virtual void onSizeChanged() {}
virtual Vector2f getRotationSize() const { return getSize(); }
virtual glm::vec2 getRotationSize() const { return getSize(); }
float getRotation() const { return mRotation; }
void setRotation(float rotation) { mRotation = rotation; }
void setRotationDegrees(float rotation)
{
setRotation(static_cast<float>(ES_DEG_TO_RAD(rotation)));
setRotation(static_cast<float>(glm::radians(rotation)));
}
float getScale() const { return mScale; }
@ -114,7 +114,7 @@ public:
void setVisible(bool visible) { mVisible = visible; }
// Returns the center point of the image (takes origin into account).
Vector2f getCenter() const;
glm::vec2 getCenter() const;
void setParent(GuiComponent* parent) { mParent = parent; }
GuiComponent* getParent() const { return mParent; }
@ -183,7 +183,7 @@ public:
virtual std::shared_ptr<Font> getFont() const { return nullptr; }
const Transform4x4f& getTransform();
const glm::mat4& getTransform();
virtual std::string getValue() const { return ""; }
virtual void setValue(const std::string& value) {}
@ -231,7 +231,7 @@ public:
const static unsigned char MAX_ANIMATIONS = 4;
protected:
void renderChildren(const Transform4x4f& transform) const;
void renderChildren(const glm::mat4& transform) const;
void updateSelf(int deltaTime); // Updates animations.
void updateChildren(int deltaTime); // Updates animations.
@ -249,10 +249,10 @@ protected:
GuiComponent* mParent;
std::vector<GuiComponent*> mChildren;
Vector3f mPosition;
Vector2f mOrigin;
Vector2f mRotationOrigin;
Vector2f mSize;
glm::vec3 mPosition;
glm::vec2 mOrigin;
glm::vec2 mRotationOrigin;
glm::vec2 mSize;
float mRotation = 0.0;
float mScale = 1.0;
@ -265,8 +265,8 @@ protected:
bool mEnabled;
private:
// Don't access this directly! Use getTransform()!
Transform4x4f mTransform;
// Don't access this directly, instead use getTransform().
glm::mat4 mTransform;
AnimationController* mAnimationMap[MAX_ANIMATIONS];
};

13
es-core/src/HelpStyle.cpp
View file

@ -13,8 +13,9 @@
HelpStyle::HelpStyle()
{
position = Vector2f(Renderer::getScreenWidth() * 0.012f, Renderer::getScreenHeight() * 0.9515f);
origin = Vector2f(0.0f, 0.0f);
position =
glm::vec2{Renderer::getScreenWidth() * 0.012f, Renderer::getScreenHeight() * 0.9515f};
origin = glm::vec2{};
iconColor = 0x777777FF;
textColor = 0x777777FF;
@ -31,12 +32,12 @@ void HelpStyle::applyTheme(const std::shared_ptr<ThemeData>& theme, const std::s
return;
if (elem->has("pos"))
position =
elem->get<Vector2f>("pos") * Vector2f(static_cast<float>(Renderer::getScreenWidth()),
static_cast<float>(Renderer::getScreenHeight()));
position = elem->get<glm::vec2>("pos") *
glm::vec2{static_cast<float>(Renderer::getScreenWidth()),
static_cast<float>(Renderer::getScreenHeight())};
if (elem->has("origin"))
origin = elem->get<Vector2f>("origin");
origin = elem->get<glm::vec2>("origin");
if (elem->has("textColor"))
textColor = elem->get<unsigned int>("textColor");

6
es-core/src/HelpStyle.h
View file

@ -10,7 +10,7 @@
#ifndef ES_CORE_HELP_STYLE_H
#define ES_CORE_HELP_STYLE_H
#include "math/Vector2f.h"
#include "math/Misc.h"
#include <memory>
#include <string>
@ -19,8 +19,8 @@ class Font;
class ThemeData;
struct HelpStyle {
Vector2f position;
Vector2f origin;
glm::vec2 position;
glm::vec2 origin;
unsigned int iconColor;
unsigned int textColor;
std::shared_ptr<Font> font;

3
es-core/src/Log.h
View file

@ -53,8 +53,7 @@ private:
{LogError, "Error"},
{LogWarning, "Warn"},
{LogInfo, "Info"},
{ LogDebug, "Debug" }
};
{LogDebug, "Debug"}};
static LogLevel reportingLevel;
LogLevel messageLevel;

29
es-core/src/ThemeData.cpp
View file

@ -24,11 +24,9 @@
std::vector<std::string> ThemeData::sSupportedViews{{"all"}, {"system"}, {"basic"},
{"detailed"}, {"grid"}, {"video"}};
std::vector<std::string> ThemeData::sSupportedFeatures{
{ "navigationsounds" }, { "video" }, { "carousel" }, { "z-index" }, { "visible" }
};
{"navigationsounds"}, {"video"}, {"carousel"}, {"z-index"}, {"visible"}};
std::map<std::string, std::map<std::string, ThemeData::ElementPropertyType>>
ThemeData::sElementMap {
std::map<std::string, std::map<std::string, ThemeData::ElementPropertyType>> ThemeData::sElementMap{
{"image",
{{"pos", NORMALIZED_PAIR},
{"size", NORMALIZED_PAIR},
@ -191,8 +189,7 @@ std::map<std::string, std::map<std::string, ThemeData::ElementPropertyType>>
{"logoSize", NORMALIZED_PAIR},
{"logoAlignment", STRING},
{"maxLogoCount", FLOAT},
{ "zIndex", FLOAT } } }
};
{"zIndex", FLOAT}}}};
#define MINIMUM_THEME_FORMAT_VERSION 3
#define CURRENT_THEME_FORMAT_VERSION 6
@ -450,20 +447,20 @@ void ThemeData::parseElement(const pugi::xml_node& root,
switch (typeIt->second) {
case NORMALIZED_RECT: {
Vector4f val;
glm::vec4 val;
auto splits = Utils::String::delimitedStringToVector(str, " ");
if (splits.size() == 2) {
val = Vector4f(static_cast<float>(atof(splits.at(0).c_str())),
val = glm::vec4{static_cast<float>(atof(splits.at(0).c_str())),
static_cast<float>(atof(splits.at(1).c_str())),
static_cast<float>(atof(splits.at(0).c_str())),
static_cast<float>(atof(splits.at(1).c_str())));
static_cast<float>(atof(splits.at(1).c_str()))};
}
else if (splits.size() == 4) {
val = Vector4f(static_cast<float>(atof(splits.at(0).c_str())),
val = glm::vec4{static_cast<float>(atof(splits.at(0).c_str())),
static_cast<float>(atof(splits.at(1).c_str())),
static_cast<float>(atof(splits.at(2).c_str())),
static_cast<float>(atof(splits.at(3).c_str())));
static_cast<float>(atof(splits.at(3).c_str()))};
}
element.properties[node.name()] = val;
@ -475,11 +472,11 @@ void ThemeData::parseElement(const pugi::xml_node& root,
throw error << "invalid normalized pair (property \"" << node.name()
<< "\", value \"" << str.c_str() << "\")";
std::string first = str.substr(0, divider);
std::string second = str.substr(divider, std::string::npos);
std::string first{str.substr(0, divider)};
std::string second{str.substr(divider, std::string::npos)};
Vector2f val(static_cast<float>(atof(first.c_str())),
static_cast<float>(atof(second.c_str())));
glm::vec2 val{static_cast<float>(atof(first.c_str())),
static_cast<float>(atof(second.c_str()))};
element.properties[node.name()] = val;
break;
@ -602,7 +599,7 @@ std::vector<GuiComponent*> ThemeData::makeExtras(const std::shared_ptr<ThemeData
comp = new TextComponent(window);
if (comp) {
comp->setDefaultZIndex(10);
comp->setDefaultZIndex(10.0f);
comp->applyTheme(theme, view, *it, ThemeFlags::ALL);
comps.push_back(comp);
}

19
es-core/src/ThemeData.h
View file

@ -11,8 +11,7 @@
#ifndef ES_CORE_THEME_DATA_H
#define ES_CORE_THEME_DATA_H
#include "math/Vector2f.h"
#include "math/Vector4f.h"
#include "math/Misc.h"
#include "utils/FileSystemUtil.h"
#include <deque>
@ -103,20 +102,20 @@ public:
std::string type;
struct Property {
void operator=(const Vector4f& value)
void operator=(const glm::vec4& value)
{
r = value;
const Vector4f initVector = value;
v = Vector2f(initVector.x(), initVector.y());
const glm::vec4 initVector{value};
v = glm::vec2{initVector.x, initVector.y};
}
void operator=(const Vector2f& value) { v = value; }
void operator=(const glm::vec2& value) { v = value; }
void operator=(const std::string& value) { s = value; }
void operator=(const unsigned int& value) { i = value; }
void operator=(const float& value) { f = value; }
void operator=(const bool& value) { b = value; }
Vector4f r;
Vector2f v;
glm::vec4 r;
glm::vec2 v;
std::string s;
unsigned int i;
float f;
@ -127,7 +126,7 @@ public:
template <typename T> const T get(const std::string& prop) const
{
if (std::is_same<T, Vector2f>::value)
if (std::is_same<T, glm::vec2>::value)
return *(const T*)&properties.at(prop).v;
else if (std::is_same<T, std::string>::value)
return *(const T*)&properties.at(prop).s;
@ -137,7 +136,7 @@ public:
return *(const T*)&properties.at(prop).f;
else if (std::is_same<T, bool>::value)
return *(const T*)&properties.at(prop).b;
else if (std::is_same<T, Vector4f>::value)
else if (std::is_same<T, glm::vec4>::value)
return *(const T*)&properties.at(prop).r;
return T();
}

41
es-core/src/Window.cpp
View file

@ -18,6 +18,7 @@
#include "InputManager.h"
#include "Log.h"
#include "Sound.h"
#include "math/Misc.h"
#include "resources/Font.h"
#include <algorithm>
@ -348,7 +349,7 @@ void Window::update(int deltaTime)
void Window::render()
{
Transform4x4f transform = Transform4x4f::Identity();
glm::mat4 trans{Renderer::getIdentity()};
mRenderedHelpPrompts = false;
@ -378,7 +379,7 @@ void Window::render()
renderBottom = false;
if (renderBottom)
bottom->render(transform);
bottom->render(trans);
if (bottom != top || mRenderLaunchScreen) {
#if defined(USE_OPENGL_21)
@ -468,21 +469,21 @@ void Window::render()
}
#endif // USE_OPENGL_21
mBackgroundOverlay->render(transform);
mBackgroundOverlay->render(trans);
// Scale-up menu opening effect.
if (Settings::getInstance()->getString("MenuOpeningEffect") == "scale-up") {
if (mTopScale < 1.0f) {
mTopScale = Math::clamp(mTopScale + 0.07f, 0.0f, 1.0f);
Vector2f topCenter = top->getCenter();
glm::vec2 topCenter{top->getCenter()};
top->setOrigin({0.5f, 0.5f});
top->setPosition({ topCenter.x(), topCenter.y(), 0.0f });
top->setPosition({topCenter.x, topCenter.y, 0.0f});
top->setScale(mTopScale);
}
}
if (!mRenderLaunchScreen)
top->render(transform);
top->render(trans);
}
else {
mCachedBackground = false;
@ -493,23 +494,23 @@ void Window::render()
// Render the quick list scrolling overlay, which is triggered in IList.
if (mListScrollOpacity != 0) {
Renderer::setMatrix(Transform4x4f::Identity());
Renderer::setMatrix(Renderer::getIdentity());
Renderer::drawRect(0.0f, 0.0f, static_cast<float>(Renderer::getScreenWidth()),
static_cast<float>(Renderer::getScreenHeight()),
0x00000000 | mListScrollOpacity, 0x00000000 | mListScrollOpacity);
Vector2f offset = mListScrollFont->sizeText(mListScrollText);
offset[0] = (Renderer::getScreenWidth() - offset.x()) * 0.5f;
offset[1] = (Renderer::getScreenHeight() - offset.y()) * 0.5f;
glm::vec2 offset{mListScrollFont->sizeText(mListScrollText)};
offset.x = (Renderer::getScreenWidth() - offset.x) * 0.5f;
offset.y = (Renderer::getScreenHeight() - offset.y) * 0.5f;
TextCache* cache = mListScrollFont->buildTextCache(mListScrollText, offset.x(), offset.y(),
TextCache* cache = mListScrollFont->buildTextCache(mListScrollText, offset.x, offset.y,
0xFFFFFF00 | mListScrollOpacity);
mListScrollFont->renderTextCache(cache);
delete cache;
}
if (!mRenderedHelpPrompts)
mHelp->render(transform);
mHelp->render(trans);
unsigned int screensaverTimer =
static_cast<unsigned int>(Settings::getInstance()->getInt("ScreensaverTimer"));
@ -531,7 +532,7 @@ void Window::render()
renderScreensaver();
if (!mRenderScreensaver && mInfoPopup)
mInfoPopup->render(transform);
mInfoPopup->render(trans);
if (mTimeSinceLastInput >= screensaverTimer && screensaverTimer != 0) {
if (!isProcessing() && mAllowSleep && (!mScreensaver)) {
@ -550,14 +551,14 @@ void Window::render()
mLaunchScreen->render();
if (Settings::getInstance()->getBool("DisplayGPUStatistics") && mFrameDataText) {
Renderer::setMatrix(Transform4x4f::Identity());
Renderer::setMatrix(Renderer::getIdentity());
mDefaultFonts.at(1)->renderTextCache(mFrameDataText.get());
}
}
void Window::renderLoadingScreen(std::string text)
{
Transform4x4f trans = Transform4x4f::Identity();
glm::mat4 trans{Renderer::getIdentity()};
Renderer::setMatrix(trans);
Renderer::drawRect(0.0f, 0.0f, static_cast<float>(Renderer::getScreenWidth()),
static_cast<float>(Renderer::getScreenHeight()), 0x000000FF, 0x000000FF);
@ -565,16 +566,16 @@ void Window::renderLoadingScreen(std::string text)
ImageComponent splash(this, true);
splash.setResize(Renderer::getScreenWidth() * 0.6f, 0.0f);
splash.setImage(":/graphics/splash.svg");
splash.setPosition((Renderer::getScreenWidth() - splash.getSize().x()) / 2.0f,
(Renderer::getScreenHeight() - splash.getSize().y()) / 2.0f * 0.6f);
splash.setPosition((Renderer::getScreenWidth() - splash.getSize().x) / 2.0f,
(Renderer::getScreenHeight() - splash.getSize().y) / 2.0f * 0.6f);
splash.render(trans);
auto& font = mDefaultFonts.at(1);
TextCache* cache = font->buildTextCache(text, 0.0f, 0.0f, 0x656565FF);
float x = std::round((Renderer::getScreenWidth() - cache->metrics.size.x()) / 2.0f);
float x = std::round((Renderer::getScreenWidth() - cache->metrics.size.x) / 2.0f);
float y = std::round(Renderer::getScreenHeight() * 0.835f);
trans = trans.translate(Vector3f(x, y, 0.0f));
trans = glm::translate(trans, glm::vec3{x, y, 0.0f});
Renderer::setMatrix(trans);
font->renderTextCache(cache);
delete cache;
@ -590,7 +591,7 @@ void Window::renderListScrollOverlay(unsigned char opacity, const std::string& t
void Window::renderHelpPromptsEarly()
{
mHelp->render(Transform4x4f::Identity());
mHelp->render(Renderer::getIdentity());
mRenderedHelpPrompts = true;
}

3
es-core/src/Window.h
View file

@ -26,7 +26,6 @@ class HelpComponent;
class ImageComponent;
class InputConfig;
class TextCache;
class Transform4x4f;
struct HelpStyle;
class Window
@ -77,7 +76,7 @@ public:
class InfoPopup
{
public:
virtual void render(const Transform4x4f& parentTrans) = 0;
virtual void render(const glm::mat4& parentTrans) = 0;
virtual void stop() = 0;
virtual ~InfoPopup() {}
};

6
es-core/src/components/AnimatedImageComponent.cpp
View file

@ -33,7 +33,7 @@ void AnimatedImageComponent::load(const AnimationDef* def)
}
auto img = std::unique_ptr<ImageComponent>(new ImageComponent(mWindow));
img->setResize(mSize.x(), mSize.y());
img->setResize(mSize.x, mSize.y);
img->setImage(std::string(def->frames[i].path), false);
mFrames.push_back(ImageFrame(std::move(img), def->frames[i].time));
@ -55,7 +55,7 @@ void AnimatedImageComponent::reset()
void AnimatedImageComponent::onSizeChanged()
{
for (auto it = mFrames.cbegin(); it != mFrames.cend(); it++) {
it->first->setResize(mSize.x(), mSize.y());
it->first->setResize(mSize.x, mSize.y);
}
}
@ -86,7 +86,7 @@ void AnimatedImageComponent::update(int deltaTime)
}
}
void AnimatedImageComponent::render(const Transform4x4f& trans)
void AnimatedImageComponent::render(const glm::mat4& trans)
{
if (mFrames.size())
mFrames.at(mCurrentFrame).first->render(getTransform() * trans);

2
es-core/src/components/AnimatedImageComponent.h
View file

@ -34,7 +34,7 @@ public:
void reset(); // Set to frame 0.
void update(int deltaTime) override;
void render(const Transform4x4f& trans) override;
void render(const glm::mat4& trans) override;
void onSizeChanged() override;

28
es-core/src/components/BusyComponent.cpp
View file

@ -25,7 +25,7 @@ const AnimationDef BUSY_ANIMATION_DEF = { BUSY_ANIMATION_FRAMES, 4, true };
BusyComponent::BusyComponent(Window* window)
: GuiComponent(window)
, mBackground(window, ":/graphics/frame.png")
, mGrid(window, Vector2i(5, 3))
, mGrid(window, glm::ivec2{5, 3})
{
mAnimation = std::make_shared<AnimatedImageComponent>(mWindow);
mAnimation->load(&BUSY_ANIMATION_DEF);
@ -33,8 +33,8 @@ BusyComponent::BusyComponent(Window* window)
0x777777FF);
// Col 0 = animation, col 1 = spacer, col 2 = text.
mGrid.setEntry(mAnimation, Vector2i(1, 1), false, true);
mGrid.setEntry(mText, Vector2i(3, 1), false, true);
mGrid.setEntry(mAnimation, glm::ivec2{1, 1}, false, true);
mGrid.setEntry(mText, glm::ivec2{3, 1}, false, true);
addChild(&mBackground);
addChild(&mGrid);
@ -44,25 +44,25 @@ void BusyComponent::onSizeChanged()
{
mGrid.setSize(mSize);
if (mSize.x() == 0 || mSize.y() == 0)
if (mSize.x == 0.0f || mSize.y == 0.0f)
return;
const float middleSpacerWidth = 0.01f * Renderer::getScreenWidth();
const float textHeight = mText->getFont()->getLetterHeight();
mText->setSize(0, textHeight);
const float textWidth = mText->getSize().x() + (4 * Renderer::getScreenWidthModifier());
const float textWidth = mText->getSize().x + (4.0f * Renderer::getScreenWidthModifier());
mGrid.setColWidthPerc(1, textHeight / mSize.x()); // Animation is square.
mGrid.setColWidthPerc(2, middleSpacerWidth / mSize.x());
mGrid.setColWidthPerc(3, textWidth / mSize.x());
mGrid.setColWidthPerc(1, textHeight / mSize.x); // Animation is square.
mGrid.setColWidthPerc(2, middleSpacerWidth / mSize.x);
mGrid.setColWidthPerc(3, textWidth / mSize.x);
mGrid.setRowHeightPerc(1, textHeight / mSize.y());
mGrid.setRowHeightPerc(1, textHeight / mSize.y);
mBackground.setCornerSize({ 16.0f * Renderer::getScreenWidthModifier(),
16.0f * Renderer::getScreenHeightModifier() });
mBackground.fitTo(Vector2f(mGrid.getColWidth(1) + mGrid.getColWidth(2) + mGrid.getColWidth(3),
textHeight + (2.0f * Renderer::getScreenHeightModifier())),
mAnimation->getPosition(), Vector2f(0, 0));
mBackground.setCornerSize(
{16.0f * Renderer::getScreenWidthModifier(), 16.0f * Renderer::getScreenHeightModifier()});
mBackground.fitTo(glm::vec2{mGrid.getColWidth(1) + mGrid.getColWidth(2) + mGrid.getColWidth(3),
textHeight + (2.0f * Renderer::getScreenHeightModifier())},
mAnimation->getPosition(), glm::vec2{});
}
void BusyComponent::reset()

26
es-core/src/components/ButtonComponent.cpp
View file

@ -32,7 +32,7 @@ ButtonComponent::ButtonComponent(Window* window,
void ButtonComponent::onSizeChanged()
{
// Fit to mBox.
mBox.fitTo(mSize, Vector3f::Zero(), Vector2f(-32.0f, -32.0f));
mBox.fitTo(mSize, glm::vec3{}, glm::vec2{-32.0f, -32.0f});
}
bool ButtonComponent::input(InputConfig* config, Input input)
@ -53,10 +53,10 @@ void ButtonComponent::setText(const std::string& text, const std::string& helpTe
mTextCache = std::unique_ptr<TextCache>(mFont->buildTextCache(mText, 0, 0, getCurTextColor()));
float minWidth = mFont->sizeText("DELETE").x() + (12.0f * Renderer::getScreenWidthModifier());
setSize(std::max(mTextCache->metrics.size.x() + (12.0f * Renderer::getScreenWidthModifier()),
float minWidth = mFont->sizeText("DELETE").x + (12.0f * Renderer::getScreenWidthModifier());
setSize(std::max(mTextCache->metrics.size.x + (12.0f * Renderer::getScreenWidthModifier()),
minWidth),
mTextCache->metrics.size.y());
mTextCache->metrics.size.y);
updateHelpPrompts();
}
@ -93,29 +93,29 @@ void ButtonComponent::updateImage()
mBox.setImagePath(mFocused ? ":/graphics/button_filled.svg" : ":/graphics/button.svg");
}
void ButtonComponent::render(const Transform4x4f& parentTrans)
void ButtonComponent::render(const glm::mat4& parentTrans)
{
Transform4x4f trans = parentTrans * getTransform();
glm::mat4 trans{parentTrans * getTransform()};
mBox.render(trans);
if (mTextCache) {
Vector3f centerOffset((mSize.x() - mTextCache->metrics.size.x()) / 2.0f,
(mSize.y() - mTextCache->metrics.size.y()) / 2.0f, 0);
trans = trans.translate(centerOffset);
glm::vec3 centerOffset{(mSize.x - mTextCache->metrics.size.x) / 2.0f,
(mSize.y - mTextCache->metrics.size.y) / 2.0f, 0.0f};
trans = glm::translate(trans, centerOffset);
if (Settings::getInstance()->getBool("DebugText")) {
Renderer::drawRect(centerOffset.x(), 0.0f, mTextCache->metrics.size.x(), mSize.y(),
Renderer::drawRect(centerOffset.x, 0.0f, mTextCache->metrics.size.x, mSize.y,
0x00000033, 0x00000033);
Renderer::drawRect(mBox.getPosition().x(), 0.0f, mBox.getSize().x(), mSize.y(),
0x0000FF33, 0x0000FF33);
Renderer::drawRect(mBox.getPosition().x, 0.0f, mBox.getSize().x, mSize.y, 0x0000FF33,
0x0000FF33);
}
Renderer::setMatrix(trans);
mTextCache->setColor(getCurTextColor());
mFont->renderTextCache(mTextCache.get());
trans = trans.translate(-centerOffset);
trans = glm::translate(trans, -centerOffset);
}
renderChildren(trans);

2
es-core/src/components/ButtonComponent.h
View file

@ -26,7 +26,7 @@ public:
void setEnabled(bool state) override;
bool input(InputConfig* config, Input input) override;
void render(const Transform4x4f& parentTrans) override;
void render(const glm::mat4& parentTrans) override;
void setText(const std::string& text, const std::string& helpText);

156
es-core/src/components/ComponentGrid.cpp
View file

@ -12,21 +12,21 @@
using namespace GridFlags;
ComponentGrid::ComponentGrid(Window* window, const Vector2i& gridDimensions)
ComponentGrid::ComponentGrid(Window* window, const glm::ivec2& gridDimensions)
: GuiComponent(window)
, mGridSize(gridDimensions)
, mCursor(0, 0)
{
assert(gridDimensions.x() > 0 && gridDimensions.y() > 0);
assert(gridDimensions.x > 0 && gridDimensions.y > 0);
mCells.reserve(gridDimensions.x() * gridDimensions.y());
mCells.reserve(gridDimensions.x * gridDimensions.y);
mColWidths = new float[gridDimensions.x()];
mRowHeights = new float[gridDimensions.y()];
mColWidths = new float[gridDimensions.x];
mRowHeights = new float[gridDimensions.y];
for (int x = 0; x < gridDimensions.x(); x++)
for (int x = 0; x < gridDimensions.x; x++)
mColWidths[x] = 0;
for (int y = 0; y < gridDimensions.y(); y++)
for (int y = 0; y < gridDimensions.y; y++)
mRowHeights[y] = 0;
}
@ -39,40 +39,40 @@ ComponentGrid::~ComponentGrid()
float ComponentGrid::getColWidth(int col)
{
if (mColWidths[col] != 0)
return mColWidths[col] * mSize.x();
return mColWidths[col] * mSize.x;
// Calculate automatic width.
float freeWidthPerc = 1;
int between = 0;
for (int x = 0; x < mGridSize.x(); x++) {
for (int x = 0; x < mGridSize.x; x++) {
freeWidthPerc -= mColWidths[x]; // If it's 0 it won't do anything.
if (mColWidths[x] == 0)
between++;
}
return (freeWidthPerc * mSize.x()) / between;
return (freeWidthPerc * mSize.x) / static_cast<float>(between);
}
float ComponentGrid::getRowHeight(int row)
{
if (mRowHeights[row] != 0)
return mRowHeights[row] * mSize.y();
return mRowHeights[row] * mSize.y;
// Calculate automatic height.
float freeHeightPerc = 1;
int between = 0;
for (int y = 0; y < mGridSize.y(); y++) {
for (int y = 0; y < mGridSize.y; y++) {
freeHeightPerc -= mRowHeights[y]; // If it's 0 it won't do anything.
if (mRowHeights[y] == 0)
between++;
}
return (freeHeightPerc * mSize.y()) / between;
return (freeHeightPerc * mSize.y) / static_cast<float>(between);
}
void ComponentGrid::setColWidthPerc(int col, float width, bool update)
{
assert(col >= 0 && col < mGridSize.x());
assert(col >= 0 && col < mGridSize.x);
mColWidths[col] = width;
if (update)
@ -82,7 +82,7 @@ void ComponentGrid::setColWidthPerc(int col, float width, bool update)
void ComponentGrid::setRowHeightPerc(int row, float height, bool update)
{
assert(height >= 0 && height <= 1);
assert(row >= 0 && row < mGridSize.y());
assert(row >= 0 && row < mGridSize.y);
mRowHeights[row] = height;
if (update)
@ -90,14 +90,14 @@ void ComponentGrid::setRowHeightPerc(int row, float height, bool update)
}
void ComponentGrid::setEntry(const std::shared_ptr<GuiComponent>& comp,
const Vector2i& pos,
const glm::ivec2& pos,
bool canFocus,
bool resize,
const Vector2i& size,
const glm::ivec2& size,
unsigned int border,
GridFlags::UpdateType updateType)
{
assert(pos.x() >= 0 && pos.x() < mGridSize.x() && pos.y() >= 0 && pos.y() < mGridSize.y());
assert(pos.x >= 0 && pos.x < mGridSize.x && pos.y >= 0 && pos.y < mGridSize.y);
assert(comp != nullptr);
assert(comp->getParent() == nullptr);
@ -132,26 +132,25 @@ bool ComponentGrid::removeEntry(const std::shared_ptr<GuiComponent>& comp)
void ComponentGrid::updateCellComponent(const GridEntry& cell)
{
// Size.
Vector2f size(0, 0);
for (int x = cell.pos.x(); x < cell.pos.x() + cell.dim.x(); x++)
size[0] += getColWidth(x);
for (int y = cell.pos.y(); y < cell.pos.y() + cell.dim.y(); y++)
size[1] += getRowHeight(y);
glm::vec2 size{0.0f};
for (int x = cell.pos.x; x < cell.pos.x + cell.dim.x; x++)
size.x += getColWidth(x);
for (int y = cell.pos.y; y < cell.pos.y + cell.dim.y; y++)
size.y += getRowHeight(y);
if (cell.resize)
cell.component->setSize(size);
// Position.
// Find top left corner.
Vector3f pos(0, 0, 0);
for (int x = 0; x < cell.pos.x(); x++)
pos[0] += getColWidth(x);
for (int y = 0; y < cell.pos.y(); y++)
pos[1] += getRowHeight(y);
glm::vec3 pos{};
for (int x = 0; x < cell.pos.x; x++)
pos.x += getColWidth(x);
for (int y = 0; y < cell.pos.y; y++)
pos.y += getRowHeight(y);
// Center component.
pos[0] = pos.x() + (size.x() - cell.component->getSize().x()) / 2;
pos[1] = pos.y() + (size.y() - cell.component->getSize().y()) / 2;
pos.x = pos.x + (size.x - cell.component->getSize().x) / 2.0f;
pos.y = pos.y + (size.y - cell.component->getSize().y) / 2.0f;
cell.component->setPosition(pos);
}
@ -162,58 +161,58 @@ void ComponentGrid::updateSeparators()
bool drawAll = Settings::getInstance()->getBool("DebugGrid");
Vector2f pos;
Vector2f size;
glm::vec2 pos;
glm::vec2 size;
for (auto it = mCells.cbegin(); it != mCells.cend(); it++) {
if (!it->border && !drawAll)
continue;
// Find component position + size.
pos = Vector2f(0, 0);
size = Vector2f(0, 0);
for (int x = 0; x < it->pos.x(); x++)
pos = glm::vec2{};
size = glm::vec2{};
for (int x = 0; x < it->pos.x; x++)
pos[0] += getColWidth(x);
for (int y = 0; y < it->pos.y(); y++)
for (int y = 0; y < it->pos.y; y++)
pos[1] += getRowHeight(y);
for (int x = it->pos.x(); x < it->pos.x() + it->dim.x(); x++)
for (int x = it->pos.x; x < it->pos.x + it->dim.x; x++)
size[0] += getColWidth(x);
for (int y = it->pos.y(); y < it->pos.y() + it->dim.y(); y++)
for (int y = it->pos.y; y < it->pos.y + it->dim.y; y++)
size[1] += getRowHeight(y);
if (size == 0)
if (size == glm::vec2{})
return;
if (it->border & BORDER_TOP || drawAll) {
std::vector<float> coordVector;
coordVector.push_back(pos.x());
coordVector.push_back(pos.y());
coordVector.push_back(size.x());
coordVector.push_back(pos.x);
coordVector.push_back(pos.y);
coordVector.push_back(size.x);
coordVector.push_back(1.0f * Renderer::getScreenHeightModifier());
mSeparators.push_back(coordVector);
}
if (it->border & BORDER_BOTTOM || drawAll) {
std::vector<float> coordVector;
coordVector.push_back(pos.x());
coordVector.push_back(pos.y() + size.y());
coordVector.push_back(size.x());
coordVector.push_back(pos.x);
coordVector.push_back(pos.y + size.y);
coordVector.push_back(size.x);
coordVector.push_back(1.0f * Renderer::getScreenHeightModifier());
mSeparators.push_back(coordVector);
}
if (it->border & BORDER_LEFT || drawAll) {
std::vector<float> coordVector;
coordVector.push_back(pos.x());
coordVector.push_back(pos.y());
coordVector.push_back(pos.x);
coordVector.push_back(pos.y);
coordVector.push_back(1.0f * Renderer::getScreenWidthModifier());
coordVector.push_back(size.y());
coordVector.push_back(size.y);
mSeparators.push_back(coordVector);
}
if (it->border & BORDER_RIGHT || drawAll) {
std::vector<float> coordVector;
coordVector.push_back(pos.x() + size.x());
coordVector.push_back(pos.y());
coordVector.push_back(pos.x + size.x);
coordVector.push_back(pos.y);
coordVector.push_back(1.0f * Renderer::getScreenWidthModifier());
coordVector.push_back(size.y());
coordVector.push_back(size.y);
mSeparators.push_back(coordVector);
}
}
@ -229,13 +228,13 @@ void ComponentGrid::onSizeChanged()
const ComponentGrid::GridEntry* ComponentGrid::getCellAt(int x, int y) const
{
assert(x >= 0 && x < mGridSize.x() && y >= 0 && y < mGridSize.y());
assert(x >= 0 && x < mGridSize.x && y >= 0 && y < mGridSize.y);
for (auto it = mCells.cbegin(); it != mCells.cend(); it++) {
int xmin = it->pos.x();
int xmax = xmin + it->dim.x();
int ymin = it->pos.y();
int ymax = ymin + it->dim.y();
int xmin = it->pos.x;
int xmax = xmin + it->dim.x;
int ymin = it->pos.y;
int ymax = ymin + it->dim.y;
if (x >= xmin && y >= ymin && x < xmax && y < ymax)
return &(*it);
@ -254,16 +253,16 @@ bool ComponentGrid::input(InputConfig* config, Input input)
return false;
if (config->isMappedLike("down", input))
return moveCursor(Vector2i(0, 1));
return moveCursor(glm::ivec2{0, 1});
if (config->isMappedLike("up", input))
return moveCursor(Vector2i(0, -1));
return moveCursor(glm::ivec2{0, -1});
if (config->isMappedLike("left", input))
return moveCursor(Vector2i(-1, 0));
return moveCursor(glm::ivec2{-1, 0});
if (config->isMappedLike("right", input))
return moveCursor(Vector2i(1, 0));
return moveCursor(glm::ivec2{1, 0});
return false;
}
@ -275,7 +274,7 @@ void ComponentGrid::resetCursor()
for (auto it = mCells.cbegin(); it != mCells.cend(); it++) {
if (it->canFocus) {
Vector2i origCursor = mCursor;
glm::ivec2 origCursor = mCursor;
mCursor = it->pos;
onCursorMoved(origCursor, mCursor);
break;
@ -283,23 +282,22 @@ void ComponentGrid::resetCursor()
}
}
bool ComponentGrid::moveCursor(Vector2i dir)
bool ComponentGrid::moveCursor(glm::ivec2 dir)
{
assert(dir.x() || dir.y());
assert(dir.x || dir.y);
const Vector2i origCursor = mCursor;
const glm::ivec2 origCursor{mCursor};
const GridEntry* currentCursorEntry = getCellAt(mCursor);
Vector2i searchAxis(dir.x() == 0, dir.y() == 0);
glm::ivec2 searchAxis(dir.x == 0, dir.y == 0);
while (mCursor.x() >= 0 && mCursor.y() >= 0 && mCursor.x() < mGridSize.x() &&
mCursor.y() < mGridSize.y()) {
while (mCursor.x >= 0 && mCursor.y >= 0 && mCursor.x < mGridSize.x && mCursor.y < mGridSize.y) {
mCursor = mCursor + dir;
Vector2i curDirPos = mCursor;
glm::ivec2 curDirPos{mCursor};
const GridEntry* cursorEntry;
// Spread out on search axis+
while (mCursor.x() < mGridSize.x() && mCursor.y() < mGridSize.y() && mCursor.x() >= 0 &&
mCursor.y() >= 0) {
while (mCursor.x < mGridSize.x && mCursor.y < mGridSize.y && mCursor.x >= 0 &&
mCursor.y >= 0) {
cursorEntry = getCellAt(mCursor);
if (cursorEntry && cursorEntry->canFocus && cursorEntry != currentCursorEntry) {
onCursorMoved(origCursor, mCursor);
@ -310,8 +308,8 @@ bool ComponentGrid::moveCursor(Vector2i dir)
// Now again on search axis-
mCursor = curDirPos;
while (mCursor.x() >= 0 && mCursor.y() >= 0 && mCursor.x() < mGridSize.x() &&
mCursor.y() < mGridSize.y()) {
while (mCursor.x >= 0 && mCursor.y >= 0 && mCursor.x < mGridSize.x &&
mCursor.y < mGridSize.y) {
cursorEntry = getCellAt(mCursor);
if (cursorEntry && cursorEntry->canFocus && cursorEntry != currentCursorEntry) {
@ -360,9 +358,9 @@ void ComponentGrid::update(int deltaTime)
}
}
void ComponentGrid::render(const Transform4x4f& parentTrans)
void ComponentGrid::render(const glm::mat4& parentTrans)
{
Transform4x4f trans = parentTrans * getTransform();
glm::mat4 trans{parentTrans * getTransform()};
renderChildren(trans);
@ -381,7 +379,7 @@ void ComponentGrid::textInput(const std::string& text)
selectedEntry->component->textInput(text);
}
void ComponentGrid::onCursorMoved(Vector2i from, Vector2i to)
void ComponentGrid::onCursorMoved(glm::ivec2 from, glm::ivec2 to)
{
const GridEntry* cell = getCellAt(from);
if (cell)
@ -398,7 +396,7 @@ void ComponentGrid::setCursorTo(const std::shared_ptr<GuiComponent>& comp)
{
for (auto it = mCells.cbegin(); it != mCells.cend(); it++) {
if (it->component == comp) {
Vector2i oldCursor = mCursor;
glm::ivec2 oldCursor{mCursor};
mCursor = it->pos;
onCursorMoved(oldCursor, mCursor);
return;
@ -416,8 +414,8 @@ std::vector<HelpPrompt> ComponentGrid::getHelpPrompts()
if (e)
prompts = e->component->getHelpPrompts();
bool canScrollVert = mGridSize.y() > 1;
bool canScrollHoriz = mGridSize.x() > 1;
bool canScrollVert = mGridSize.y > 1;
bool canScrollHoriz = mGridSize.x > 1;
for (auto it = prompts.cbegin(); it != prompts.cend(); it++) {
if (it->first == "up/down/left/right") {
canScrollHoriz = false;

27
es-core/src/components/ComponentGrid.h
View file

@ -10,7 +10,6 @@
#define ES_CORE_COMPONENTS_COMPONENT_GRID_H
#include "GuiComponent.h"
#include "math/Vector2i.h"
#include "renderers/Renderer.h"
namespace GridFlags
@ -34,23 +33,23 @@ namespace GridFlags
class ComponentGrid : public GuiComponent
{
public:
ComponentGrid(Window* window, const Vector2i& gridDimensions);
ComponentGrid(Window* window, const glm::ivec2& gridDimensions);
virtual ~ComponentGrid();
bool removeEntry(const std::shared_ptr<GuiComponent>& comp);
void setEntry(const std::shared_ptr<GuiComponent>& comp,
const Vector2i& pos,
const glm::ivec2& pos,
bool canFocus,
bool resize = true,
const Vector2i& size = Vector2i(1, 1),
const glm::ivec2& size = glm::ivec2{1, 1},
unsigned int border = GridFlags::BORDER_NONE,
GridFlags::UpdateType updateType = GridFlags::UPDATE_ALWAYS);
void textInput(const std::string& text) override;
bool input(InputConfig* config, Input input) override;
void update(int deltaTime) override;
void render(const Transform4x4f& parentTrans) override;
void render(const glm::mat4& parentTrans) override;
void onSizeChanged() override;
void resetCursor();
@ -65,7 +64,7 @@ public:
// Dito.
void setRowHeightPerc(int row, float height, bool update = true);
bool moveCursor(Vector2i dir);
bool moveCursor(glm::ivec2 dir);
void setCursorTo(const std::shared_ptr<GuiComponent>& comp);
std::shared_ptr<GuiComponent> getSelectedComponent()
@ -86,16 +85,16 @@ private:
class GridEntry
{
public:
Vector2i pos;
Vector2i dim;
glm::ivec2 pos;
glm::ivec2 dim;
std::shared_ptr<GuiComponent> component;
bool canFocus;
bool resize;
GridFlags::UpdateType updateType;
unsigned int border;
GridEntry(const Vector2i& p = Vector2i::Zero(),
const Vector2i& d = Vector2i::Zero(),
GridEntry(const glm::ivec2& p = glm::ivec2{},
const glm::ivec2& d = glm::ivec2{},
const std::shared_ptr<GuiComponent>& cmp = nullptr,
bool f = false,
bool r = true,
@ -118,14 +117,14 @@ private:
void updateCellComponent(const GridEntry& cell);
void updateSeparators();
void onCursorMoved(Vector2i from, Vector2i to);
void onCursorMoved(glm::ivec2 from, glm::ivec2 to);
const GridEntry* getCellAt(int x, int y) const;
const GridEntry* getCellAt(const Vector2i& pos) const { return getCellAt(pos.x(), pos.y()); }
const GridEntry* getCellAt(const glm::ivec2& pos) const { return getCellAt(pos.x, pos.y); }
std::vector<std::vector<float>> mSeparators;
Vector2i mGridSize;
glm::ivec2 mGridSize;
std::vector<GridEntry> mCells;
Vector2i mCursor;
glm::ivec2 mCursor;
float* mRowHeights;
float* mColWidths;

61
es-core/src/components/ComponentList.cpp
View file

@ -145,45 +145,47 @@ void ComponentList::updateCameraOffset()
{
// Move the camera to scroll.
const float totalHeight = getTotalRowHeight();
if (totalHeight > mSize.y()) {
float target = mSelectorBarOffset + getRowHeight(mEntries.at(mCursor).data) / 2.0f -
(mSize.y() / 2.0f);
if (totalHeight > mSize.y) {
float target =
mSelectorBarOffset + getRowHeight(mEntries.at(mCursor).data) / 2.0f - (mSize.y / 2.0f);
// Clamp the camera to prevent a fraction of a row from being displayed.
mCameraOffset = 0.0f;
unsigned int i = 0;
while (mCameraOffset < target && i < mEntries.size()) {
mCameraOffset += getRowHeight(mEntries.at(i).data);
if (mCameraOffset > totalHeight - mSize.y())
if (mCameraOffset > totalHeight - mSize.y)
break;
i++;
}
if (mCameraOffset < 0)
mCameraOffset = 0;
if (mCameraOffset < 0.0f)
mCameraOffset = 0.0f;
}
else {
mCameraOffset = 0;
mCameraOffset = 0.0f;
}
}
void ComponentList::render(const Transform4x4f& parentTrans)
void ComponentList::render(const glm::mat4& parentTrans)
{
if (!size())
return;
Transform4x4f trans = parentTrans * getTransform();
glm::mat4 trans{parentTrans * getTransform()};
// Clip everything to be inside our bounds.
Vector3f dim(mSize.x(), mSize.y(), 0.0f);
dim = trans * dim - trans.translation();
glm::vec3 dim{mSize.x, mSize.y, 0.0f};
dim.x = (trans[0].x * dim.x + trans[3].x) - trans[3].x;
dim.y = (trans[1].y * dim.y + trans[3].y) - trans[3].y;
Renderer::pushClipRect(
Vector2i(static_cast<int>(std::round(trans.translation().x())),
static_cast<int>(std::round(trans.translation().y()))),
Vector2i(static_cast<int>(std::round(dim.x())), static_cast<int>(std::round(dim.y()))));
glm::ivec2{static_cast<int>(std::round(trans[3].x)),
static_cast<int>(std::round(trans[3].y))},
glm::ivec2{static_cast<int>(std::round(dim.x)), static_cast<int>(std::round(dim.y))});
// Scroll the camera.
trans.translate(Vector3f(0.0f, -std::round(mCameraOffset), 0.0f));
trans = glm::translate(trans, glm::vec3{0.0f, -std::round(mCameraOffset), 0.0f});
// Draw our entries.
std::vector<GuiComponent*> drawAfterCursor;
@ -243,19 +245,14 @@ void ComponentList::render(const Transform4x4f& parentTrans)
// Draw selector bar.
if (mFocused) {
// Inversion: src * (1 - dst) + dst * 0 = where src = 1
// Need a function that goes roughly 0x777777 -> 0xFFFFFF
// and 0xFFFFFF -> 0x777777
// (1 - dst) + 0x77
const float selectedRowHeight = getRowHeight(mEntries.at(mCursor).data);
if (opacity == 1) {
Renderer::drawRect(0.0f, mSelectorBarOffset, mSize.x(), selectedRowHeight, 0xFFFFFFFF,
Renderer::drawRect(0.0f, mSelectorBarOffset, mSize.x, selectedRowHeight, 0xFFFFFFFF,
0xFFFFFFFF, false, opacity, trans,
Renderer::Blend::ONE_MINUS_DST_COLOR, Renderer::Blend::ZERO);
Renderer::drawRect(0.0f, mSelectorBarOffset, mSize.x(), selectedRowHeight, 0x777777FF,
Renderer::drawRect(0.0f, mSelectorBarOffset, mSize.x, selectedRowHeight, 0x777777FF,
0x777777FF, false, opacity, trans, Renderer::Blend::ONE,
Renderer::Blend::ONE);
}
@ -271,12 +268,12 @@ void ComponentList::render(const Transform4x4f& parentTrans)
// Draw separators.
float y = 0;
for (unsigned int i = 0; i < mEntries.size(); i++) {
Renderer::drawRect(0.0f, y, mSize.x(), 1.0f * Renderer::getScreenHeightModifier(),
0xC6C7C6FF, 0xC6C7C6FF, false, opacity, trans);
Renderer::drawRect(0.0f, y, mSize.x, 1.0f * Renderer::getScreenHeightModifier(), 0xC6C7C6FF,
0xC6C7C6FF, false, opacity, trans);
y += getRowHeight(mEntries.at(i).data);
}
Renderer::drawRect(0.0f, y, mSize.x(), 1.0f * Renderer::getScreenHeightModifier(), 0xC6C7C6FF,
Renderer::drawRect(0.0f, y, mSize.x, 1.0f * Renderer::getScreenHeightModifier(), 0xC6C7C6FF,
0xC6C7C6FF, false, opacity, trans);
Renderer::popClipRect();
}
@ -286,8 +283,8 @@ float ComponentList::getRowHeight(const ComponentListRow& row) const
// Returns the highest component height found in the row.
float height = 0;
for (unsigned int i = 0; i < row.elements.size(); i++) {
if (row.elements.at(i).component->getSize().y() > height)
height = row.elements.at(i).component->getSize().y();
if (row.elements.at(i).component->getSize().y > height)
height = row.elements.at(i).component->getSize().y;
}
return height;
@ -316,27 +313,27 @@ void ComponentList::updateElementPosition(const ComponentListRow& row)
const auto comp = row.elements.at(i).component;
// Center vertically.
comp->setPosition(x, (rowHeight - comp->getSize().y()) / 2.0f + yOffset);
x += comp->getSize().x();
comp->setPosition(x, (rowHeight - comp->getSize().y) / 2.0f + yOffset);
x += comp->getSize().x;
}
}
void ComponentList::updateElementSize(const ComponentListRow& row)
{
float width = mSize.x() - mHorizontalPadding;
float width = mSize.x - mHorizontalPadding;
std::vector<std::shared_ptr<GuiComponent>> resizeVec;
for (auto it = row.elements.cbegin(); it != row.elements.cend(); it++) {
if (it->resize_width)
resizeVec.push_back(it->component);
else
width -= it->component->getSize().x();
width -= it->component->getSize().x;
}
// Redistribute the "unused" width equally among the components with resize_width set to true.
width = width / resizeVec.size();
for (auto it = resizeVec.cbegin(); it != resizeVec.cend(); it++)
(*it)->setSize(width, (*it)->getSize().y());
(*it)->setSize(width, (*it)->getSize().y);
}
void ComponentList::textInput(const std::string& text)

2
es-core/src/components/ComponentList.h
View file

@ -66,7 +66,7 @@ public:
void textInput(const std::string& text) override;
bool input(InputConfig* config, Input input) override;
void update(int deltaTime) override;
void render(const Transform4x4f& parentTrans) override;
void render(const glm::mat4& parentTrans) override;
virtual std::vector<HelpPrompt> getHelpPrompts() override;
void onSizeChanged() override;

7
es-core/src/components/DateTimeComponent.cpp
View file

@ -27,8 +27,8 @@ DateTimeComponent::DateTimeComponent(Window* window,
const std::shared_ptr<Font>& font,
unsigned int color,
Alignment align,
Vector3f pos,
Vector2f size,
glm::vec3 pos,
glm::vec2 size,
unsigned int bgcolor)
: TextComponent(window, text, font, color, align, pos, size, bgcolor)
, mDisplayRelative(false)
@ -101,8 +101,9 @@ std::string DateTimeComponent::getDisplayString() const
return Utils::Time::timeToString(mTime.getTime(), mFormat);
}
void DateTimeComponent::render(const Transform4x4f& parentTrans)
void DateTimeComponent::render(const glm::mat4& parentTrans)
{
// Render the component.
TextComponent::render(parentTrans);
}

6
es-core/src/components/DateTimeComponent.h
View file

@ -26,11 +26,11 @@ public:
const std::shared_ptr<Font>& font,
unsigned int color = 0x000000FF,
Alignment align = ALIGN_LEFT,
Vector3f pos = Vector3f::Zero(),
Vector2f size = Vector2f::Zero(),
glm::vec3 pos = {},
glm::vec2 size = {},
unsigned int bgcolor = 0x00000000);
void render(const Transform4x4f& parentTrans) override;
void render(const glm::mat4& parentTrans) override;
void setValue(const std::string& val) override;
std::string getValue() const override;

38
es-core/src/components/DateTimeEditComponent.cpp
View file

@ -154,9 +154,9 @@ void DateTimeEditComponent::update(int deltaTime)
GuiComponent::update(deltaTime);
}
void DateTimeEditComponent::render(const Transform4x4f& parentTrans)
void DateTimeEditComponent::render(const glm::mat4& parentTrans)
{
Transform4x4f trans = parentTrans * getTransform();
glm::mat4 trans{parentTrans * getTransform()};
if (mTextCache) {
std::shared_ptr<Font> font = getFont();
@ -164,28 +164,28 @@ void DateTimeEditComponent::render(const Transform4x4f& parentTrans)
if (mAlignRight) {
if (mTime != 0)
referenceSize = font->sizeText("ABCDEFG").x();
referenceSize = font->sizeText("ABCDEFG").x;
else
referenceSize = font->sizeText("ABCDEIJ").x();
referenceSize = font->sizeText("ABCDEIJ").x;
}
// Vertically center.
Vector3f off(0, (mSize.y() - mTextCache->metrics.size.y()) / 2.0f, 0.0f);
glm::vec3 off{0.0f, (mSize.y - mTextCache->metrics.size.y) / 2.0f, 0.0f};
if (mAlignRight)
off.x() += referenceSize - mTextCache->metrics.size.x();
trans.translate(off);
off.x += referenceSize - mTextCache->metrics.size.x;
trans = glm::translate(trans, off);
Renderer::setMatrix(trans);
if (Settings::getInstance()->getBool("DebugText")) {
Renderer::setMatrix(trans);
if (mTextCache->metrics.size.x() > 0) {
Renderer::drawRect(0.0f, 0.0f - off.y(), mSize.x() - off.x(), mSize.y(), 0x0000FF33,
if (mTextCache->metrics.size.x > 0.0f) {
Renderer::drawRect(0.0f, 0.0f - off.y, mSize.x - off.x, mSize.y, 0x0000FF33,
0x0000FF33);
}
Renderer::drawRect(0.0f, 0.0f, mTextCache->metrics.size.x(),
mTextCache->metrics.size.y(), 0x00000033, 0x00000033);
Renderer::drawRect(0.0f, 0.0f, mTextCache->metrics.size.x, mTextCache->metrics.size.y,
0x00000033, 0x00000033);
}
mTextCache->setColor((mColor & 0xFFFFFF00) | getOpacity());
@ -300,22 +300,22 @@ void DateTimeEditComponent::updateTextCache()
return;
// Year.
Vector2f start(0, 0);
Vector2f end = font->sizeText(dispString.substr(0, 4));
Vector2f diff = end - start;
mCursorBoxes.push_back(Vector4f(start[0], start[1], diff[0], diff[1]));
glm::vec2 start{};
glm::vec2 end{font->sizeText(dispString.substr(0, 4))};
glm::vec2 diff{end - start};
mCursorBoxes.push_back(glm::vec4{start[0], start[1], diff[0], diff[1]});
// Month.
start[0] = font->sizeText(dispString.substr(0, 5)).x();
start[0] = font->sizeText(dispString.substr(0, 5)).x;
end = font->sizeText(dispString.substr(0, 7));
diff = end - start;
mCursorBoxes.push_back(Vector4f(start[0], start[1], diff[0], diff[1]));
mCursorBoxes.push_back(glm::vec4{start[0], start[1], diff[0], diff[1]});
// Day.
start[0] = font->sizeText(dispString.substr(0, 8)).x();
start[0] = font->sizeText(dispString.substr(0, 8)).x;
end = font->sizeText(dispString.substr(0, 10));
diff = end - start;
mCursorBoxes.push_back(Vector4f(start[0], start[1], diff[0], diff[1]));
mCursorBoxes.push_back(glm::vec4{start[0], start[1], diff[0], diff[1]});
// The logic for handling time for 'mode = DISP_DATE_TIME' is missing, but
// nobody will use it anyway so it's not worthwhile implementing.

4
es-core/src/components/DateTimeEditComponent.h
View file

@ -34,7 +34,7 @@ public:
bool input(InputConfig* config, Input input) override;
void update(int deltaTime) override;
unsigned int getColor() const override { return mColor; }
void render(const Transform4x4f& parentTrans) override;
void render(const glm::mat4& parentTrans) override;
void onSizeChanged() override;
// Set how the point in time will be displayed:
@ -82,7 +82,7 @@ private:
int mRelativeUpdateAccumulator;
std::unique_ptr<TextCache> mTextCache;
std::vector<Vector4f> mCursorBoxes;
std::vector<glm::vec4> mCursorBoxes;
unsigned int mColor;
Utils::Time::DateTime mOriginalValue;

47
es-core/src/components/GridTileComponent.cpp
View file

@ -17,12 +17,12 @@ GridTileComponent::GridTileComponent(Window* window)
, mBackground(window, ":/graphics/frame.png")
{
mDefaultProperties.mSize = getDefaultTileSize();
mDefaultProperties.mPadding = Vector2f(16.0f * Renderer::getScreenWidthModifier(),
16.0f * Renderer::getScreenHeightModifier());
mDefaultProperties.mPadding = glm::vec2{16.0f * Renderer::getScreenWidthModifier(),
16.0f * Renderer::getScreenHeightModifier()};
mDefaultProperties.mImageColor = 0xAAAAAABB;
// Attempting to use frame.svg instead causes quite severe performance problems.
mDefaultProperties.mBackgroundImage = ":/graphics/frame.png";
mDefaultProperties.mBackgroundCornerSize = Vector2f(16.0f, 16.0f);
mDefaultProperties.mBackgroundCornerSize = glm::vec2{16.0f, 16.0f};
mDefaultProperties.mBackgroundCenterColor = 0xAAAAEEFF;
mDefaultProperties.mBackgroundEdgeColor = 0xAAAAEEFF;
@ -50,9 +50,9 @@ GridTileComponent::GridTileComponent(Window* window)
setVisible(true);
}
void GridTileComponent::render(const Transform4x4f& parentTrans)
void GridTileComponent::render(const glm::mat4& parentTrans)
{
Transform4x4f trans = getTransform() * parentTrans;
glm::mat4 trans{getTransform() * parentTrans};
if (mVisible)
renderChildren(trans);
@ -76,14 +76,14 @@ void GridTileComponent::update(int deltaTime)
void applyThemeToProperties(const ThemeData::ThemeElement* elem, GridTileProperties* properties)
{
Vector2f screen = Vector2f(static_cast<float>(Renderer::getScreenWidth()),
static_cast<float>(Renderer::getScreenHeight()));
glm::vec2 screen{static_cast<float>(Renderer::getScreenWidth()),
static_cast<float>(Renderer::getScreenHeight())};
if (elem->has("size"))
properties->mSize = elem->get<Vector2f>("size") * screen;
properties->mSize = elem->get<glm::vec2>("size") * screen;
if (elem->has("padding"))
properties->mPadding = elem->get<Vector2f>("padding");
properties->mPadding = elem->get<glm::vec2>("padding");
if (elem->has("imageColor"))
properties->mImageColor = elem->get<unsigned int>("imageColor");
@ -92,7 +92,7 @@ void applyThemeToProperties(const ThemeData::ThemeElement* elem, GridTilePropert
properties->mBackgroundImage = elem->get<std::string>("backgroundImage");
if (elem->has("backgroundCornerSize"))
properties->mBackgroundCornerSize = elem->get<Vector2f>("backgroundCornerSize");
properties->mBackgroundCornerSize = elem->get<glm::vec2>("backgroundCornerSize");
if (elem->has("backgroundColor")) {
properties->mBackgroundCenterColor = elem->get<unsigned int>("backgroundColor");
@ -111,9 +111,6 @@ void GridTileComponent::applyTheme(const std::shared_ptr<ThemeData>& theme,
const std::string& /*element*/,
unsigned int /*properties*/)
{
Vector2f screen = Vector2f(static_cast<float>(Renderer::getScreenWidth()),
static_cast<float>(Renderer::getScreenHeight()));
// Apply theme to the default gridtile.
const ThemeData::ThemeElement* elem = theme->getElement(view, "default", "gridtile");
if (elem)
@ -133,15 +130,15 @@ void GridTileComponent::applyTheme(const std::shared_ptr<ThemeData>& theme,
applyThemeToProperties(elem, &mSelectedProperties);
}
Vector2f GridTileComponent::getDefaultTileSize()
glm::vec2 GridTileComponent::getDefaultTileSize()
{
Vector2f screen = Vector2f(static_cast<float>(Renderer::getScreenWidth()),
static_cast<float>(Renderer::getScreenHeight()));
glm::vec2 screen{glm::vec2(static_cast<float>(Renderer::getScreenWidth()),
static_cast<float>(Renderer::getScreenHeight()))};
return screen * 0.22f;
}
Vector2f GridTileComponent::getSelectedTileSize() const
glm::vec2 GridTileComponent::getSelectedTileSize() const
{
// Return the tile size.
return mDefaultProperties.mSize * 1.2f;
@ -171,7 +168,7 @@ void GridTileComponent::setImage(const std::shared_ptr<TextureResource>& texture
void GridTileComponent::setSelected(bool selected,
bool allowAnimation,
Vector3f* pPosition,
glm::vec3* pPosition,
bool force)
{
if (mSelected == selected && !force)
@ -184,15 +181,15 @@ void GridTileComponent::setSelected(bool selected,
cancelAnimation(3);
this->setSelectedZoom(1);
mAnimPosition = Vector3f(0, 0, 0);
mAnimPosition = {};
resize();
}
else {
mAnimPosition = Vector3f(pPosition->x(), pPosition->y(), pPosition->z());
mAnimPosition = glm::vec3{pPosition->x, pPosition->y, pPosition->z};
auto func = [this](float t) {
t -= 1; // Cubic ease out.
t -= 1;
float pct = Math::lerp(0, 1, t * t * t + 1);
this->setSelectedZoom(pct);
};
@ -202,7 +199,7 @@ void GridTileComponent::setSelected(bool selected,
new LambdaAnimation(func, 250), 0,
[this] {
this->setSelectedZoom(1);
mAnimPosition = Vector3f(0, 0, 0);
mAnimPosition = {};
},
false, 3);
}
@ -218,7 +215,7 @@ void GridTileComponent::setSelected(bool selected,
this->setSelectedZoom(1);
auto func = [this](float t) {
t -= 1.0f; // Cubic ease out.
t -= 1.0f;
float pct = Math::lerp(0, 1, t * t * t + 1.0f);
this->setSelectedZoom(1.0f - pct);
};
@ -307,7 +304,7 @@ void GridTileComponent::calcCurrentProperties()
}
}
Vector3f GridTileComponent::getBackgroundPosition()
glm::vec3 GridTileComponent::getBackgroundPosition()
{
return mBackground.getPosition() + mPosition;
}
@ -320,7 +317,7 @@ std::shared_ptr<TextureResource> GridTileComponent::getTexture()
return nullptr;
};
void GridTileComponent::forceSize(Vector2f size, float selectedZoom)
void GridTileComponent::forceSize(glm::vec2 size, float selectedZoom)
{
mDefaultProperties.mSize = size;
mSelectedProperties.mSize = size * selectedZoom;

20
es-core/src/components/GridTileComponent.h
View file

@ -13,11 +13,11 @@
#include "NinePatchComponent.h"
struct GridTileProperties {
Vector2f mSize;
Vector2f mPadding;
glm::vec2 mSize;
glm::vec2 mPadding;
unsigned int mImageColor;
std::string mBackgroundImage;
Vector2f mBackgroundCornerSize;
glm::vec2 mBackgroundCornerSize;
unsigned int mBackgroundCenterColor;
unsigned int mBackgroundEdgeColor;
};
@ -27,7 +27,7 @@ class GridTileComponent : public GuiComponent
public:
GridTileComponent(Window* window);
void render(const Transform4x4f& parentTrans) override;
void render(const glm::mat4& parentTrans) override;
virtual void applyTheme(const std::shared_ptr<ThemeData>& theme,
const std::string& view,
const std::string& element,
@ -35,8 +35,8 @@ public:
// Made this a static function because the ImageGridComponent needs to know the default tile
// max size to calculate the grid dimension before it instantiates the GridTileComponents.
static Vector2f getDefaultTileSize();
Vector2f getSelectedTileSize() const;
static glm::vec2 getDefaultTileSize();
glm::vec2 getSelectedTileSize() const;
bool isSelected() const;
void reset() { setImage(""); }
@ -45,13 +45,13 @@ public:
void setImage(const std::shared_ptr<TextureResource>& texture);
void setSelected(bool selected,
bool allowAnimation = true,
Vector3f* pPosition = nullptr,
glm::vec3* pPosition = nullptr,
bool force = false);
void setVisible(bool visible);
void forceSize(Vector2f size, float selectedZoom);
void forceSize(glm::vec2 size, float selectedZoom);
Vector3f getBackgroundPosition();
glm::vec3 getBackgroundPosition();
virtual void update(int deltaTime) override;
@ -73,7 +73,7 @@ private:
bool mSelected;
bool mVisible;
Vector3f mAnimPosition;
glm::vec3 mAnimPosition;
};
#endif // ES_CORE_COMPONENTS_GRID_TILE_COMPONENT_H

22
es-core/src/components/HelpComponent.cpp
View file

@ -16,8 +16,8 @@
#include "resources/TextureResource.h"
#include "utils/StringUtil.h"
#define ICON_TEXT_SPACING 8 // Space between [icon] and [text] (px).
#define ENTRY_SPACING 16 // Space between [text] and next [icon] (px).
#define ICON_TEXT_SPACING 8.0f // Space between [icon] and [text] (px).
#define ENTRY_SPACING 16.0f // Space between [text] and next [icon] (px).
static std::map<std::string, std::string> sIconPathMap{};
@ -114,7 +114,7 @@ void HelpComponent::updateGrid()
std::shared_ptr<Font>& font = mStyle.font;
mGrid = std::make_shared<ComponentGrid>(mWindow,
Vector2i(static_cast<int>(mPrompts.size()) * 4, 1));
glm::ivec2{static_cast<int>(mPrompts.size()) * 4, 1});
// [icon] [spacer1] [text] [spacer2]
@ -135,7 +135,7 @@ void HelpComponent::updateGrid()
font, mStyle.textColor);
labels.push_back(lbl);
width += icon->getSize().x() + lbl->getSize().x() +
width += icon->getSize().x + lbl->getSize().x +
((ICON_TEXT_SPACING + ENTRY_SPACING) * Renderer::getScreenWidthModifier());
}
@ -143,16 +143,16 @@ void HelpComponent::updateGrid()
for (unsigned int i = 0; i < icons.size(); i++) {
const int col = i * 4;
mGrid->setColWidthPerc(col, icons.at(i)->getSize().x() / width);
mGrid->setColWidthPerc(col, icons.at(i)->getSize().x / width);
mGrid->setColWidthPerc(col + 1,
(ICON_TEXT_SPACING * Renderer::getScreenWidthModifier()) / width);
mGrid->setColWidthPerc(col + 2, labels.at(i)->getSize().x() / width);
mGrid->setColWidthPerc(col + 2, labels.at(i)->getSize().x / width);
mGrid->setEntry(icons.at(i), Vector2i(col, 0), false, false);
mGrid->setEntry(labels.at(i), Vector2i(col + 2, 0), false, false);
mGrid->setEntry(icons.at(i), glm::ivec2{col, 0}, false, false);
mGrid->setEntry(labels.at(i), glm::ivec2{col + 2, 0}, false, false);
}
mGrid->setPosition(Vector3f(mStyle.position.x(), mStyle.position.y(), 0.0f));
mGrid->setPosition({mStyle.position.x, mStyle.position.y, 0.0f});
mGrid->setOrigin(mStyle.origin);
}
@ -187,9 +187,9 @@ void HelpComponent::setOpacity(unsigned char opacity)
mGrid->getChild(i)->setOpacity(opacity);
}
void HelpComponent::render(const Transform4x4f& parentTrans)
void HelpComponent::render(const glm::mat4& parentTrans)
{
Transform4x4f trans = parentTrans * getTransform();
glm::mat4 trans{parentTrans * getTransform()};
if (mGrid)
mGrid->render(trans);

2
es-core/src/components/HelpComponent.h
View file

@ -26,7 +26,7 @@ public:
void clearPrompts();
void setPrompts(const std::vector<HelpPrompt>& prompts);
void render(const Transform4x4f& parent) override;
void render(const glm::mat4& parent) override;
void setOpacity(unsigned char opacity) override;
void setStyle(const HelpStyle& style);

2
es-core/src/components/IList.h
View file

@ -282,7 +282,7 @@ protected:
scroll(mScrollVelocity);
}
void listRenderTitleOverlay(const Transform4x4f& /*trans*/)
void listRenderTitleOverlay(const glm::mat4& /*trans*/)
{
if (!Settings::getInstance()->getBool("ListScrollOverlay"))
return;

171
es-core/src/components/ImageComponent.cpp
View file

@ -14,15 +14,15 @@
#include "resources/TextureResource.h"
#include "utils/CImgUtil.h"
Vector2i ImageComponent::getTextureSize() const
glm::ivec2 ImageComponent::getTextureSize() const
{
if (mTexture)
return mTexture->getSize();
else
return Vector2i::Zero();
return glm::ivec2{};
}
Vector2f ImageComponent::getSize() const
glm::vec2 ImageComponent::getSize() const
{
return GuiComponent::getSize() * (mBottomRightCrop - mTopLeftCrop);
}
@ -53,8 +53,8 @@ void ImageComponent::resize()
if (!mTexture)
return;
const Vector2f textureSize = mTexture->getSourceImageSize();
if (textureSize == Vector2f::Zero())
const glm::vec2 textureSize{mTexture->getSourceImageSize()};
if (textureSize == glm::vec2{})
return;
if (mTexture->isTiled()) {
@ -71,70 +71,69 @@ void ImageComponent::resize()
if (mTargetIsMax) {
mSize = textureSize;
Vector2f resizeScale((mTargetSize.x() / mSize.x()), (mTargetSize.y() / mSize.y()));
glm::vec2 resizeScale{(mTargetSize.x / mSize.x), (mTargetSize.y / mSize.y)};
if (resizeScale.x() < resizeScale.y()) {
// This will be mTargetSize.x(). We can't exceed it, nor be lower than it.
mSize[0] *= resizeScale.x();
if (resizeScale.x < resizeScale.y) {
// This will be mTargetSize.x. We can't exceed it, nor be lower than it.
mSize.x *= resizeScale.x;
// We need to make sure we're not creating an image larger than max size.
mSize[1] = std::min(floorf(mSize[1] *= resizeScale.x()), mTargetSize.y());
mSize.y = std::min(floorf(mSize.y *= resizeScale.x), mTargetSize.y);
}
else {
// This will be mTargetSize.y(). We can't exceed it.
mSize[1] = floorf(mSize[1] * resizeScale.y());
mSize.y = floorf(mSize.y * resizeScale.y);
// For SVG rasterization, always calculate width from rounded height (see comment
// above). We need to make sure we're not creating an image larger than max size.
mSize[0] =
std::min((mSize[1] / textureSize.y()) * textureSize.x(), mTargetSize.x());
mSize.x = std::min((mSize.y / textureSize.y) * textureSize.x, mTargetSize.x);
}
}
else if (mTargetIsMin) {
mSize = textureSize;
Vector2f resizeScale((mTargetSize.x() / mSize.x()), (mTargetSize.y() / mSize.y()));
glm::vec2 resizeScale{(mTargetSize.x / mSize.x), (mTargetSize.y / mSize.y)};
if (resizeScale.x() > resizeScale.y()) {
mSize[0] *= resizeScale.x();
mSize[1] *= resizeScale.x();
if (resizeScale.x > resizeScale.y) {
mSize.x *= resizeScale.x;
mSize.y *= resizeScale.x;
float cropPercent = (mSize.y() - mTargetSize.y()) / (mSize.y() * 2);
crop(0, cropPercent, 0, cropPercent);
float cropPercent = (mSize.y - mTargetSize.y) / (mSize.y * 2.0f);
crop(0.0f, cropPercent, 0.0f, cropPercent);
}
else {
mSize[0] *= resizeScale.y();
mSize[1] *= resizeScale.y();
mSize.x *= resizeScale.y;
mSize.y *= resizeScale.y;
float cropPercent = (mSize.x() - mTargetSize.x()) / (mSize.x() * 2);
crop(cropPercent, 0, cropPercent, 0);
float cropPercent = (mSize.x - mTargetSize.x) / (mSize.x * 2.0f);
crop(cropPercent, 0.0f, cropPercent, 0.0f);
}
// For SVG rasterization, always calculate width from rounded height (see comment
// above). We need to make sure we're not creating an image smaller than min size.
mSize[1] = std::max(floorf(mSize[1]), mTargetSize.y());
mSize[0] = std::max((mSize[1] / textureSize.y()) * textureSize.x(), mTargetSize.x());
mSize.y = std::max(floorf(mSize.y), mTargetSize.y);
mSize.x = std::max((mSize.y / textureSize.y) * textureSize.x, mTargetSize.x);
}
else {
// If both components are set, we just stretch.
// If no components are set, we don't resize at all.
mSize = mTargetSize == Vector2f::Zero() ? textureSize : mTargetSize;
mSize = mTargetSize == glm::vec2{} ? textureSize : mTargetSize;
// If only one component is set, we resize in a way that maintains aspect ratio.
// For SVG rasterization, we always calculate width from rounded height (see
// comment above).
if (!mTargetSize.x() && mTargetSize.y()) {
mSize[1] = floorf(mTargetSize.y());
mSize[0] = (mSize.y() / textureSize.y()) * textureSize.x();
if (!mTargetSize.x && mTargetSize.y) {
mSize.y = floorf(mTargetSize.y);
mSize.x = (mSize.y / textureSize.y) * textureSize.x;
}
else if (mTargetSize.x() && !mTargetSize.y()) {
mSize[1] = floorf((mTargetSize.x() / textureSize.x()) * textureSize.y());
mSize[0] = (mSize.y() / textureSize.y()) * textureSize.x();
else if (mTargetSize.x && !mTargetSize.y) {
mSize.y = floorf((mTargetSize.x / textureSize.x) * textureSize.y);
mSize.x = (mSize.y / textureSize.y) * textureSize.x;
}
}
}
mSize[0] = floorf(mSize.x());
mSize[1] = floorf(mSize.y());
mSize.x = floorf(mSize.x);
mSize.y = floorf(mSize.y);
// mSize.y() should already be rounded.
mTexture->rasterizeAt(static_cast<size_t>(mSize.x()), static_cast<size_t>(mSize.y()));
mTexture->rasterizeAt(static_cast<size_t>(mSize.x), static_cast<size_t>(mSize.y));
onSizeChanged();
}
@ -178,7 +177,7 @@ void ImageComponent::setImage(const std::shared_ptr<TextureResource>& texture)
void ImageComponent::setResize(float width, float height)
{
mTargetSize = Vector2f(width, height);
mTargetSize = glm::vec2{width, height};
mTargetIsMax = false;
mTargetIsMin = false;
resize();
@ -186,7 +185,7 @@ void ImageComponent::setResize(float width, float height)
void ImageComponent::setMaxSize(float width, float height)
{
mTargetSize = Vector2f(width, height);
mTargetSize = glm::vec2{width, height};
mTargetIsMax = true;
mTargetIsMin = false;
resize();
@ -194,7 +193,7 @@ void ImageComponent::setMaxSize(float width, float height)
void ImageComponent::setMinSize(float width, float height)
{
mTargetSize = Vector2f(width, height);
mTargetSize = glm::vec2{width, height};
mTargetIsMax = false;
mTargetIsMin = true;
resize();
@ -203,25 +202,25 @@ void ImageComponent::setMinSize(float width, float height)
void ImageComponent::cropLeft(float percent)
{
assert(percent >= 0.0f && percent <= 1.0f);
mTopLeftCrop.x() = percent;
mTopLeftCrop.x = percent;
}
void ImageComponent::cropTop(float percent)
{
assert(percent >= 0.0f && percent <= 1.0f);
mTopLeftCrop.y() = percent;
mTopLeftCrop.y = percent;
}
void ImageComponent::cropRight(float percent)
{
assert(percent >= 0.0f && percent <= 1.0f);
mBottomRightCrop.x() = 1.0f - percent;
mBottomRightCrop.x = 1.0f - percent;
}
void ImageComponent::cropBot(float percent)
{
assert(percent >= 0.0f && percent <= 1.0f);
mBottomRightCrop.y() = 1.0f - percent;
mBottomRightCrop.y = 1.0f - percent;
}
void ImageComponent::crop(float left, float top, float right, float bot)
@ -235,12 +234,12 @@ void ImageComponent::crop(float left, float top, float right, float bot)
void ImageComponent::uncrop()
{
// Remove any applied crop.
crop(0, 0, 0, 0);
crop(0.0f, 0.0f, 0.0f, 0.0f);
}
void ImageComponent::cropTransparentPadding(float maxSizeX, float maxSizeY)
{
if (mSize == 0)
if (mSize == glm::vec2{})
return;
std::vector<unsigned char> imageRGBA = mTexture.get()->getRawRGBAData();
@ -248,10 +247,10 @@ void ImageComponent::cropTransparentPadding(float maxSizeX, float maxSizeY)
if (imageRGBA.size() == 0)
return;
Vector2i imageSize = mTexture.get()->getSize();
cimg_library::CImg<unsigned char> imageCImg(imageSize.x(), imageSize.y(), 1, 4, 0);
glm::ivec2 imageSize{mTexture.get()->getSize()};
cimg_library::CImg<unsigned char> imageCImg(imageSize.x, imageSize.y, 1, 4, 0);
int paddingCoords[4] = {};
int paddingCoords[4]{};
// We need to convert our RGBA data to the CImg internal format as CImg does not interleave
// the pixels (as in RGBARGBARGBA).
@ -260,36 +259,36 @@ void ImageComponent::cropTransparentPadding(float maxSizeX, float maxSizeY)
// This will give us the coordinates for the fully transparent areas.
Utils::CImg::getTransparentPaddingCoords(imageCImg, paddingCoords);
Vector2f originalSize = mSize;
glm::vec2 originalSize{mSize};
float cropLeft = static_cast<float>(paddingCoords[0]) / static_cast<float>(imageSize.x());
float cropTop = static_cast<float>(paddingCoords[1]) / static_cast<float>(imageSize.y());
float cropRight = static_cast<float>(paddingCoords[2]) / static_cast<float>(imageSize.x());
float cropBottom = static_cast<float>(paddingCoords[3]) / static_cast<float>(imageSize.y());
float cropLeft{static_cast<float>(paddingCoords[0]) / static_cast<float>(imageSize.x)};
float cropTop{static_cast<float>(paddingCoords[1]) / static_cast<float>(imageSize.y)};
float cropRight{static_cast<float>(paddingCoords[2]) / static_cast<float>(imageSize.x)};
float cropBottom{static_cast<float>(paddingCoords[3]) / static_cast<float>(imageSize.y)};
crop(cropLeft, cropTop, cropRight, cropBottom);
// Cropping the image obviously leads to a reduction in size, so we need to determine
// how much to scale up after cropping to keep within the max size restrictions that
// were passed as arguments.
mSize.x() -= mSize.x() * (cropLeft + cropRight);
mSize.y() -= mSize.y() * (cropTop + cropBottom);
mSize.x -= mSize.x * (cropLeft + cropRight);
mSize.y -= mSize.y * (cropTop + cropBottom);
float scaleFactor = originalSize.y() / mSize.y();
float scaleFactor = originalSize.y / mSize.y;
if (scaleFactor * mSize.x() < maxSizeX)
scaleFactor = maxSizeX / mSize.x();
if (scaleFactor * mSize.x < maxSizeX)
scaleFactor = maxSizeX / mSize.x;
if (scaleFactor * mSize.y() < maxSizeY)
scaleFactor = maxSizeY / mSize.y();
if (scaleFactor * mSize.y < maxSizeY)
scaleFactor = maxSizeY / mSize.y;
if (scaleFactor * mSize.x() > maxSizeX)
scaleFactor = maxSizeX / mSize.x();
if (scaleFactor * mSize.x > maxSizeX)
scaleFactor = maxSizeX / mSize.x;
if (scaleFactor * mSize.y() > maxSizeY)
scaleFactor = maxSizeY / mSize.y();
if (scaleFactor * mSize.y > maxSizeY)
scaleFactor = maxSizeY / mSize.y;
setResize(mSize.x() * scaleFactor, mSize.y() * scaleFactor);
setResize(mSize.x * scaleFactor, mSize.y * scaleFactor);
updateVertices();
}
@ -343,23 +342,23 @@ void ImageComponent::updateVertices()
// We go through this mess to make sure everything is properly rounded.
// If we just round vertices at the end, edge cases occur near sizes of 0.5.
const Vector2f topLeft = { 0, 0 };
const Vector2f bottomRight = mSize;
const float px = mTexture->isTiled() ? mSize.x() / getTextureSize().x() : 1.0f;
const float py = mTexture->isTiled() ? mSize.y() / getTextureSize().y() : 1.0f;
const glm::vec2 topLeft{};
const glm::vec2 bottomRight{mSize};
const float px{mTexture->isTiled() ? mSize.x / getTextureSize().x : 1.0f};
const float py{mTexture->isTiled() ? mSize.y / getTextureSize().y : 1.0f};
// clang-format off
mVertices[0] = { { topLeft.x(), topLeft.y() }, { mTopLeftCrop.x(), py - mTopLeftCrop.y() }, 0 };
mVertices[1] = { { topLeft.x(), bottomRight.y() }, { mTopLeftCrop.x(), 1.0f - mBottomRightCrop.y() }, 0 };
mVertices[2] = { { bottomRight.x(), topLeft.y() }, { mBottomRightCrop.x() * px, py - mTopLeftCrop.y() }, 0 };
mVertices[3] = { { bottomRight.x(), bottomRight.y() }, { mBottomRightCrop.x() * px, 1.0f - mBottomRightCrop.y() }, 0 };
mVertices[0] = {{topLeft.x, topLeft.y }, {mTopLeftCrop.x, py - mTopLeftCrop.y }, 0};
mVertices[1] = {{topLeft.x, bottomRight.y}, {mTopLeftCrop.x, 1.0f - mBottomRightCrop.y}, 0};
mVertices[2] = {{bottomRight.x, topLeft.y }, {mBottomRightCrop.x * px, py - mTopLeftCrop.y }, 0};
mVertices[3] = {{bottomRight.x, bottomRight.y}, {mBottomRightCrop.x * px, 1.0f - mBottomRightCrop.y}, 0};
// clang-format on
updateColors();
// Round vertices.
for (int i = 0; i < 4; i++)
mVertices[i].pos.round();
mVertices[i].pos = glm::round(mVertices[i].pos);
if (mFlipX) {
for (int i = 0; i < 4; i++)
@ -387,23 +386,23 @@ void ImageComponent::updateColors()
mVertices[3].col = colorEnd;
}
void ImageComponent::render(const Transform4x4f& parentTrans)
void ImageComponent::render(const glm::mat4& parentTrans)
{
if (!isVisible())
return;
Transform4x4f trans = parentTrans * getTransform();
glm::mat4 trans{parentTrans * getTransform()};
Renderer::setMatrix(trans);
if (mTexture && mOpacity > 0) {
if (Settings::getInstance()->getBool("DebugImage")) {
Vector2f targetSizePos = (mTargetSize - mSize) * mOrigin * -1;
Renderer::drawRect(targetSizePos.x(), targetSizePos.y(), mTargetSize.x(),
mTargetSize.y(), 0xFF000033, 0xFF000033);
Renderer::drawRect(0.0f, 0.0f, mSize.x(), mSize.y(), 0xFF000033, 0xFF000033);
glm::vec2 targetSizePos{(mTargetSize - mSize) * mOrigin * glm::vec2{-1.0f}};
Renderer::drawRect(targetSizePos.x, targetSizePos.y, mTargetSize.x, mTargetSize.y,
0xFF000033, 0xFF000033);
Renderer::drawRect(0.0f, 0.0f, mSize.x, mSize.y, 0xFF000033, 0xFF000033);
}
// An image with zero size would normally indicate a corrupt image file.
if (mTexture->isInitialized() && mTexture->getSize() != 0) {
if (mTexture->isInitialized() && mTexture->getSize() != glm::ivec2{}) {
// Actually draw the image.
// The bind() function returns false if the texture is not currently loaded. A blank
// texture is bound in this case but we want to handle a fade so it doesn't just
@ -483,17 +482,17 @@ void ImageComponent::applyTheme(const std::shared_ptr<ThemeData>& theme,
if (!elem)
return;
Vector2f scale = getParent() ? getParent()->getSize() :
Vector2f(static_cast<float>(Renderer::getScreenWidth()),
static_cast<float>(Renderer::getScreenHeight()));
glm::vec2 scale{getParent() ? getParent()->getSize() :
glm::vec2(static_cast<float>(Renderer::getScreenWidth()),
static_cast<float>(Renderer::getScreenHeight()))};
if (properties & ThemeFlags::SIZE) {
if (elem->has("size"))
setResize(elem->get<Vector2f>("size") * scale);
setResize(elem->get<glm::vec2>("size") * scale);
else if (elem->has("maxSize"))
setMaxSize(elem->get<Vector2f>("maxSize") * scale);
setMaxSize(elem->get<glm::vec2>("maxSize") * scale);
else if (elem->has("minSize"))
setMinSize(elem->get<Vector2f>("minSize") * scale);
setMinSize(elem->get<glm::vec2>("minSize") * scale);
}
if (elem->has("default"))

21
es-core/src/components/ImageComponent.h
View file

@ -10,7 +10,6 @@
#define ES_CORE_COMPONENTS_IMAGE_COMPONENT_H
#include "GuiComponent.h"
#include "math/Vector2i.h"
#include "renderers/Renderer.h"
class TextureResource;
@ -39,18 +38,18 @@ public:
// Can be set before or after an image is loaded.
// setMaxSize() and setResize() are mutually exclusive.
void setResize(float width, float height) override;
void setResize(const Vector2f& size) { setResize(size.x(), size.y()); }
void setResize(const glm::vec2& size) { setResize(size.x, size.y); }
// Resize the image to be as large as possible but fit within a box of this size.
// Can be set before or after an image is loaded.
// Never breaks the aspect ratio. setMaxSize() and setResize() are mutually exclusive.
void setMaxSize(float width, float height);
void setMaxSize(const Vector2f& size) { setMaxSize(size.x(), size.y()); }
void setMaxSize(const glm::vec2& size) { setMaxSize(size.x, size.y); }
void setMinSize(float width, float height);
void setMinSize(const Vector2f& size) { setMinSize(size.x(), size.y()); }
void setMinSize(const glm::vec2& size) { setMinSize(size.x, size.y); }
Vector2f getRotationSize() const override { return mRotateByTargetSize ? mTargetSize : mSize; }
glm::vec2 getRotationSize() const override { return mRotateByTargetSize ? mTargetSize : mSize; }
// Applied AFTER image positioning and sizing.
// cropTop(0.2) will crop 20% of the top of the image.
@ -83,14 +82,14 @@ public:
// Returns the size of the current texture, or (0, 0) if none is loaded.
// May be different than drawn size (use getSize() for that).
Vector2i getTextureSize() const;
glm::ivec2 getTextureSize() const;
Vector2f getSize() const override;
glm::vec2 getSize() const override;
bool hasImage() { return static_cast<bool>(mTexture); }
std::shared_ptr<TextureResource> getTexture() { return mTexture; }
void render(const Transform4x4f& parentTrans) override;
void render(const glm::mat4& parentTrans) override;
virtual void applyTheme(const std::shared_ptr<ThemeData>& theme,
const std::string& view,
@ -100,7 +99,7 @@ public:
virtual std::vector<HelpPrompt> getHelpPrompts() override;
private:
Vector2f mTargetSize;
glm::vec2 mTargetSize;
bool mFlipX, mFlipY, mTargetIsMax, mTargetIsMin;
@ -127,8 +126,8 @@ private:
bool mDynamic;
bool mRotateByTargetSize;
Vector2f mTopLeftCrop;
Vector2f mBottomRightCrop;
glm::vec2 mTopLeftCrop;
glm::vec2 mBottomRightCrop;
};
#endif // ES_CORE_COMPONENTS_IMAGE_COMPONENT_H

144
es-core/src/components/ImageGridComponent.h
View file

@ -61,7 +61,7 @@ public:
bool input(InputConfig* config, Input input) override;
void update(int deltaTime) override;
void render(const Transform4x4f& parentTrans) override;
void render(const glm::mat4& parentTrans) override;
virtual void applyTheme(const std::shared_ptr<ThemeData>& theme,
const std::string& view,
const std::string& element,
@ -98,13 +98,13 @@ private:
// Tiles.
bool mLastRowPartial;
Vector2f mAutoLayout;
glm::vec2 mAutoLayout;
float mAutoLayoutZoom;
Vector4f mPadding;
Vector2f mMargin;
Vector2f mTileSize;
Vector2i mGridDimension;
glm::vec4 mPadding;
glm::vec2 mMargin;
glm::vec2 mTileSize;
glm::ivec2 mGridDimension;
std::shared_ptr<ThemeData> mTheme;
std::vector<std::shared_ptr<GridTileComponent>> mTiles;
@ -126,14 +126,14 @@ template <typename T>
ImageGridComponent<T>::ImageGridComponent(Window* window)
: IList<ImageGridData, T>(window)
{
Vector2f screen = Vector2f(static_cast<float>(Renderer::getScreenWidth()),
static_cast<float>(Renderer::getScreenHeight()));
glm::vec2 screen{static_cast<float>(Renderer::getScreenWidth()),
static_cast<float>(Renderer::getScreenHeight())};
mCamera = 0.0;
mCameraDirection = 1.0;
mCamera = 0.0f;
mCameraDirection = 1.0f;
mAutoLayout = Vector2f::Zero();
mAutoLayoutZoom = 1.0;
mAutoLayout = glm::vec2{};
mAutoLayoutZoom = 1.0f;
mStartPosition = 0;
@ -144,7 +144,7 @@ ImageGridComponent<T>::ImageGridComponent(Window* window)
mSize = screen * 0.80f;
mMargin = screen * 0.07f;
mPadding = Vector4f::Zero();
mPadding = {};
mTileSize = GridTileComponent::getDefaultTileSize();
mAnimate = true;
@ -171,7 +171,7 @@ template <typename T> bool ImageGridComponent<T>::input(InputConfig* config, Inp
if (input.value != 0) {
int idx = isVertical() ? 0 : 1;
Vector2i dir = Vector2i::Zero();
glm::ivec2 dir{};
if (config->isMappedLike("up", input))
dir[1 ^ idx] = -1;
else if (config->isMappedLike("down", input))
@ -181,11 +181,11 @@ template <typename T> bool ImageGridComponent<T>::input(InputConfig* config, Inp
else if (config->isMappedLike("right", input))
dir[0 ^ idx] = 1;
if (dir != Vector2i::Zero()) {
if (dir != glm::ivec2{}) {
if (isVertical())
listInput(dir.x() + dir.y() * mGridDimension.x());
listInput(dir.x + dir.y * mGridDimension.x);
else
listInput(dir.x() + dir.y() * mGridDimension.y());
listInput(dir.x + dir.y * mGridDimension.y);
return true;
}
}
@ -208,17 +208,15 @@ template <typename T> void ImageGridComponent<T>::update(int deltaTime)
(*it)->update(deltaTime);
}
template <typename T> void ImageGridComponent<T>::render(const Transform4x4f& parentTrans)
template <typename T> void ImageGridComponent<T>::render(const glm::mat4& parentTrans)
{
Transform4x4f trans = getTransform() * parentTrans;
Transform4x4f tileTrans = trans;
glm::mat4 trans{getTransform() * parentTrans};
glm::mat4 tileTrans{trans};
float offsetX =
isVertical() ? 0.0f : mCamera * mCameraDirection * (mTileSize.x() + mMargin.x());
float offsetY =
isVertical() ? mCamera * mCameraDirection * (mTileSize.y() + mMargin.y()) : 0.0f;
float offsetX{isVertical() ? 0.0f : mCamera * mCameraDirection * (mTileSize.x + mMargin.x)};
float offsetY{isVertical() ? mCamera * mCameraDirection * (mTileSize.y + mMargin.y) : 0.0f};
tileTrans.translate(Vector3f(offsetX, offsetY, 0.0));
tileTrans = glm::translate(tileTrans, glm::vec3{offsetX, offsetY, 0.0f});
if (mEntriesDirty) {
updateTiles();
@ -226,13 +224,13 @@ template <typename T> void ImageGridComponent<T>::render(const Transform4x4f& pa
}
// Create a clipRect to hide tiles used to buffer texture loading.
float scaleX = trans.r0().x();
float scaleY = trans.r1().y();
float scaleX = trans[0].x;
float scaleY = trans[1].y;
Vector2i pos(static_cast<int>(std::round(trans.translation()[0])),
static_cast<int>(std::round(trans.translation()[1])));
Vector2i size(static_cast<int>(std::round(mSize.x() * scaleX)),
static_cast<int>(std::round(mSize.y() * scaleY)));
glm::ivec2 pos{static_cast<int>(std::round(trans[3].x)),
static_cast<int>(std::round(trans[3].y))};
glm::ivec2 size{static_cast<int>(std::round(mSize.x * scaleX)),
static_cast<int>(std::round(mSize.y * scaleY))};
Renderer::pushClipRect(pos, size);
@ -271,20 +269,20 @@ void ImageGridComponent<T>::applyTheme(const std::shared_ptr<ThemeData>& theme,
// Keep the theme pointer to apply it on the tiles later on.
mTheme = theme;
Vector2f screen = Vector2f(static_cast<float>(Renderer::getScreenWidth()),
static_cast<float>(Renderer::getScreenHeight()));
glm::vec2 screen{static_cast<float>(Renderer::getScreenWidth()),
static_cast<float>(Renderer::getScreenHeight())};
const ThemeData::ThemeElement* elem = theme->getElement(view, element, "imagegrid");
if (elem) {
if (elem->has("margin"))
mMargin = elem->get<Vector2f>("margin") * screen;
mMargin = elem->get<glm::vec2>("margin") * screen;
if (elem->has("padding"))
mPadding = elem->get<Vector4f>("padding") *
Vector4f(screen.x(), screen.y(), screen.x(), screen.y());
mPadding =
elem->get<glm::vec4>("padding") * glm::vec4{screen.x, screen.y, screen.x, screen.y};
if (elem->has("autoLayout"))
mAutoLayout = elem->get<Vector2f>("autoLayout");
mAutoLayout = elem->get<glm::vec2>("autoLayout");
if (elem->has("autoLayoutSelectedZoom"))
mAutoLayoutZoom = elem->get<float>("autoLayoutSelectedZoom");
@ -369,7 +367,7 @@ void ImageGridComponent<T>::applyTheme(const std::shared_ptr<ThemeData>& theme,
// grid dimension, and then (re)build the tiles.
elem = theme->getElement(view, "default", "gridtile");
mTileSize = elem && elem->has("size") ? elem->get<Vector2f>("size") * screen :
mTileSize = elem && elem->has("size") ? elem->get<glm::vec2>("size") * screen :
GridTileComponent::getDefaultTileSize();
// Apply size property which will trigger a call to onSizeChanged() which will build the tiles.
@ -401,8 +399,8 @@ template <typename T> void ImageGridComponent<T>::onCursorChanged(const CursorSt
int oldStart = mStartPosition;
int dimScrollable = (isVertical() ? mGridDimension.y() : mGridDimension.x()) - 2 * EXTRAITEMS;
int dimOpposite = isVertical() ? mGridDimension.x() : mGridDimension.y();
int dimScrollable = (isVertical() ? mGridDimension.y : mGridDimension.x) - 2 * EXTRAITEMS;
int dimOpposite = isVertical() ? mGridDimension.x : mGridDimension.y;
int centralCol = static_cast<int>((static_cast<float>(dimScrollable) - 0.5f) / 2.0f);
int maxCentralCol = dimScrollable / 2;
@ -449,7 +447,7 @@ template <typename T> void ImageGridComponent<T>::onCursorChanged(const CursorSt
}
}
Vector3f oldPos = Vector3f::Zero();
glm::vec3 oldPos{};
if (oldTile != nullptr && oldTile != newTile) {
oldPos = oldTile->getBackgroundPosition();
@ -457,7 +455,7 @@ template <typename T> void ImageGridComponent<T>::onCursorChanged(const CursorSt
}
if (newTile != nullptr)
newTile->setSelected(true, true, oldPos == Vector3f::Zero() ? nullptr : &oldPos, true);
newTile->setSelected(true, true, oldPos == glm::vec3{} ? nullptr : &oldPos, true);
}
int firstVisibleCol = mStartPosition / dimOpposite;
@ -506,7 +504,7 @@ template <typename T> void ImageGridComponent<T>::onCursorChanged(const CursorSt
if (!moveCamera)
return;
t -= 1.0f; // Cubic ease out.
t -= 1.0f;
float pct = Math::lerp(0, 1.0f, t * t * t + 1.0f);
t = startPos * (1.0f - pct) + endPos * pct;
mCamera = t;
@ -530,35 +528,33 @@ template <typename T> void ImageGridComponent<T>::buildTiles()
calcGridDimension();
if (mCenterSelection) {
int dimScrollable =
(isVertical() ? mGridDimension.y() : mGridDimension.x()) - 2 * EXTRAITEMS;
int dimScrollable = (isVertical() ? mGridDimension.y : mGridDimension.x) - 2 * EXTRAITEMS;
mStartPosition -= static_cast<int>(floorf(dimScrollable / 2.0f));
}
Vector2f tileDistance = mTileSize + mMargin;
glm::vec2 tileDistance{mTileSize + mMargin};
if (mAutoLayout.x() != 0.0f && mAutoLayout.y() != 0.0f) {
auto x =
(mSize.x() - (mMargin.x() * (mAutoLayout.x() - 1.0f)) - mPadding.x() - mPadding.z()) /
static_cast<int>(mAutoLayout.x());
auto y =
(mSize.y() - (mMargin.y() * (mAutoLayout.y() - 1.0f)) - mPadding.y() - mPadding.w()) /
static_cast<int>(mAutoLayout.y());
if (mAutoLayout.x != 0.0f && mAutoLayout.y != 0.0f) {
auto x = (mSize.x - (mMargin.x * (mAutoLayout.x - 1.0f)) - mPadding.x - mPadding.z) /
static_cast<int>(mAutoLayout.x);
auto y = (mSize.y - (mMargin.y * (mAutoLayout.y - 1.0f)) - mPadding.y - mPadding.w) /
static_cast<int>(mAutoLayout.y);
mTileSize = Vector2f(x, y);
mTileSize = glm::vec2{x, y};
tileDistance = mTileSize + mMargin;
}
bool vert = isVertical();
Vector2f startPosition = mTileSize / 2.0f;
startPosition += mPadding.v2();
glm::vec2 startPosition{mTileSize / 2.0f};
startPosition.x += mPadding.x;
startPosition.y += mPadding.y;
int X;
int Y;
// Layout tile size and position.
for (int y = 0; y < (vert ? mGridDimension.y() : mGridDimension.x()); y++) {
for (int x = 0; x < (vert ? mGridDimension.x() : mGridDimension.y()); x++) {
for (int y = 0; y < (vert ? mGridDimension.y : mGridDimension.x); y++) {
for (int x = 0; x < (vert ? mGridDimension.x : mGridDimension.y); x++) {
// Create tiles.
auto tile = std::make_shared<GridTileComponent>(mWindow);
@ -567,15 +563,15 @@ template <typename T> void ImageGridComponent<T>::buildTiles()
X = vert ? x : y - EXTRAITEMS;
Y = vert ? y - EXTRAITEMS : x;
tile->setPosition(X * tileDistance.x() + startPosition.x(),
Y * tileDistance.y() + startPosition.y());
tile->setPosition(X * tileDistance.x + startPosition.x,
Y * tileDistance.y + startPosition.y);
tile->setOrigin(0.5f, 0.5f);
tile->setImage("");
if (mTheme)
tile->applyTheme(mTheme, "grid", "gridtile", ThemeFlags::ALL);
if (mAutoLayout.x() != 0 && mAutoLayout.y() != 0)
if (mAutoLayout.x != 0 && mAutoLayout.y != 0.0f)
tile->forceSize(mTileSize, mAutoLayoutZoom);
mTiles.push_back(tile);
@ -617,7 +613,7 @@ void ImageGridComponent<T>::updateTiles(bool ascending,
int end = ascending ? static_cast<int>(mTiles.size()) : -1;
int img = mStartPosition + ti;
img -= EXTRAITEMS * (isVertical() ? mGridDimension.x() : mGridDimension.y());
img -= EXTRAITEMS * (isVertical() ? mGridDimension.x : mGridDimension.y);
// Update the tiles.
while (ti != end) {
@ -677,7 +673,7 @@ void ImageGridComponent<T>::updateTileAtPos(int tilePos,
if (idx < 0 || idx >= mTiles.size())
idx = 0;
Vector3f pos = mTiles.at(idx)->getBackgroundPosition();
glm::vec3 pos{mTiles.at(idx)->getBackgroundPosition()};
tile->setSelected(true, allowAnimation, &pos);
}
else {
@ -693,30 +689,30 @@ template <typename T> void ImageGridComponent<T>::calcGridDimension()
{
// grid_size = columns * tile_size + (columns - 1) * margin
// <=> columns = (grid_size + margin) / (tile_size + margin)
Vector2f gridDimension = (mSize + mMargin) / (mTileSize + mMargin);
glm::vec2 gridDimension{(mSize + mMargin) / (mTileSize + mMargin)};
if (mAutoLayout.x() != 0 && mAutoLayout.y() != 0)
if (mAutoLayout.x != 0.0f && mAutoLayout.y != 0.0f)
gridDimension = mAutoLayout;
mLastRowPartial = floorf(gridDimension.y()) != gridDimension.y();
mLastRowPartial = floorf(gridDimension.y) != gridDimension.y;
// Ceil y dim so we can display partial last row.
mGridDimension = Vector2i(static_cast<const int>(gridDimension.x()),
static_cast<const int>(ceilf(gridDimension.y())));
mGridDimension = glm::ivec2{static_cast<const int>(gridDimension.x),
static_cast<const int>(ceilf(gridDimension.y))};
// Grid dimension validation.
if (mGridDimension.x() < 1) {
if (mGridDimension.x < 1) {
LOG(LogError) << "Theme defined grid X dimension below 1";
}
if (mGridDimension.y() < 1) {
if (mGridDimension.y < 1) {
LOG(LogError) << "Theme defined grid Y dimension below 1";
}
// Add extra tiles to both sides.
if (isVertical())
mGridDimension.y() += 2 * EXTRAITEMS;
mGridDimension.y += 2 * EXTRAITEMS;
else
mGridDimension.x() += 2 * EXTRAITEMS;
mGridDimension.x += 2 * EXTRAITEMS;
}
template <typename T> bool ImageGridComponent<T>::isScrollLoop()
@ -724,8 +720,8 @@ template <typename T> bool ImageGridComponent<T>::isScrollLoop()
if (!mScrollLoop)
return false;
if (isVertical())
return (mGridDimension.x() * (mGridDimension.y() - 2 * EXTRAITEMS)) <= mEntries.size();
return (mGridDimension.y() * (mGridDimension.x() - 2 * EXTRAITEMS)) <= mEntries.size();
return (mGridDimension.x * (mGridDimension.y - 2 * EXTRAITEMS)) <= mEntries.size();
return (mGridDimension.y * (mGridDimension.x - 2 * EXTRAITEMS)) <= mEntries.size();
}
#endif // ES_CORE_COMPONENTS_IMAGE_GRID_COMPONENT_H

31
es-core/src/components/MenuComponent.cpp
View file

@ -21,7 +21,7 @@ MenuComponent::MenuComponent(Window* window,
const std::shared_ptr<Font>& titleFont)
: GuiComponent(window)
, mBackground(window)
, mGrid(window, Vector2i(1, 3))
, mGrid(window, glm::ivec2{1, 3})
, mNeedsSaving(false)
{
addChild(&mBackground);
@ -34,11 +34,11 @@ MenuComponent::MenuComponent(Window* window,
mTitle->setHorizontalAlignment(ALIGN_CENTER);
mTitle->setColor(0x555555FF);
setTitle(title, titleFont);
mGrid.setEntry(mTitle, Vector2i(0, 0), false);
mGrid.setEntry(mTitle, glm::ivec2{}, false);
// Set up list which will never change (externally, anyway).
mList = std::make_shared<ComponentList>(mWindow);
mGrid.setEntry(mList, Vector2i(0, 1), true);
mGrid.setEntry(mList, glm::ivec2{0, 1}, true);
updateGrid();
updateSize();
@ -74,7 +74,7 @@ void MenuComponent::setTitle(std::string title, const std::shared_ptr<Font>& fon
float MenuComponent::getButtonGridHeight() const
{
return (mButtonGrid ? mButtonGrid->getSize().y() :
return (mButtonGrid ? mButtonGrid->getSize().y :
Font::get(FONT_SIZE_MEDIUM)->getHeight() +
(BUTTON_GRID_VERT_PADDING * Renderer::getScreenHeightModifier()));
}
@ -106,11 +106,11 @@ void MenuComponent::updateSize()
void MenuComponent::onSizeChanged()
{
mBackground.fitTo(mSize, Vector3f::Zero(), Vector2f(-32.0f, -32.0f));
mBackground.fitTo(mSize, glm::vec3{}, glm::vec2{-32.0f, -32.0f});
// Update grid row/column sizes.
mGrid.setRowHeightPerc(0, TITLE_HEIGHT / mSize.y());
mGrid.setRowHeightPerc(2, getButtonGridHeight() / mSize.y());
mGrid.setRowHeightPerc(0, TITLE_HEIGHT / mSize.y);
mGrid.setRowHeightPerc(2, getButtonGridHeight() / mSize.y);
mGrid.setSize(mSize);
}
@ -134,7 +134,7 @@ void MenuComponent::updateGrid()
if (mButtons.size()) {
mButtonGrid = makeButtonGrid(mWindow, mButtons);
mGrid.setEntry(mButtonGrid, Vector2i(0, 2), true, false);
mGrid.setEntry(mButtonGrid, glm::ivec2{0, 2}, true, false);
}
}
@ -142,26 +142,27 @@ std::shared_ptr<ComponentGrid> makeButtonGrid(
Window* window, const std::vector<std::shared_ptr<ButtonComponent>>& buttons)
{
std::shared_ptr<ComponentGrid> buttonGrid =
std::make_shared<ComponentGrid>(window, Vector2i(static_cast<int>(buttons.size()), 2));
std::make_shared<ComponentGrid>(window, glm::ivec2{static_cast<int>(buttons.size()), 2});
// Initialize to padding.
float buttonGridWidth =
BUTTON_GRID_HORIZ_PADDING * Renderer::getScreenWidthModifier() * buttons.size();
for (int i = 0; i < static_cast<int>(buttons.size()); i++) {
buttonGrid->setEntry(buttons.at(i), Vector2i(i, 0), true, false);
buttonGridWidth += buttons.at(i)->getSize().x();
buttonGrid->setEntry(buttons.at(i), glm::ivec2{i, 0}, true, false);
buttonGridWidth += buttons.at(i)->getSize().x;
}
for (unsigned int i = 0; i < buttons.size(); i++)
buttonGrid->setColWidthPerc(
i, (buttons.at(i)->getSize().x() +
i, (buttons.at(i)->getSize().x +
BUTTON_GRID_HORIZ_PADDING * Renderer::getScreenWidthModifier()) /
buttonGridWidth);
buttonGrid->setSize(buttonGridWidth,
buttons.at(0)->getSize().y() +
(BUTTON_GRID_VERT_PADDING * Renderer::getScreenHeightModifier()) + 2);
buttons.at(0)->getSize().y +
(BUTTON_GRID_VERT_PADDING * Renderer::getScreenHeightModifier()) +
2.0f);
// Spacer row to deal with dropshadow to make buttons look centered.
buttonGrid->setRowHeightPerc(1, 2 / buttonGrid->getSize().y());
buttonGrid->setRowHeightPerc(1, 2.0f / buttonGrid->getSize().y);
return buttonGrid;
}

63
es-core/src/components/NinePatchComponent.cpp
View file

@ -61,52 +61,51 @@ void NinePatchComponent::buildVertices()
mTexture = TextureResource::get(mPath, false, false, true, scaleFactor);
if (mTexture->getSize() == Vector2i::Zero()) {
if (mTexture->getSize() == glm::ivec2{}) {
mVertices = nullptr;
LOG(LogWarning) << "NinePatchComponent has no texture";
return;
}
Vector2f texSize;
mVertices = new Renderer::Vertex[6 * 9];
texSize = Vector2f(static_cast<float>(mTexture->getSize().x()),
static_cast<float>(mTexture->getSize().y()));
glm::vec2 texSize{static_cast<float>(mTexture->getSize().x),
static_cast<float>(mTexture->getSize().y)};
// clang-format off
const float imgSizeX[3] = { mCornerSize.x(), mSize.x() - mCornerSize.x() * 2.0f, mCornerSize.x() };
const float imgSizeY[3] = { mCornerSize.y(), mSize.y() - mCornerSize.y() * 2.0f, mCornerSize.y() };
const float imgPosX[3] = { 0, imgSizeX[0], imgSizeX[0] + imgSizeX[1] };
const float imgPosY[3] = { 0, imgSizeY[0], imgSizeY[0] + imgSizeY[1] };
const float imgSizeX[3]{mCornerSize.x, mSize.x - mCornerSize.x * 2.0f, mCornerSize.x};
const float imgSizeY[3]{mCornerSize.y, mSize.y - mCornerSize.y * 2.0f, mCornerSize.y};
const float imgPosX[3]{0, imgSizeX[0], imgSizeX[0] + imgSizeX[1]};
const float imgPosY[3]{0, imgSizeY[0], imgSizeY[0] + imgSizeY[1]};
// The "1 +" in posY and "-" in sizeY is to deal with texture coordinates having a bottom
// left corner origin vs. verticies having a top left origin.
const float texSizeX[3] = { mCornerSize.x() / texSize.x(), (texSize.x() - mCornerSize.x() * 2.0f) / texSize.x(), mCornerSize.x() / texSize.x() };
const float texSizeY[3] = { -mCornerSize.y() / texSize.y(), -(texSize.y() - mCornerSize.y() * 2.0f) / texSize.y(), -mCornerSize.y() / texSize.y() };
const float texPosX[3] = { 0.0f, texSizeX[0], texSizeX[0] + texSizeX[1] };
const float texPosY[3] = { 1.0f, 1.0f + texSizeY[0], 1.0f + texSizeY[0] + texSizeY[1] };
const float texSizeX[3]{mCornerSize.x / texSize.x, (texSize.x - mCornerSize.x * 2.0f) / texSize.x, mCornerSize.x / texSize.x};
const float texSizeY[3]{-mCornerSize.y / texSize.y, -(texSize.y - mCornerSize.y * 2.0f) / texSize.y, -mCornerSize.y / texSize.y};
const float texPosX[3]{0.0f, texSizeX[0], texSizeX[0] + texSizeX[1]};
const float texPosY[3]{1.0f, 1.0f + texSizeY[0], 1.0f + texSizeY[0] + texSizeY[1]};
// clang-format on
int v = 0;
for (int slice = 0; slice < 9; slice++) {
const int sliceX = slice % 3;
const int sliceY = slice / 3;
const Vector2f imgPos = Vector2f(imgPosX[sliceX], imgPosY[sliceY]);
const Vector2f imgSize = Vector2f(imgSizeX[sliceX], imgSizeY[sliceY]);
const Vector2f texPos = Vector2f(texPosX[sliceX], texPosY[sliceY]);
const Vector2f texSize = Vector2f(texSizeX[sliceX], texSizeY[sliceY]);
const int sliceX{slice % 3};
const int sliceY{slice / 3};
const glm::vec2 imgPos{imgPosX[sliceX], imgPosY[sliceY]};
const glm::vec2 imgSize{imgSizeX[sliceX], imgSizeY[sliceY]};
const glm::vec2 texPos{texPosX[sliceX], texPosY[sliceY]};
const glm::vec2 texSize{texSizeX[sliceX], texSizeY[sliceY]};
// clang-format off
mVertices[v + 1] = { { imgPos.x() , imgPos.y() }, { texPos.x(), texPos.y() }, 0 };
mVertices[v + 2] = { { imgPos.x() , imgPos.y() + imgSize.y() }, { texPos.x(), texPos.y() + texSize.y() }, 0 };
mVertices[v + 3] = { { imgPos.x() + imgSize.x(), imgPos.y() }, { texPos.x() + texSize.x(), texPos.y() }, 0 };
mVertices[v + 4] = { { imgPos.x() + imgSize.x(), imgPos.y() + imgSize.y() }, { texPos.x() + texSize.x(), texPos.y() + texSize.y() }, 0 };
mVertices[v + 1] = {{imgPos.x , imgPos.y }, {texPos.x, texPos.y }, 0};
mVertices[v + 2] = {{imgPos.x , imgPos.y + imgSize.y}, {texPos.x, texPos.y + texSize.y}, 0};
mVertices[v + 3] = {{imgPos.x + imgSize.x, imgPos.y }, {texPos.x + texSize.x, texPos.y }, 0};
mVertices[v + 4] = {{imgPos.x + imgSize.x, imgPos.y + imgSize.y}, {texPos.x + texSize.x, texPos.y + texSize.y}, 0};
// clang-format on
// Round vertices.
for (int i = 1; i < 5; i++)
mVertices[v + i].pos.round();
mVertices[v + i].pos = glm::round(mVertices[v + i].pos);
// Make duplicates of first and last vertex so this can be rendered as a triangle strip.
mVertices[v + 0] = mVertices[v + 1];
@ -118,12 +117,12 @@ void NinePatchComponent::buildVertices()
updateColors();
}
void NinePatchComponent::render(const Transform4x4f& parentTrans)
void NinePatchComponent::render(const glm::mat4& parentTrans)
{
if (!isVisible())
return;
Transform4x4f trans = parentTrans * getTransform();
glm::mat4 trans{parentTrans * getTransform()};
if (mTexture && mVertices != nullptr) {
Renderer::setMatrix(trans);
@ -144,17 +143,15 @@ void NinePatchComponent::render(const Transform4x4f& parentTrans)
renderChildren(trans);
}
void NinePatchComponent::onSizeChanged() { buildVertices(); }
void NinePatchComponent::fitTo(Vector2f size, Vector3f position, Vector2f padding)
void NinePatchComponent::fitTo(glm::vec2 size, glm::vec3 position, glm::vec2 padding)
{
size += padding;
position[0] -= padding.x() / 2.0f;
position[1] -= padding.y() / 2.0f;
position[0] -= padding.x / 2.0f;
position[1] -= padding.y / 2.0f;
setSize(size + mCornerSize * 2.0f);
setPosition(position.x() + Math::lerp(-mCornerSize.x(), mCornerSize.x(), mOrigin.x()),
position.y() + Math::lerp(-mCornerSize.y(), mCornerSize.y(), mOrigin.y()));
setPosition(position.x + Math::lerp(-mCornerSize.x, mCornerSize.x, mOrigin.x),
position.y + Math::lerp(-mCornerSize.y, mCornerSize.y, mOrigin.y));
}
void NinePatchComponent::setImagePath(const std::string& path)

15
es-core/src/components/NinePatchComponent.h
View file

@ -35,13 +35,10 @@ public:
unsigned int centerColor = 0xFFFFFFFF);
virtual ~NinePatchComponent();
void render(const Transform4x4f& parentTrans) override;
void render(const glm::mat4& parentTrans) override;
void onSizeChanged() override;
void fitTo(Vector2f size,
Vector3f position = Vector3f::Zero(),
Vector2f padding = Vector2f::Zero());
void onSizeChanged() override { buildVertices(); }
void fitTo(glm::vec2 size, glm::vec3 position = {}, glm::vec2 padding = {});
void setImagePath(const std::string& path);
// Apply a color shift to the "edge" parts of the ninepatch.
@ -54,8 +51,8 @@ public:
const std::string& element,
unsigned int properties) override;
const Vector2f& getCornerSize() const { return mCornerSize; }
void setCornerSize(const Vector2f& size)
const glm::vec2& getCornerSize() const { return mCornerSize; }
void setCornerSize(const glm::vec2& size)
{
mCornerSize = size;
buildVertices();
@ -68,7 +65,7 @@ private:
Renderer::Vertex* mVertices;
std::string mPath;
Vector2f mCornerSize;
glm::vec2 mCornerSize;
unsigned int mEdgeColor;
unsigned int mCenterColor;
std::shared_ptr<TextureResource> mTexture;

33
es-core/src/components/OptionListComponent.h
View file

@ -58,7 +58,7 @@ public:
addChild(&mRightArrow);
}
setSize(mLeftArrow.getSize().x() + mRightArrow.getSize().x(), font->getHeight());
setSize(mLeftArrow.getSize().x + mRightArrow.getSize().x, font->getHeight());
}
// Handles positioning/resizing of text and arrows.
@ -67,19 +67,19 @@ public:
mLeftArrow.setResize(0, mText.getFont()->getLetterHeight());
mRightArrow.setResize(0, mText.getFont()->getLetterHeight());
if (mSize.x() < (mLeftArrow.getSize().x() + mRightArrow.getSize().x())) {
if (mSize.x < (mLeftArrow.getSize().x + mRightArrow.getSize().x)) {
LOG(LogWarning) << "OptionListComponent too narrow";
}
mText.setSize(mSize.x() - mLeftArrow.getSize().x() - mRightArrow.getSize().x(),
mText.setSize(mSize.x - mLeftArrow.getSize().x - mRightArrow.getSize().x,
mText.getFont()->getHeight());
// Position.
mLeftArrow.setPosition(0, (mSize.y() - mLeftArrow.getSize().y()) / 2);
mText.setPosition(mLeftArrow.getPosition().x() + mLeftArrow.getSize().x(),
(mSize.y() - mText.getSize().y()) / 2);
mRightArrow.setPosition(mText.getPosition().x() + mText.getSize().x(),
(mSize.y() - mRightArrow.getSize().y()) / 2);
mLeftArrow.setPosition(0.0f, (mSize.y - mLeftArrow.getSize().y) / 2.0f);
mText.setPosition(mLeftArrow.getPosition().x + mLeftArrow.getSize().x,
(mSize.y - mText.getSize().y) / 2.0f);
mRightArrow.setPosition(mText.getPosition().x + mText.getSize().x,
(mSize.y - mRightArrow.getSize().y) / 2.0f);
}
bool input(InputConfig* config, Input input) override
@ -232,10 +232,10 @@ private:
std::stringstream ss;
ss << getSelectedObjects().size() << " SELECTED";
mText.setText(ss.str());
mText.setSize(0, mText.getSize().y());
setSize(mText.getSize().x() + mRightArrow.getSize().x() +
24 * Renderer::getScreenWidthModifier(),
mText.getSize().y());
mText.setSize(0, mText.getSize().y);
setSize(mText.getSize().x + mRightArrow.getSize().x +
24.0f * Renderer::getScreenWidthModifier(),
mText.getSize().y);
if (mParent) // Hack since there's no "on child size changed" callback.
mParent->onSizeChanged();
}
@ -244,11 +244,10 @@ private:
for (auto it = mEntries.cbegin(); it != mEntries.cend(); it++) {
if (it->selected) {
mText.setText(Utils::String::toUpper(it->name));
mText.setSize(0, mText.getSize().y());
setSize(mText.getSize().x() + mLeftArrow.getSize().x() +
mRightArrow.getSize().x() +
mText.setSize(0.0f, mText.getSize().y);
setSize(mText.getSize().x + mLeftArrow.getSize().x + mRightArrow.getSize().x +
24.0f * Renderer::getScreenWidthModifier(),
mText.getSize().y());
mText.getSize().y);
if (mParent) // Hack since there's no "on child size changed" callback.
mParent->onSizeChanged();
break;
@ -356,7 +355,7 @@ private:
});
}
mMenu.setPosition((Renderer::getScreenWidth() - mMenu.getSize().x()) / 2.0f,
mMenu.setPosition((Renderer::getScreenWidth() - mMenu.getSize().x) / 2.0f,
Renderer::getScreenHeight() * 0.13f);
addChild(&mMenu);
}

26
es-core/src/components/RatingComponent.cpp
View file

@ -25,7 +25,7 @@ RatingComponent::RatingComponent(Window* window, bool colorizeChanges)
mFilledTexture = TextureResource::get(":/graphics/star_filled.svg", true);
mUnfilledTexture = TextureResource::get(":/graphics/star_unfilled.svg", true);
mValue = 0.5f;
mSize = Vector2f(64.0f * NUM_RATING_STARS, 64.0f);
mSize = glm::vec2{64.0f * NUM_RATING_STARS, 64.0f};
updateVertices();
updateColors();
}
@ -96,13 +96,13 @@ void RatingComponent::setColorShift(unsigned int color)
void RatingComponent::onSizeChanged()
{
if (mSize.y() == 0)
mSize[1] = mSize.x() / NUM_RATING_STARS;
else if (mSize.x() == 0)
mSize[0] = mSize.y() * NUM_RATING_STARS;
if (mSize.y == 0.0f)
mSize.y = mSize.x / NUM_RATING_STARS;
else if (mSize.x == 0.0f)
mSize.x = mSize.y * NUM_RATING_STARS;
if (mSize.y() > 0) {
size_t heightPx = static_cast<size_t>(std::round(mSize.y()));
if (mSize.y > 0.0f) {
size_t heightPx = static_cast<size_t>(std::round(mSize.y));
if (mFilledTexture)
mFilledTexture->rasterizeAt(heightPx, heightPx);
if (mUnfilledTexture)
@ -115,9 +115,9 @@ void RatingComponent::onSizeChanged()
void RatingComponent::updateVertices()
{
const float numStars = NUM_RATING_STARS;
const float h = getSize().y(); // Ss the same as a single star's width.
const float w = getSize().y() * mValue * numStars;
const float fw = getSize().y() * numStars;
const float h = getSize().y; // Ss the same as a single star's width.
const float w = getSize().y * mValue * numStars;
const float fw = getSize().y * numStars;
const unsigned int color = Renderer::convertRGBAToABGR(mColorShift);
// clang-format off
@ -141,18 +141,18 @@ void RatingComponent::updateColors()
mVertices[i].col = color;
}
void RatingComponent::render(const Transform4x4f& parentTrans)
void RatingComponent::render(const glm::mat4& parentTrans)
{
if (!isVisible() || mFilledTexture == nullptr || mUnfilledTexture == nullptr)
return;
Transform4x4f trans = parentTrans * getTransform();
glm::mat4 trans{parentTrans * getTransform()};
Renderer::setMatrix(trans);
if (mOpacity > 0) {
if (Settings::getInstance()->getBool("DebugImage")) {
Renderer::drawRect(0.0f, 0.0f, mSize.y() * NUM_RATING_STARS, mSize.y(), 0xFF000033,
Renderer::drawRect(0.0f, 0.0f, mSize.y * NUM_RATING_STARS, mSize.y, 0xFF000033,
0xFF000033);
}

4
es-core/src/components/RatingComponent.h
View file

@ -27,7 +27,7 @@ public:
void setValue(const std::string& value) override;
bool input(InputConfig* config, Input input) override;
void render(const Transform4x4f& parentTrans) override;
void render(const glm::mat4& parentTrans) override;
void onSizeChanged() override;
@ -48,8 +48,6 @@ public:
virtual std::vector<HelpPrompt> getHelpPrompts() override;
private:
Vector2f mTargetSize;
void updateVertices();
void updateColors();

71
es-core/src/components/ScrollableContainer.cpp
View file

@ -11,7 +11,6 @@
#include "Window.h"
#include "animations/LambdaAnimation.h"
#include "math/Vector2i.h"
#include "renderers/Renderer.h"
#include "resources/Font.h"
@ -45,7 +44,7 @@ ScrollableContainer::ScrollableContainer(Window* window)
void ScrollableContainer::setAutoScroll(bool autoScroll)
{
if (autoScroll) {
mScrollDir = Vector2f(0, 1);
mScrollDir = glm::vec2{0.0f, 1.0f};
mAutoScrollDelay = static_cast<int>(mAutoScrollDelayConstant);
mAutoScrollSpeed = mAutoScrollSpeedConstant;
mAutoScrollSpeed =
@ -53,7 +52,7 @@ void ScrollableContainer::setAutoScroll(bool autoScroll)
reset();
}
else {
mScrollDir = Vector2f(0, 0);
mScrollDir = glm::vec2{};
mAutoScrollDelay = 0;
mAutoScrollSpeed = 0;
mAutoScrollAccumulator = 0;
@ -71,7 +70,7 @@ void ScrollableContainer::setScrollParameters(float autoScrollDelayConstant,
void ScrollableContainer::reset()
{
mScrollPos = Vector2f(0, 0);
mScrollPos = glm::vec2{};
mAutoScrollResetAccumulator = 0;
mAutoScrollAccumulator = -mAutoScrollDelay + mAutoScrollSpeed;
mAtEnd = false;
@ -82,16 +81,16 @@ void ScrollableContainer::update(int deltaTime)
// Don't scroll if the media viewer or screensaver is active or if text scrolling is disabled;
if (mWindow->isMediaViewerActive() || mWindow->isScreensaverActive() ||
!mWindow->getAllowTextScrolling()) {
if (mScrollPos != 0 && !mWindow->isLaunchScreenDisplayed())
if (mScrollPos != glm::vec2{} && !mWindow->isLaunchScreenDisplayed())
reset();
return;
}
const Vector2f contentSize = getContentSize();
const glm::vec2 contentSize{getContentSize()};
int adjustedAutoScrollSpeed = mAutoScrollSpeed;
// Adjust the scrolling speed based on the width of the container.
float widthModifier = contentSize.x() / static_cast<float>(Renderer::getScreenWidth());
float widthModifier = contentSize.x / static_cast<float>(Renderer::getScreenWidth());
adjustedAutoScrollSpeed = static_cast<int>(adjustedAutoScrollSpeed * widthModifier);
// Also adjust the scrolling speed based on the size of the font.
@ -105,28 +104,28 @@ void ScrollableContainer::update(int deltaTime)
if (adjustedAutoScrollSpeed != 0) {
mAutoScrollAccumulator += deltaTime;
while (mAutoScrollAccumulator >= adjustedAutoScrollSpeed) {
if (contentSize.y() > mSize.y())
if (contentSize.y > mSize.y)
mScrollPos += mScrollDir;
mAutoScrollAccumulator -= adjustedAutoScrollSpeed;
}
}
// Clip scrolling within bounds.
if (mScrollPos.x() < 0)
mScrollPos[0] = 0;
if (mScrollPos.y() < 0)
mScrollPos[1] = 0;
if (mScrollPos.x < 0.0f)
mScrollPos.x = 0.0f;
if (mScrollPos.y < 0.0f)
mScrollPos.y = 0.0f;
if (mScrollPos.x() + getSize().x() > contentSize.x()) {
mScrollPos[0] = contentSize.x() - getSize().x();
if (mScrollPos.x + getSize().x > contentSize.x) {
mScrollPos.x = contentSize.x - getSize().x;
mAtEnd = true;
}
if (contentSize.y() < getSize().y()) {
mScrollPos[1] = 0;
if (contentSize.y < getSize().y) {
mScrollPos.y = 0.0f;
}
else if (mScrollPos.y() + getSize().y() > contentSize.y()) {
mScrollPos[1] = contentSize.y() - getSize().y();
else if (mScrollPos.y + getSize().y > contentSize.y) {
mScrollPos.y = contentSize.y - getSize().y;
mAtEnd = true;
}
@ -136,7 +135,7 @@ void ScrollableContainer::update(int deltaTime)
// Fade in the text as it resets to the start position.
auto func = [this](float t) {
this->setOpacity(static_cast<unsigned char>(Math::lerp(0.0f, 1.0f, t) * 255));
mScrollPos = Vector2f(0, 0);
mScrollPos = glm::vec2{};
mAutoScrollResetAccumulator = 0;
mAutoScrollAccumulator = -mAutoScrollDelay + mAutoScrollSpeed;
mAtEnd = false;
@ -148,39 +147,41 @@ void ScrollableContainer::update(int deltaTime)
GuiComponent::update(deltaTime);
}
void ScrollableContainer::render(const Transform4x4f& parentTrans)
void ScrollableContainer::render(const glm::mat4& parentTrans)
{
if (!isVisible())
return;
Transform4x4f trans = parentTrans * getTransform();
glm::mat4 trans{parentTrans * getTransform()};
Vector2i clipPos(static_cast<int>(trans.translation().x()),
static_cast<int>(trans.translation().y()));
glm::ivec2 clipPos{static_cast<int>(trans[3].x), static_cast<int>(trans[3].y)};
Vector3f dimScaled = trans * Vector3f(mSize.x(), mSize.y(), 0);
Vector2i clipDim(static_cast<int>((dimScaled.x()) - trans.translation().x()),
static_cast<int>((dimScaled.y()) - trans.translation().y()));
glm::vec3 dimScaled{};
dimScaled.x = std::fabs(trans[3].x + mSize.x);
dimScaled.y = std::fabs(trans[3].y + mSize.y);
glm::ivec2 clipDim{static_cast<int>(dimScaled.x - trans[3].x),
static_cast<int>(dimScaled.y - trans[3].y)};
Renderer::pushClipRect(clipPos, clipDim);
trans.translate(-Vector3f(mScrollPos.x(), mScrollPos.y(), 0));
trans = glm::translate(trans, -glm::vec3{mScrollPos.x, mScrollPos.y, 0.0f});
Renderer::setMatrix(trans);
GuiComponent::renderChildren(trans);
Renderer::popClipRect();
}
Vector2f ScrollableContainer::getContentSize()
glm::vec2 ScrollableContainer::getContentSize()
{
Vector2f max(0, 0);
glm::vec2 max{};
for (unsigned int i = 0; i < mChildren.size(); i++) {
Vector2f pos(mChildren.at(i)->getPosition()[0], mChildren.at(i)->getPosition()[1]);
Vector2f bottomRight = mChildren.at(i)->getSize() + pos;
if (bottomRight.x() > max.x())
max.x() = bottomRight.x();
if (bottomRight.y() > max.y())
max.y() = bottomRight.y();
glm::vec2 pos{mChildren.at(i)->getPosition().x, mChildren.at(i)->getPosition().y};
glm::vec2 bottomRight{mChildren.at(i)->getSize() + pos};
if (bottomRight.x > max.x)
max.x = bottomRight.x;
if (bottomRight.y > max.y)
max.y = bottomRight.y;
if (!mFontSize)
mFontSize = static_cast<float>(mChildren.at(i)->getFont()->getSize());
}

12
es-core/src/components/ScrollableContainer.h
View file

@ -24,8 +24,8 @@ class ScrollableContainer : public GuiComponent
public:
ScrollableContainer(Window* window);
Vector2f getScrollPos() const { return mScrollPos; }
void setScrollPos(const Vector2f& pos) { mScrollPos = pos; }
glm::vec2 getScrollPos() const { return mScrollPos; }
void setScrollPos(const glm::vec2& pos) { mScrollPos = pos; }
void setAutoScroll(bool autoScroll);
void setScrollParameters(float autoScrollDelayConstant,
@ -34,13 +34,13 @@ public:
void reset();
void update(int deltaTime) override;
void render(const Transform4x4f& parentTrans) override;
void render(const glm::mat4& parentTrans) override;
private:
Vector2f getContentSize();
glm::vec2 getContentSize();
Vector2f mScrollPos;
Vector2f mScrollDir;
glm::vec2 mScrollPos;
glm::vec2 mScrollDir;
float mFontSize;
float mSmallFontSize;

36
es-core/src/components/SliderComponent.cpp
View file

@ -74,23 +74,23 @@ void SliderComponent::update(int deltaTime)
GuiComponent::update(deltaTime);
}
void SliderComponent::render(const Transform4x4f& parentTrans)
void SliderComponent::render(const glm::mat4& parentTrans)
{
Transform4x4f trans = parentTrans * getTransform();
glm::mat4 trans{parentTrans * getTransform()};
Renderer::setMatrix(trans);
// Render suffix.
if (mValueCache)
mFont->renderTextCache(mValueCache.get());
float width =
mSize.x() - mKnob.getSize().x() -
(mValueCache ? mValueCache->metrics.size.x() + (4.0f * Renderer::getScreenWidthModifier()) :
0);
float width{mSize.x - mKnob.getSize().x -
(mValueCache ?
mValueCache->metrics.size.x + (4.0f * Renderer::getScreenWidthModifier()) :
0.0f)};
// Render line.
const float lineWidth = 2.0f * Renderer::getScreenHeightModifier();
Renderer::drawRect(mKnob.getSize().x() / 2.0f, mSize.y() / 2.0f - lineWidth / 2.0f, width,
const float lineWidth{2.0f * Renderer::getScreenHeightModifier()};
Renderer::drawRect(mKnob.getSize().x / 2.0f, mSize.y / 2.0f - lineWidth / 2.0f, width,
lineWidth, 0x777777FF, 0x777777FF);
// Render knob.
@ -115,7 +115,7 @@ float SliderComponent::getValue() { return mValue; }
void SliderComponent::onSizeChanged()
{
if (!mSuffix.empty())
mFont = Font::get(static_cast<int>(mSize.y()), FONT_PATH_LIGHT);
mFont = Font::get(static_cast<int>(mSize.y), FONT_PATH_LIGHT);
onValueChanged();
}
@ -139,21 +139,21 @@ void SliderComponent::onValueChanged()
ss << mSuffix;
const std::string max = ss.str();
Vector2f textSize = mFont->sizeText(max);
glm::vec2 textSize = mFont->sizeText(max);
mValueCache = std::shared_ptr<TextCache>(mFont->buildTextCache(
val, mSize.x() - textSize.x(), (mSize.y() - textSize.y()) / 2.0f, 0x777777FF));
mValueCache->metrics.size[0] = textSize.x(); // Fudge the width.
val, mSize.x - textSize.x, (mSize.y - textSize.y) / 2.0f, 0x777777FF));
mValueCache->metrics.size.x = textSize.x; // Fudge the width.
}
// Update knob position/size.
mKnob.setResize(0, mSize.y() * 0.7f);
mKnob.setResize(0, mSize.y * 0.7f);
float lineLength =
mSize.x() - mKnob.getSize().x() -
(mValueCache ? mValueCache->metrics.size.x() + (4.0f * Renderer::getScreenWidthModifier()) :
0);
mSize.x - mKnob.getSize().x -
(mValueCache ? mValueCache->metrics.size.x + (4.0f * Renderer::getScreenWidthModifier()) :
0.0f);
mKnob.setPosition(((mValue - mMin / 2.0f) / mMax) * lineLength + mKnob.getSize().x() / 2.0f,
mSize.y() / 2.0f);
mKnob.setPosition(((mValue - mMin / 2.0f) / mMax) * lineLength + mKnob.getSize().x / 2.0f,
mSize.y / 2.0f);
}
std::vector<HelpPrompt> SliderComponent::getHelpPrompts()

2
es-core/src/components/SliderComponent.h
View file

@ -29,7 +29,7 @@ public:
bool input(InputConfig* config, Input input) override;
void update(int deltaTime) override;
void render(const Transform4x4f& parentTrans) override;
void render(const glm::mat4& parentTrans) override;
void onSizeChanged() override;

4
es-core/src/components/SwitchComponent.cpp
View file

@ -42,9 +42,9 @@ bool SwitchComponent::input(InputConfig* config, Input input)
return false;
}
void SwitchComponent::render(const Transform4x4f& parentTrans)
void SwitchComponent::render(const glm::mat4& parentTrans)
{
Transform4x4f trans = parentTrans * getTransform();
glm::mat4 trans{parentTrans * getTransform()};
mImage.render(trans);
renderChildren(trans);
}

2
es-core/src/components/SwitchComponent.h
View file

@ -19,7 +19,7 @@ public:
SwitchComponent(Window* window, bool state = false);
bool input(InputConfig* config, Input input) override;
void render(const Transform4x4f& parentTrans) override;
void render(const glm::mat4& parentTrans) override;
void onSizeChanged() override { mImage.setSize(mSize); }
void setResize(float width, float height) override { mImage.setResize(width, height); }

66
es-core/src/components/TextComponent.cpp
View file

@ -33,8 +33,8 @@ TextComponent::TextComponent(Window* window,
const std::shared_ptr<Font>& font,
unsigned int color,
Alignment align,
Vector3f pos,
Vector2f size,
glm::vec3 pos,
glm::vec2 size,
unsigned int bgcolor,
float margin)
: GuiComponent(window)
@ -60,7 +60,7 @@ TextComponent::TextComponent(Window* window,
void TextComponent::onSizeChanged()
{
mAutoCalcExtent = Vector2i((getSize().x() == 0), (getSize().y() == 0));
mAutoCalcExtent = glm::ivec2{(getSize().x == 0), (getSize().y == 0)};
onTextChanged();
}
@ -115,66 +115,66 @@ void TextComponent::setUppercase(bool uppercase)
onTextChanged();
}
void TextComponent::render(const Transform4x4f& parentTrans)
void TextComponent::render(const glm::mat4& parentTrans)
{
if (!isVisible())
return;
Transform4x4f trans = parentTrans * getTransform();
glm::mat4 trans{parentTrans * getTransform()};
if (mRenderBackground) {
Renderer::setMatrix(trans);
Renderer::drawRect(0.0f, 0.0f, mSize.x(), mSize.y(), mBgColor, mBgColor);
Renderer::drawRect(0.0f, 0.0f, mSize.x, mSize.y, mBgColor, mBgColor);
}
if (mTextCache) {
const Vector2f& textSize = mTextCache->metrics.size;
float yOff = 0;
const glm::vec2& textSize{mTextCache->metrics.size};
float yOff = 0.0f;
switch (mVerticalAlignment) {
case ALIGN_TOP: {
yOff = 0;
yOff = 0.0f;
break;
}
case ALIGN_BOTTOM: {
yOff = (getSize().y() - textSize.y());
yOff = (getSize().y - textSize.y);
break;
}
case ALIGN_CENTER: {
yOff = (getSize().y() - textSize.y()) / 2.0f;
yOff = (getSize().y - textSize.y) / 2.0f;
break;
}
default: {
break;
}
}
Vector3f off(0, yOff, 0);
glm::vec3 off{0.0f, yOff, 0.0f};
if (Settings::getInstance()->getBool("DebugText")) {
// Draw the "textbox" area, what we are aligned within.
Renderer::setMatrix(trans);
Renderer::drawRect(0.0f, 0.0f, mSize.x(), mSize.y(), 0x0000FF33, 0x0000FF33);
Renderer::drawRect(0.0f, 0.0f, mSize.x, mSize.y, 0x0000FF33, 0x0000FF33);
}
trans.translate(off);
trans = glm::translate(trans, off);
Renderer::setMatrix(trans);
// Draw the text area, where the text actually is located.
if (Settings::getInstance()->getBool("DebugText")) {
switch (mHorizontalAlignment) {
case ALIGN_LEFT: {
Renderer::drawRect(0.0f, 0.0f, mTextCache->metrics.size.x(),
mTextCache->metrics.size.y(), 0x00000033, 0x00000033);
Renderer::drawRect(0.0f, 0.0f, mTextCache->metrics.size.x,
mTextCache->metrics.size.y, 0x00000033, 0x00000033);
break;
}
case ALIGN_CENTER: {
Renderer::drawRect((mSize.x() - mTextCache->metrics.size.x()) / 2.0f, 0.0f,
mTextCache->metrics.size.x(), mTextCache->metrics.size.y(),
Renderer::drawRect((mSize.x - mTextCache->metrics.size.x) / 2.0f, 0.0f,
mTextCache->metrics.size.x, mTextCache->metrics.size.y,
0x00000033, 0x00000033);
break;
}
case ALIGN_RIGHT: {
Renderer::drawRect(mSize.x() - mTextCache->metrics.size.x(), 0.0f,
mTextCache->metrics.size.x(), mTextCache->metrics.size.y(),
Renderer::drawRect(mSize.x - mTextCache->metrics.size.x, 0.0f,
mTextCache->metrics.size.x, mTextCache->metrics.size.y,
0x00000033, 0x00000033);
break;
}
@ -189,15 +189,15 @@ void TextComponent::render(const Transform4x4f& parentTrans)
void TextComponent::calculateExtent()
{
if (mAutoCalcExtent.x()) {
if (mAutoCalcExtent.x) {
mSize = mFont->sizeText(mUppercase ? Utils::String::toUpper(mText) : mText, mLineSpacing);
}
else {
if (mAutoCalcExtent.y())
mSize[1] = mFont
if (mAutoCalcExtent.y)
mSize.y = mFont
->sizeWrappedText(mUppercase ? Utils::String::toUpper(mText) : mText,
getSize().x(), mLineSpacing)
.y();
getSize().x, mLineSpacing)
.y;
}
}
@ -213,7 +213,7 @@ void TextComponent::onTextChanged()
std::string text = mUppercase ? Utils::String::toUpper(mText) : mText;
std::shared_ptr<Font> f = mFont;
const bool isMultiline = (mSize.y() == 0 || mSize.y() > f->getHeight() * 1.2f);
const bool isMultiline = (mSize.y == 0.0f || mSize.y > f->getHeight() * 1.2f);
bool addAbbrev = false;
if (!isMultiline) {
@ -223,15 +223,15 @@ void TextComponent::onTextChanged()
addAbbrev = newline != std::string::npos;
}
Vector2f size = f->sizeText(text);
if (!isMultiline && mSize.x() > 0.0f && text.size() && (size.x() > mSize.x() || addAbbrev)) {
glm::vec2 size{f->sizeText(text)};
if (!isMultiline && mSize.x > 0.0f && text.size() && (size.x > mSize.x || addAbbrev)) {
// Abbreviate text.
const std::string abbrev = "...";
Vector2f abbrevSize = f->sizeText(abbrev);
glm::vec2 abbrevSize{f->sizeText(abbrev)};
// mMargin adds a margin around the text if it's abbreviated.
float marginAdjustedSize = mSize.x() - (mSize.x() * mMargin);
float marginAdjustedSize = mSize.x - (mSize.x * mMargin);
while (text.size() && size.x() + abbrevSize.x() > marginAdjustedSize) {
while (text.size() && size.x + abbrevSize.x > marginAdjustedSize) {
size_t newSize = Utils::String::prevCursor(text, text.size());
text.erase(newSize, text.size() - newSize);
size = f->sizeText(text);
@ -240,12 +240,12 @@ void TextComponent::onTextChanged()
text.append(abbrev);
mTextCache = std::shared_ptr<TextCache>(
f->buildTextCache(text, Vector2f(0, 0), (mColor >> 8 << 8) | mOpacity, mSize.x(),
f->buildTextCache(text, glm::vec2{}, (mColor >> 8 << 8) | mOpacity, mSize.x,
mHorizontalAlignment, mLineSpacing, mNoTopMargin));
}
else {
mTextCache = std::shared_ptr<TextCache>(f->buildTextCache(
f->wrapText(text, mSize.x()), Vector2f(0, 0), (mColor >> 8 << 8) | mOpacity, mSize.x(),
f->wrapText(text, mSize.x), glm::vec2{}, (mColor >> 8 << 8) | mOpacity, mSize.x,
mHorizontalAlignment, mLineSpacing, mNoTopMargin));
}
}

8
es-core/src/components/TextComponent.h
View file

@ -30,8 +30,8 @@ public:
const std::shared_ptr<Font>& font,
unsigned int color = 0x000000FF,
Alignment align = ALIGN_LEFT,
Vector3f pos = Vector3f::Zero(),
Vector2f size = Vector2f::Zero(),
glm::vec3 pos = {},
glm::vec2 size = {},
unsigned int bgcolor = 0x00000000,
float margin = 0.0f);
@ -48,7 +48,7 @@ public:
void setBackgroundColor(unsigned int color);
void setRenderBackground(bool render) { mRenderBackground = render; }
void render(const Transform4x4f& parentTrans) override;
void render(const glm::mat4& parentTrans) override;
std::string getValue() const override { return mText; }
void setValue(const std::string& value) override { setText(value); }
@ -88,7 +88,7 @@ private:
bool mRenderBackground;
bool mUppercase;
Vector2i mAutoCalcExtent;
glm::ivec2 mAutoCalcExtent;
std::shared_ptr<TextCache> mTextCache;
Alignment mHorizontalAlignment;
Alignment mVerticalAlignment;

76
es-core/src/components/TextEditComponent.cpp
View file

@ -28,7 +28,7 @@ TextEditComponent::TextEditComponent(Window* window)
{
addChild(&mBox);
onFocusLost();
mResolutionAdjustment = -(34 * Renderer::getScreenWidthModifier() - 34);
mResolutionAdjustment = -(34.0f * Renderer::getScreenWidthModifier() - 34.0f);
setSize(4096, mFont->getHeight() + (TEXT_PADDING_VERT * Renderer::getScreenHeightModifier()));
}
@ -46,9 +46,9 @@ void TextEditComponent::onFocusLost()
void TextEditComponent::onSizeChanged()
{
mBox.fitTo(mSize, Vector3f::Zero(),
Vector2f(-34 + mResolutionAdjustment,
-32 - (TEXT_PADDING_VERT * Renderer::getScreenHeightModifier())));
mBox.fitTo(mSize, glm::vec3{},
glm::vec2{-34.0f + mResolutionAdjustment,
-32.0f - (TEXT_PADDING_VERT * Renderer::getScreenHeightModifier())});
onTextChanged(); // Wrap point probably changed.
}
@ -239,10 +239,9 @@ void TextEditComponent::setCursor(size_t pos)
void TextEditComponent::onTextChanged()
{
std::string wrappedText =
(isMultiline() ? mFont->wrapText(mText, getTextAreaSize().x()) : mText);
std::string wrappedText = (isMultiline() ? mFont->wrapText(mText, getTextAreaSize().x) : mText);
mTextCache = std::unique_ptr<TextCache>(
mFont->buildTextCache(wrappedText, 0, 0, 0x77777700 | getOpacity()));
mFont->buildTextCache(wrappedText, 0.0f, 0.0f, 0x77777700 | getOpacity()));
if (mCursor > static_cast<int>(mText.length()))
mCursor = static_cast<unsigned int>(mText.length());
@ -251,44 +250,45 @@ void TextEditComponent::onTextChanged()
void TextEditComponent::onCursorChanged()
{
if (isMultiline()) {
Vector2f textSize =
mFont->getWrappedTextCursorOffset(mText, getTextAreaSize().x(), mCursor);
glm::vec2 textSize{mFont->getWrappedTextCursorOffset(mText, getTextAreaSize().x, mCursor)};
// Need to scroll down?
if (mScrollOffset.y() + getTextAreaSize().y() < textSize.y() + mFont->getHeight())
mScrollOffset[1] = textSize.y() - getTextAreaSize().y() + mFont->getHeight();
if (mScrollOffset.y + getTextAreaSize().y < textSize.y + mFont->getHeight())
mScrollOffset.y = textSize.y - getTextAreaSize().y + mFont->getHeight();
// Need to scroll up?
else if (mScrollOffset.y() > textSize.y())
mScrollOffset[1] = textSize.y();
else if (mScrollOffset.y > textSize.y)
mScrollOffset.y = textSize.y;
}
else {
Vector2f cursorPos = mFont->sizeText(mText.substr(0, mCursor));
glm::vec2 cursorPos{mFont->sizeText(mText.substr(0, mCursor))};
if (mScrollOffset.x() + getTextAreaSize().x() < cursorPos.x())
mScrollOffset[0] = cursorPos.x() - getTextAreaSize().x();
else if (mScrollOffset.x() > cursorPos.x())
mScrollOffset[0] = cursorPos.x();
if (mScrollOffset.x + getTextAreaSize().x < cursorPos.x)
mScrollOffset.x = cursorPos.x - getTextAreaSize().x;
else if (mScrollOffset.x > cursorPos.x)
mScrollOffset.x = cursorPos.x;
}
}
void TextEditComponent::render(const Transform4x4f& parentTrans)
void TextEditComponent::render(const glm::mat4& parentTrans)
{
Transform4x4f trans = getTransform() * parentTrans;
glm::mat4 trans{getTransform() * parentTrans};
renderChildren(trans);
// Text + cursor rendering.
// Offset into our "text area" (padding).
trans.translation() += Vector3f(getTextAreaPos().x(), getTextAreaPos().y(), 0);
trans = glm::translate(trans, glm::vec3{getTextAreaPos().x, getTextAreaPos().y, 0.0f});
Vector2i clipPos(static_cast<int>(trans.translation().x()),
static_cast<int>(trans.translation().y()));
glm::ivec2 clipPos{static_cast<int>(trans[3].x), static_cast<int>(trans[3].y)};
// Use "text area" size for clipping.
Vector3f dimScaled = trans * Vector3f(getTextAreaSize().x(), getTextAreaSize().y(), 0);
Vector2i clipDim(static_cast<int>((dimScaled.x()) - trans.translation().x()),
static_cast<int>((dimScaled.y()) - trans.translation().y()));
glm::vec3 dimScaled{};
dimScaled.x = std::fabs(trans[3].x + getTextAreaSize().x);
dimScaled.y = std::fabs(trans[3].y + getTextAreaSize().y);
glm::ivec2 clipDim{static_cast<int>(dimScaled.x - trans[3].x),
static_cast<int>(dimScaled.y - trans[3].y)};
Renderer::pushClipRect(clipPos, clipDim);
trans.translate(Vector3f(-mScrollOffset.x(), -mScrollOffset.y(), 0));
trans = glm::translate(trans, glm::vec3{-mScrollOffset.x, -mScrollOffset.y, 0.0f});
Renderer::setMatrix(trans);
if (mTextCache)
@ -299,9 +299,9 @@ void TextEditComponent::render(const Transform4x4f& parentTrans)
// Draw cursor.
if (mEditing) {
Vector2f cursorPos;
glm::vec2 cursorPos;
if (isMultiline()) {
cursorPos = mFont->getWrappedTextCursorOffset(mText, getTextAreaSize().x(), mCursor);
cursorPos = mFont->getWrappedTextCursorOffset(mText, getTextAreaSize().x, mCursor);
}
else {
cursorPos = mFont->sizeText(mText.substr(0, mCursor));
@ -309,24 +309,24 @@ void TextEditComponent::render(const Transform4x4f& parentTrans)
}
float cursorHeight = mFont->getHeight() * 0.8f;
Renderer::drawRect(
cursorPos.x(), cursorPos.y() + (mFont->getHeight() - cursorHeight) / 2.0f,
2.0f * Renderer::getScreenWidthModifier(), cursorHeight, 0x000000FF, 0x000000FF);
Renderer::drawRect(cursorPos.x, cursorPos.y + (mFont->getHeight() - cursorHeight) / 2.0f,
2.0f * Renderer::getScreenWidthModifier(), cursorHeight, 0x000000FF,
0x000000FF);
}
}
Vector2f TextEditComponent::getTextAreaPos() const
glm::vec2 TextEditComponent::getTextAreaPos() const
{
return Vector2f(
return glm::vec2{
(-mResolutionAdjustment + (TEXT_PADDING_HORIZ * Renderer::getScreenWidthModifier())) / 2.0f,
(TEXT_PADDING_VERT * Renderer::getScreenHeightModifier()) / 2.0f);
(TEXT_PADDING_VERT * Renderer::getScreenHeightModifier()) / 2.0f};
}
Vector2f TextEditComponent::getTextAreaSize() const
glm::vec2 TextEditComponent::getTextAreaSize() const
{
return Vector2f(mSize.x() + mResolutionAdjustment -
return glm::vec2{mSize.x + mResolutionAdjustment -
(TEXT_PADDING_HORIZ * Renderer::getScreenWidthModifier()),
mSize.y() - (TEXT_PADDING_VERT * Renderer::getScreenHeightModifier()));
mSize.y - (TEXT_PADDING_VERT * Renderer::getScreenHeightModifier())};
}
std::vector<HelpPrompt> TextEditComponent::getHelpPrompts()

10
es-core/src/components/TextEditComponent.h
View file

@ -25,7 +25,7 @@ public:
void textInput(const std::string& text) override;
bool input(InputConfig* config, Input input) override;
void update(int deltaTime) override;
void render(const Transform4x4f& parentTrans) override;
void render(const glm::mat4& parentTrans) override;
void onFocusGained() override;
void onFocusLost() override;
@ -52,9 +52,9 @@ private:
void updateCursorRepeat(int deltaTime);
void moveCursor(int amt);
bool isMultiline() { return (getSize().y() > mFont->getHeight() * 1.25f); }
Vector2f getTextAreaPos() const;
Vector2f getTextAreaSize() const;
bool isMultiline() { return (getSize().y > mFont->getHeight() * 1.25f); }
glm::vec2 getTextAreaPos() const;
glm::vec2 getTextAreaSize() const;
std::string mText;
std::string mTextOrig;
@ -65,7 +65,7 @@ private:
int mCursorRepeatTimer;
int mCursorRepeatDir;
Vector2f mScrollOffset;
glm::vec2 mScrollOffset;
NinePatchComponent mBox;
float mResolutionAdjustment;

80
es-core/src/components/TextListComponent.h
View file

@ -48,7 +48,7 @@ public:
bool input(InputConfig* config, Input input) override;
void update(int deltaTime) override;
void render(const Transform4x4f& parentTrans) override;
void render(const glm::mat4& parentTrans) override;
void applyTheme(const std::shared_ptr<ThemeData>& theme,
const std::string& view,
const std::string& element,
@ -155,22 +155,22 @@ TextListComponent<T>::TextListComponent(Window* window)
mColors[1] = 0x00FF00FF;
}
template <typename T> void TextListComponent<T>::render(const Transform4x4f& parentTrans)
template <typename T> void TextListComponent<T>::render(const glm::mat4& parentTrans)
{
if (size() == 0)
return;
Transform4x4f trans = parentTrans * getTransform();
std::shared_ptr<Font>& font = mFont;
glm::mat4 trans{parentTrans * getTransform()};
std::shared_ptr<Font>& font{mFont};
int startEntry = 0;
float y = 0;
int startEntry{0};
float y{0.0f};
const float entrySize =
std::max(font->getHeight(1.0), static_cast<float>(font->getSize())) * mLineSpacing;
const float entrySize{std::max(font->getHeight(1.0), static_cast<float>(font->getSize())) *
mLineSpacing};
// Number of entries that can fit on the screen simultaneously.
int screenCount = static_cast<int>(mSize.y() / entrySize + 0.5f);
int screenCount = static_cast<int>(mSize.y / entrySize + 0.5f);
if (size() >= screenCount) {
startEntry = mCursor - screenCount / 2;
@ -193,25 +193,26 @@ template <typename T> void TextListComponent<T>::render(const Transform4x4f& par
}
else {
Renderer::setMatrix(trans);
Renderer::drawRect(0.0f, (mCursor - startEntry) * entrySize + mSelectorOffsetY,
mSize.x(), mSelectorHeight, mSelectorColor, mSelectorColorEnd,
Renderer::drawRect(0.0f, (mCursor - startEntry) * entrySize + mSelectorOffsetY, mSize.x,
mSelectorHeight, mSelectorColor, mSelectorColorEnd,
mSelectorColorGradientHorizontal);
}
}
if (Settings::getInstance()->getBool("DebugText")) {
Renderer::drawRect(mHorizontalMargin, 0.0f, mSize.x() - mHorizontalMargin * 2.0f, mSize.y(),
Renderer::drawRect(mHorizontalMargin, 0.0f, mSize.x - mHorizontalMargin * 2.0f, mSize.y,
0x00000033, 0x00000033);
Renderer::drawRect(0.0f, 0.0f, mSize.x(), mSize.y(), 0x0000FF33, 0x0000FF33);
Renderer::drawRect(0.0f, 0.0f, mSize.x, mSize.y, 0x0000FF33, 0x0000FF33);
}
// Clip to inside margins.
Vector3f dim(mSize.x(), mSize.y(), 0.0f);
dim = trans * dim - trans.translation();
glm::vec3 dim{mSize.x, mSize.y, 0.0f};
dim.x = (trans[0].x * dim.x + trans[3].x) - trans[3].x;
dim.y = (trans[1].y * dim.y + trans[3].y) - trans[3].y;
Renderer::pushClipRect(
Vector2i(static_cast<int>(trans.translation().x() + mHorizontalMargin),
static_cast<int>(trans.translation().y())),
Vector2i(static_cast<int>(dim.x() - mHorizontalMargin * 2.0f), static_cast<int>(dim.y())));
glm::ivec2{static_cast<int>(trans[3].x + mHorizontalMargin), static_cast<int>(trans[3].y)},
glm::ivec2{static_cast<int>(dim.x - mHorizontalMargin * 2.0f), static_cast<int>(dim.y)});
for (int i = startEntry; i < listCutoff; i++) {
typename IList<TextListData, T>::Entry& entry = mEntries.at(static_cast<unsigned int>(i));
@ -235,34 +236,35 @@ template <typename T> void TextListComponent<T>::render(const Transform4x4f& par
else
entry.data.textCache->setColor(color);
Vector3f offset(0.0f, y, 0.0f);
glm::vec3 offset{0.0f, y, 0.0f};
switch (mAlignment) {
case ALIGN_LEFT:
offset[0] = mHorizontalMargin;
offset.x = mHorizontalMargin;
break;
case ALIGN_CENTER:
offset[0] =
static_cast<float>((mSize.x() - entry.data.textCache->metrics.size.x()) / 2.0f);
if (offset[0] < mHorizontalMargin)
offset[0] = mHorizontalMargin;
offset.x =
static_cast<float>((mSize.x - entry.data.textCache->metrics.size.x) / 2.0f);
if (offset.x < mHorizontalMargin)
offset.x = mHorizontalMargin;
break;
case ALIGN_RIGHT:
offset[0] = (mSize.x() - entry.data.textCache->metrics.size.x());
offset[0] -= mHorizontalMargin;
if (offset[0] < mHorizontalMargin)
offset[0] = mHorizontalMargin;
offset.x = (mSize.x - entry.data.textCache->metrics.size.x);
offset.x -= mHorizontalMargin;
if (offset.x < mHorizontalMargin)
offset.x = mHorizontalMargin;
break;
}
// Render text.
Transform4x4f drawTrans = trans;
glm::mat4 drawTrans{trans};
// Currently selected item text might be scrolling.
if (mCursor == i && mMarqueeOffset > 0)
drawTrans.translate(offset - Vector3f(static_cast<float>(mMarqueeOffset), 0.0f, 0.0f));
drawTrans = glm::translate(
drawTrans, offset - glm::vec3{static_cast<float>(mMarqueeOffset), 0.0f, 0.0f});
else
drawTrans.translate(offset);
drawTrans = glm::translate(drawTrans, offset);
// Needed to avoid flickering when returning to the start position.
if (mMarqueeOffset == 0 && mMarqueeOffset2 == 0)
@ -275,13 +277,13 @@ template <typename T> void TextListComponent<T>::render(const Transform4x4f& par
if ((mCursor == i && mMarqueeOffset2 < 0) || (mCursor == i && mMarqueeScroll)) {
mMarqueeScroll = true;
drawTrans = trans;
drawTrans.translate(offset - Vector3f(static_cast<float>(mMarqueeOffset2), 0.0f, 0.0f));
drawTrans = glm::translate(
drawTrans, offset - glm::vec3{static_cast<float>(mMarqueeOffset2), 0.0f, 0.0f});
Renderer::setMatrix(drawTrans);
font->renderTextCache(entry.data.textCache.get());
}
y += entrySize;
}
Renderer::popClipRect();
listRenderTitleOverlay(trans);
GuiComponent::renderChildren(trans);
@ -347,13 +349,13 @@ template <typename T> void TextListComponent<T>::update(int deltaTime)
const float textLength = mFont
->sizeText(Utils::String::toUpper(
mEntries.at(static_cast<unsigned int>(mCursor)).name))
.x();
const float limit = mSize.x() - mHorizontalMargin * 2.0f;
.x;
const float limit = mSize.x - mHorizontalMargin * 2.0f;
if (textLength > limit) {
// Loop.
// Pixels per second (based on nes-mini font at 1920x1080 to produce a speed of 200).
const float speed = mFont->sizeText("ABCDEFGHIJKLMNOPQRSTUVWXYZ").x() * 0.247f;
const float speed = mFont->sizeText("ABCDEFGHIJKLMNOPQRSTUVWXYZ").x * 0.247f;
const float delay = 3000.0f;
const float scrollLength = textLength;
const float returnLength = speed * 1.5f;
@ -450,7 +452,7 @@ void TextListComponent<T>::applyTheme(const std::shared_ptr<ThemeData>& theme,
}
if (elem->has("horizontalMargin")) {
mHorizontalMargin = elem->get<float>("horizontalMargin") *
(this->mParent ? this->mParent->getSize().x() :
(this->mParent ? this->mParent->getSize().x :
static_cast<float>(Renderer::getScreenWidth()));
}
}
@ -464,7 +466,7 @@ void TextListComponent<T>::applyTheme(const std::shared_ptr<ThemeData>& theme,
if (elem->has("selectorHeight"))
setSelectorHeight(elem->get<float>("selectorHeight") * Renderer::getScreenHeight());
if (elem->has("selectorOffsetY")) {
float scale = this->mParent ? this->mParent->getSize().y() :
float scale = this->mParent ? this->mParent->getSize().y :
static_cast<float>(Renderer::getScreenHeight());
setSelectorOffsetY(elem->get<float>("selectorOffsetY") * scale);
}
@ -477,7 +479,7 @@ void TextListComponent<T>::applyTheme(const std::shared_ptr<ThemeData>& theme,
std::string path = elem->get<std::string>("selectorImagePath");
bool tile = elem->has("selectorImageTile") && elem->get<bool>("selectorImageTile");
mSelectorImage.setImage(path, tile);
mSelectorImage.setSize(mSize.x(), mSelectorHeight);
mSelectorImage.setSize(mSize.x, mSelectorHeight);
mSelectorImage.setColorShift(mSelectorColor);
mSelectorImage.setColorShiftEnd(mSelectorColorEnd);
}

22
es-core/src/components/VideoComponent.cpp
View file

@ -171,12 +171,12 @@ void VideoComponent::topWindow(bool isTop)
manageState();
}
void VideoComponent::render(const Transform4x4f& parentTrans)
void VideoComponent::render(const glm::mat4& parentTrans)
{
if (!isVisible())
return;
Transform4x4f trans = parentTrans * getTransform();
glm::mat4 trans{parentTrans * getTransform()};
GuiComponent::renderChildren(trans);
Renderer::setMatrix(trans);
@ -191,7 +191,7 @@ void VideoComponent::render(const Transform4x4f& parentTrans)
pauseVideo();
}
void VideoComponent::renderSnapshot(const Transform4x4f& parentTrans)
void VideoComponent::renderSnapshot(const glm::mat4& parentTrans)
{
// This function is called when the video is not currently being played. We need to
// work out if we should display a static image. If the menu is open, then always render
@ -223,24 +223,24 @@ void VideoComponent::applyTheme(const std::shared_ptr<ThemeData>& theme,
if (!elem)
return;
Vector2f scale = getParent() ? getParent()->getSize() :
Vector2f(static_cast<float>(Renderer::getScreenWidth()),
static_cast<float>(Renderer::getScreenHeight()));
glm::vec2 scale{getParent() ? getParent()->getSize() :
glm::vec2{static_cast<float>(Renderer::getScreenWidth()),
static_cast<float>(Renderer::getScreenHeight())}};
if (properties & ThemeFlags::SIZE) {
if (elem->has("size")) {
setResize(elem->get<Vector2f>("size") * scale);
mVideoAreaSize = elem->get<Vector2f>("size") * scale;
setResize(elem->get<glm::vec2>("size") * scale);
mVideoAreaSize = elem->get<glm::vec2>("size") * scale;
}
else if (elem->has("maxSize")) {
setMaxSize(elem->get<Vector2f>("maxSize") * scale);
mVideoAreaSize = elem->get<Vector2f>("maxSize") * scale;
setMaxSize(elem->get<glm::vec2>("maxSize") * scale);
mVideoAreaSize = elem->get<glm::vec2>("maxSize") * scale;
}
}
if (properties & ThemeFlags::POSITION) {
if (elem->has("pos"))
mVideoAreaPos = elem->get<Vector2f>("pos") * scale;
mVideoAreaPos = elem->get<glm::vec2>("pos") * scale;
}
if (elem->has("default"))

14
es-core/src/components/VideoComponent.h
View file

@ -61,8 +61,8 @@ public:
void onPositionChanged() override { mStaticImage.setPosition(mPosition); }
void onSizeChanged() override { mStaticImage.onSizeChanged(); }
void render(const Transform4x4f& parentTrans) override;
void renderSnapshot(const Transform4x4f& parentTrans);
void render(const glm::mat4& parentTrans) override;
void renderSnapshot(const glm::mat4& parentTrans);
virtual void applyTheme(const std::shared_ptr<ThemeData>& theme,
const std::string& view,
@ -78,13 +78,13 @@ public:
// zero, no resizing. This can be set before or after a video is loaded.
// setMaxSize() and setResize() are mutually exclusive.
virtual void setResize(float width, float height) override = 0;
void setResize(const Vector2f& size) { setResize(size.x(), size.y()); }
void setResize(const glm::vec2& size) { setResize(size.x, size.y); }
// Resize the video to be as large as possible but fit within a box of this size.
// This can be set before or after a video is loaded.
// Never breaks the aspect ratio. setMaxSize() and setResize() are mutually exclusive.
virtual void setMaxSize(float width, float height) = 0;
void setMaxSize(const Vector2f& size) { setMaxSize(size.x(), size.y()); }
void setMaxSize(const glm::vec2& size) { setMaxSize(size.x, size.y); }
private:
// Start the video immediately.
@ -110,9 +110,9 @@ protected:
Window* mWindow;
unsigned mVideoWidth;
unsigned mVideoHeight;
Vector2f mTargetSize;
Vector2f mVideoAreaPos;
Vector2f mVideoAreaSize;
glm::vec2 mTargetSize;
glm::vec2 mVideoAreaPos;
glm::vec2 mVideoAreaSize;
std::shared_ptr<TextureResource> mTexture;
std::string mStaticImagePath;
ImageComponent mStaticImage;

84
es-core/src/components/VideoFFmpegComponent.cpp
View file

@ -57,7 +57,7 @@ VideoFFmpegComponent::~VideoFFmpegComponent() { stopVideo(); }
void VideoFFmpegComponent::setResize(float width, float height)
{
// This resize function is used when stretching videos to full screen in the video screensaver.
mTargetSize = Vector2f(width, height);
mTargetSize = glm::vec2{width, height};
mTargetIsMax = false;
mStaticImage.setResize(width, height);
resize();
@ -67,7 +67,7 @@ void VideoFFmpegComponent::setMaxSize(float width, float height)
{
// This resize function is used in most instances, such as non-stretched video screensaver
// and the gamelist videos.
mTargetSize = Vector2f(width, height);
mTargetSize = glm::vec2{width, height};
mTargetIsMax = true;
mStaticImage.setMaxSize(width, height);
resize();
@ -78,51 +78,51 @@ void VideoFFmpegComponent::resize()
if (!mTexture)
return;
const Vector2f textureSize(static_cast<float>(mVideoWidth), static_cast<float>(mVideoHeight));
const glm::vec2 textureSize{static_cast<float>(mVideoWidth), static_cast<float>(mVideoHeight)};
if (textureSize == Vector2f::Zero())
if (textureSize == glm::vec2{})
return;
if (mTargetIsMax) {
mSize = textureSize;
Vector2f resizeScale((mTargetSize.x() / mSize.x()), (mTargetSize.y() / mSize.y()));
glm::vec2 resizeScale{(mTargetSize.x / mSize.x), (mTargetSize.y / mSize.y)};
if (resizeScale.x() < resizeScale.y()) {
mSize[0] *= resizeScale.x();
mSize[1] *= resizeScale.x();
if (resizeScale.x < resizeScale.y) {
mSize.x *= resizeScale.x;
mSize.y *= resizeScale.x;
}
else {
mSize[0] *= resizeScale.y();
mSize[1] *= resizeScale.y();
mSize.x *= resizeScale.y;
mSize.y *= resizeScale.y;
}
mSize[1] = std::round(mSize[1]);
mSize[0] = (mSize[1] / textureSize.y()) * textureSize.x();
mSize.y = std::round(mSize.y);
mSize.x = (mSize.y / textureSize.y) * textureSize.x;
}
else {
// If both components are set, we just stretch.
// If no components are set, we don't resize at all.
mSize = mTargetSize == Vector2f::Zero() ? textureSize : mTargetSize;
mSize = mTargetSize == glm::vec2{} ? textureSize : mTargetSize;
// If only one component is set, we resize in a way that maintains aspect ratio.
if (!mTargetSize.x() && mTargetSize.y()) {
mSize[1] = std::round(mTargetSize.y());
mSize[0] = (mSize.y() / textureSize.y()) * textureSize.x();
if (!mTargetSize.x && mTargetSize.y) {
mSize.y = std::round(mTargetSize.y);
mSize.x = (mSize.y / textureSize.y) * textureSize.x;
}
else if (mTargetSize.x() && !mTargetSize.y()) {
mSize[1] = std::round((mTargetSize.x() / textureSize.x()) * textureSize.y());
mSize[0] = (mSize.y() / textureSize.y()) * textureSize.x();
else if (mTargetSize.x && !mTargetSize.y) {
mSize.y = std::round((mTargetSize.x / textureSize.x) * textureSize.y);
mSize.x = (mSize.y / textureSize.y) * textureSize.x;
}
}
onSizeChanged();
}
void VideoFFmpegComponent::render(const Transform4x4f& parentTrans)
void VideoFFmpegComponent::render(const glm::mat4& parentTrans)
{
VideoComponent::render(parentTrans);
Transform4x4f trans = parentTrans * getTransform();
glm::mat4 trans{parentTrans * getTransform()};
GuiComponent::renderChildren(trans);
if (mIsPlaying && mFormatContext) {
@ -147,14 +147,14 @@ void VideoFFmpegComponent::render(const Transform4x4f& parentTrans)
// clang-format off
vertices[0] = {{0.0f , 0.0f }, {0.0f, 0.0f}, color};
vertices[1] = { { 0.0f , mSize.y() }, { 0.0f, 1.0f }, color };
vertices[2] = { { mSize.x(), 0.0f }, { 1.0f, 0.0f }, color };
vertices[3] = { { mSize.x(), mSize.y() }, { 1.0f, 1.0f }, color };
vertices[1] = {{0.0f , mSize.y}, {0.0f, 1.0f}, color};
vertices[2] = {{mSize.x , 0.0f }, {1.0f, 0.0f}, color};
vertices[3] = {{mSize.x , mSize.y}, {1.0f, 1.0f}, color};
// clang-format on
// Round vertices.
for (int i = 0; i < 4; i++)
vertices[i].pos.round();
vertices[i].pos = glm::round(vertices[i].pos);
// This is needed to avoid a slight gap before the video starts playing.
if (!mDecodedFrame)
@ -798,51 +798,49 @@ void VideoFFmpegComponent::calculateBlackRectangle()
// otherwise it will exactly match the video size. The reason to add a black rectangle
// behind videos in this second instance is that the scanline rendering will make the
// video partially transparent so this may avoid some unforseen issues with some themes.
if (mVideoAreaPos != 0 && mVideoAreaSize != 0) {
if (mVideoAreaPos != glm::vec2{} && mVideoAreaSize != glm::vec2{}) {
mVideoRectangleCoords.clear();
if (Settings::getInstance()->getBool("GamelistVideoPillarbox")) {
float rectHeight;
float rectWidth;
// Video is in landscape orientation.
if (mSize.x() > mSize.y()) {
if (mSize.x > mSize.y) {
// Checking the Y size should not normally be required as landscape format
// should mean the height can't be higher than the max size defined by the
// theme. But as the height in mSize is provided by FFmpeg in integer format
// and then scaled, there could be rounding errors that make the video height
// slightly higher than allowed. It's only a single pixel or a few pixels, but
// it's still visible for some videos.
if (mSize.y() < mVideoAreaSize.y() && mSize.y() / mVideoAreaSize.y() < 0.90)
rectHeight = mVideoAreaSize.y();
if (mSize.y < mVideoAreaSize.y && mSize.y / mVideoAreaSize.y < 0.90f)
rectHeight = mVideoAreaSize.y;
else
rectHeight = mSize.y();
rectHeight = mSize.y;
// Don't add a black border that is too narrow, that's what the 0.85 constant
// takes care of.
if (mSize.x() < mVideoAreaSize.x() && mSize.x() / mVideoAreaSize.x() < 0.85)
rectWidth = mVideoAreaSize.x();
if (mSize.x < mVideoAreaSize.x && mSize.x / mVideoAreaSize.x < 0.85f)
rectWidth = mVideoAreaSize.x;
else
rectWidth = mSize.x();
rectWidth = mSize.x;
}
// Video is in portrait orientation (or completely square).
else {
rectWidth = mVideoAreaSize.x();
rectHeight = mSize.y();
rectWidth = mVideoAreaSize.x;
rectHeight = mSize.y;
}
// Populate the rectangle coordinates to be used in render().
mVideoRectangleCoords.push_back(
std::round(mVideoAreaPos.x() - rectWidth * mOrigin.x()));
mVideoRectangleCoords.push_back(
std::round(mVideoAreaPos.y() - rectHeight * mOrigin.y()));
mVideoRectangleCoords.push_back(std::round(mVideoAreaPos.x - rectWidth * mOrigin.x));
mVideoRectangleCoords.push_back(std::round(mVideoAreaPos.y - rectHeight * mOrigin.y));
mVideoRectangleCoords.push_back(std::round(rectWidth));
mVideoRectangleCoords.push_back(std::round(rectHeight));
}
// If the option to display pillarboxes is disabled, then make the rectangle equivalent
// to the size of the video.
else {
mVideoRectangleCoords.push_back(std::round(mPosition.x() - mSize.x() * mOrigin.x()));
mVideoRectangleCoords.push_back(std::round(mPosition.y() - mSize.y() * mOrigin.y()));
mVideoRectangleCoords.push_back(std::round(mSize.x()));
mVideoRectangleCoords.push_back(std::round(mSize.y()));
mVideoRectangleCoords.push_back(std::round(mPosition.x - mSize.x * mOrigin.x));
mVideoRectangleCoords.push_back(std::round(mPosition.y - mSize.y * mOrigin.y));
mVideoRectangleCoords.push_back(std::round(mSize.x));
mVideoRectangleCoords.push_back(std::round(mSize.y));
}
}
}

2
es-core/src/components/VideoFFmpegComponent.h
View file

@ -50,7 +50,7 @@ private:
// Used internally whenever the resizing parameters or texture change.
void resize();
void render(const Transform4x4f& parentTrans) override;
void render(const glm::mat4& parentTrans) override;
virtual void updatePlayer() override;
// This will run the frame processing in a separate thread.

84
es-core/src/components/VideoVlcComponent.cpp
View file

@ -63,7 +63,7 @@ void VideoVlcComponent::deinit()
void VideoVlcComponent::setResize(float width, float height)
{
// This resize function is used when stretching videos to full screen in the video screensaver.
mTargetSize = Vector2f(width, height);
mTargetSize = glm::vec2{width, height};
mTargetIsMax = false;
mStaticImage.setResize(width, height);
resize();
@ -73,7 +73,7 @@ void VideoVlcComponent::setMaxSize(float width, float height)
{
// This resize function is used in most instances, such as non-stretched video screensaver
// and the gamelist videos.
mTargetSize = Vector2f(width, height);
mTargetSize = glm::vec2{width, height};
mTargetIsMax = true;
mStaticImage.setMaxSize(width, height);
resize();
@ -127,48 +127,48 @@ void VideoVlcComponent::resize()
if (!mTexture)
return;
const Vector2f textureSize(static_cast<float>(mVideoWidth), static_cast<float>(mVideoHeight));
const glm::vec2 textureSize(static_cast<float>(mVideoWidth), static_cast<float>(mVideoHeight));
if (textureSize == Vector2f::Zero())
if (textureSize == glm::vec2{})
return;
if (mTargetIsMax) {
mSize = textureSize;
Vector2f resizeScale((mTargetSize.x() / mSize.x()), (mTargetSize.y() / mSize.y()));
glm::vec2 resizeScale{(mTargetSize.x / mSize.x), (mTargetSize.y / mSize.y)};
if (resizeScale.x() < resizeScale.y()) {
mSize[0] *= resizeScale.x();
mSize[1] *= resizeScale.x();
if (resizeScale.x < resizeScale.y) {
mSize.x *= resizeScale.x;
mSize.y *= resizeScale.x;
}
else {
mSize[0] *= resizeScale.y();
mSize[1] *= resizeScale.y();
mSize.x *= resizeScale.y;
mSize.y *= resizeScale.y;
}
mSize[1] = std::round(mSize[1]);
mSize[0] = (mSize[1] / textureSize.y()) * textureSize.x();
mSize.x = (mSize.y / textureSize.y) * textureSize.x;
mSize.y = std::round(mSize[1]);
}
else {
// If both components are set, we just stretch.
// If no components are set, we don't resize at all.
mSize = mTargetSize == Vector2f::Zero() ? textureSize : mTargetSize;
mSize = mTargetSize == glm::vec2{} ? textureSize : mTargetSize;
// If only one component is set, we resize in a way that maintains aspect ratio.
if (!mTargetSize.x() && mTargetSize.y()) {
mSize[1] = std::round(mTargetSize.y());
mSize[0] = (mSize.y() / textureSize.y()) * textureSize.x();
if (!mTargetSize.x && mTargetSize.y) {
mSize.y = std::round(mTargetSize.y);
mSize.x = (mSize.y / textureSize.y) * textureSize.x;
}
else if (mTargetSize.x() && !mTargetSize.y()) {
mSize[1] = std::round((mTargetSize.x() / textureSize.x()) * textureSize.y());
mSize[0] = (mSize.y() / textureSize.y()) * textureSize.x();
else if (mTargetSize.x && !mTargetSize.y) {
mSize.y = std::round((mTargetSize.x / textureSize.x) * textureSize.y);
mSize.x = (mSize.y / textureSize.y) * textureSize.x;
}
}
onSizeChanged();
}
void VideoVlcComponent::render(const Transform4x4f& parentTrans)
void VideoVlcComponent::render(const glm::mat4& parentTrans)
{
// Set the audio volume. As libVLC is very unreliable we need to make an additional
// attempt here in the render loop in addition to the initialization in startVideo().
@ -179,7 +179,7 @@ void VideoVlcComponent::render(const Transform4x4f& parentTrans)
setAudioVolume();
VideoComponent::render(parentTrans);
Transform4x4f trans = parentTrans * getTransform();
glm::mat4 trans{parentTrans * getTransform()};
GuiComponent::renderChildren(trans);
// Check the actual VLC state, i.e. if the video is really playing rather than
@ -214,14 +214,14 @@ void VideoVlcComponent::render(const Transform4x4f& parentTrans)
// clang-format off
vertices[0] = {{0.0f , 0.0f }, {0.0f, 0.0f}, color};
vertices[1] = { { 0.0f , mSize.y() }, { 0.0f, 1.0f }, color };
vertices[2] = { { mSize.x(), 0.0f }, { 1.0f, 0.0f }, color };
vertices[3] = { { mSize.x(), mSize.y() }, { 1.0f, 1.0f }, color };
vertices[1] = {{0.0f , mSize.y}, {0.0f, 1.0f}, color};
vertices[2] = {{mSize.x, 0.0f }, {1.0f, 0.0f}, color};
vertices[3] = {{mSize.x, mSize.y}, {1.0f, 1.0f}, color};
// clang-format on
// Round vertices.
for (int i = 0; i < 4; i++)
vertices[i].pos.round();
vertices[i].pos = glm::round(vertices[i].pos);
// Build a texture for the video frame.
mTexture->initFromPixels(reinterpret_cast<unsigned char*>(mContext.surface->pixels),
@ -255,51 +255,49 @@ void VideoVlcComponent::calculateBlackRectangle()
// otherwise it will exactly match the video size. The reason to add a black rectangle
// behind videos in this second instance is that the scanline rendering will make the
// video partially transparent so this may avoid some unforseen issues with some themes.
if (mVideoAreaPos != 0 && mVideoAreaSize != 0) {
if (mVideoAreaPos != glm::vec2{} && mVideoAreaSize != glm::vec2{}) {
mVideoRectangleCoords.clear();
if (Settings::getInstance()->getBool("GamelistVideoPillarbox")) {
float rectHeight;
float rectWidth;
// Video is in landscape orientation.
if (mSize.x() > mSize.y()) {
if (mSize.x > mSize.y) {
// Checking the Y size should not normally be required as landscape format
// should mean the height can't be higher than the max size defined by the
// theme. But as the height in mSize is provided by libVLC in integer format
// and then scaled, there could be rounding errors that make the video height
// slightly higher than allowed. It's only a single pixel or a few pixels, but
// it's still visible for some videos.
if (mSize.y() < mVideoAreaSize.y() && mSize.y() / mVideoAreaSize.y() < 0.90)
rectHeight = mVideoAreaSize.y();
if (mSize.y < mVideoAreaSize.y && mSize.y / mVideoAreaSize.y < 0.90f)
rectHeight = mVideoAreaSize.y;
else
rectHeight = mSize.y();
rectHeight = mSize.y;
// Don't add a black border that is too narrow, that's what the 0.85 constant
// takes care of.
if (mSize.x() < mVideoAreaSize.x() && mSize.x() / mVideoAreaSize.x() < 0.85)
rectWidth = mVideoAreaSize.x();
if (mSize.x < mVideoAreaSize.x && mSize.x / mVideoAreaSize.x < 0.85f)
rectWidth = mVideoAreaSize.x;
else
rectWidth = mSize.x();
rectWidth = mSize.x;
}
// Video is in portrait orientation (or completely square).
else {
rectWidth = mVideoAreaSize.x();
rectHeight = mSize.y();
rectWidth = mVideoAreaSize.x;
rectHeight = mSize.y;
}
// Populate the rectangle coordinates to be used in render().
mVideoRectangleCoords.push_back(
std::round(mVideoAreaPos.x() - rectWidth * mOrigin.x()));
mVideoRectangleCoords.push_back(
std::round(mVideoAreaPos.y() - rectHeight * mOrigin.y()));
mVideoRectangleCoords.push_back(std::round(mVideoAreaPos.x - rectWidth * mOrigin.x));
mVideoRectangleCoords.push_back(std::round(mVideoAreaPos.y - rectHeight * mOrigin.y));
mVideoRectangleCoords.push_back(std::round(rectWidth));
mVideoRectangleCoords.push_back(std::round(rectHeight));
}
// If the option to display pillarboxes is disabled, then make the rectangle equivalent
// to the size of the video.
else {
mVideoRectangleCoords.push_back(std::round(mPosition.x() - mSize.x() * mOrigin.x()));
mVideoRectangleCoords.push_back(std::round(mPosition.y() - mSize.y() * mOrigin.y()));
mVideoRectangleCoords.push_back(std::round(mSize.x()));
mVideoRectangleCoords.push_back(std::round(mSize.y()));
mVideoRectangleCoords.push_back(std::round(mPosition.x - mSize.x * mOrigin.x));
mVideoRectangleCoords.push_back(std::round(mPosition.y - mSize.y * mOrigin.y));
mVideoRectangleCoords.push_back(std::round(mSize.x));
mVideoRectangleCoords.push_back(std::round(mSize.y));
}
}
}

2
es-core/src/components/VideoVlcComponent.h
View file

@ -53,7 +53,7 @@ private:
// Used internally whenever the resizing parameters or texture change.
void resize();
void render(const Transform4x4f& parentTrans) override;
void render(const glm::mat4& parentTrans) override;
void calculateBlackRectangle();
void setAudioVolume();

28
es-core/src/guis/GuiComplexTextEditPopup.cpp
View file

@ -35,7 +35,7 @@ GuiComplexTextEditPopup::GuiComplexTextEditPopup(
: GuiComponent(window)
, mHelpStyle(helpstyle)
, mBackground(window, ":/graphics/frame.svg")
, mGrid(window, Vector2i(1, 5))
, mGrid(window, glm::ivec2{1, 5})
, mMultiLine(multiLine)
, mInitValue(initValue)
, mOkCallback(okCallback)
@ -75,12 +75,12 @@ GuiComplexTextEditPopup::GuiComplexTextEditPopup(
mButtonGrid = makeButtonGrid(mWindow, buttons);
mGrid.setEntry(mTitle, Vector2i(0, 0), false, true);
mGrid.setEntry(mInfoString1, Vector2i(0, 1), false, true);
mGrid.setEntry(mInfoString2, Vector2i(0, 2), false, false);
mGrid.setEntry(mText, Vector2i(0, 3), true, false, Vector2i(1, 1),
mGrid.setEntry(mTitle, glm::ivec2{0, 0}, false, true);
mGrid.setEntry(mInfoString1, glm::ivec2{0, 1}, false, true);
mGrid.setEntry(mInfoString2, glm::ivec2{0, 2}, false, false);
mGrid.setEntry(mText, glm::ivec2{0, 3}, true, false, glm::ivec2{1, 1},
GridFlags::BORDER_TOP | GridFlags::BORDER_BOTTOM);
mGrid.setEntry(mButtonGrid, Vector2i(0, 4), true, false);
mGrid.setEntry(mButtonGrid, glm::ivec2{0, 4}, true, false);
mGrid.setRowHeightPerc(1, 0.15f, true);
float textHeight = mText->getFont()->getHeight();
@ -97,21 +97,21 @@ GuiComplexTextEditPopup::GuiComplexTextEditPopup(
mText->setSize(0, textHeight);
mInfoString2->setSize(infoWidth, mInfoString2->getFont()->getHeight());
setSize(windowWidth, mTitle->getFont()->getHeight() + textHeight + mButtonGrid->getSize().y() +
mButtonGrid->getSize().y() * 1.85f);
setPosition((Renderer::getScreenWidth() - mSize.x()) / 2.0f,
(Renderer::getScreenHeight() - mSize.y()) / 2.0f);
setSize(windowWidth, mTitle->getFont()->getHeight() + textHeight + mButtonGrid->getSize().y +
mButtonGrid->getSize().y * 1.85f);
setPosition((Renderer::getScreenWidth() - mSize.x) / 2.0f,
(Renderer::getScreenHeight() - mSize.y) / 2.0f);
mText->startEditing();
}
void GuiComplexTextEditPopup::onSizeChanged()
{
mBackground.fitTo(mSize, Vector3f::Zero(), Vector2f(-32.0f, -32.0f));
mText->setSize(mSize.x() - 40.0f, mText->getSize().y());
mBackground.fitTo(mSize, glm::vec3{}, glm::vec2{-32.0f, -32.0f});
mText->setSize(mSize.x - 40.0f, mText->getSize().y);
// Update grid.
mGrid.setRowHeightPerc(0, mTitle->getFont()->getHeight() / mSize.y());
mGrid.setRowHeightPerc(2, mButtonGrid->getSize().y() / mSize.y());
mGrid.setRowHeightPerc(0, mTitle->getFont()->getHeight() / mSize.y);
mGrid.setRowHeightPerc(2, mButtonGrid->getSize().y / mSize.y);
mGrid.setSize(mSize);
}

25
es-core/src/guis/GuiDetectDevice.cpp
View file

@ -25,7 +25,7 @@ GuiDetectDevice::GuiDetectDevice(Window* window,
, mFirstRun(firstRun)
, mForcedConfig(forcedConfig)
, mBackground(window, ":/graphics/frame.svg")
, mGrid(window, Vector2i(1, 5))
, mGrid(window, glm::ivec2{1, 5})
{
mHoldingConfig = nullptr;
mHoldTime = 0;
@ -38,7 +38,8 @@ GuiDetectDevice::GuiDetectDevice(Window* window,
mTitle =
std::make_shared<TextComponent>(mWindow, firstRun ? "WELCOME" : "CONFIGURE INPUT DEVICE",
Font::get(FONT_SIZE_LARGE), 0x555555FF, ALIGN_CENTER);
mGrid.setEntry(mTitle, Vector2i(0, 0), false, true, Vector2i(1, 1), GridFlags::BORDER_BOTTOM);
mGrid.setEntry(mTitle, glm::ivec2{0, 0}, false, true, glm::ivec2{1, 1},
GridFlags::BORDER_BOTTOM);
// Device info.
std::stringstream deviceInfo;
@ -54,7 +55,7 @@ GuiDetectDevice::GuiDetectDevice(Window* window,
mDeviceInfo = std::make_shared<TextComponent>(
mWindow, deviceInfo.str(), Font::get(FONT_SIZE_SMALL), 0x999999FF, ALIGN_CENTER);
mGrid.setEntry(mDeviceInfo, Vector2i(0, 1), false, true);
mGrid.setEntry(mDeviceInfo, glm::ivec2{0, 1}, false, true);
// Message.
if (numDevices > 0) {
@ -68,18 +69,18 @@ GuiDetectDevice::GuiDetectDevice(Window* window,
0x777777FF, ALIGN_CENTER);
}
mGrid.setEntry(mMsg1, Vector2i(0, 2), false, true);
mGrid.setEntry(mMsg1, glm::ivec2{0, 2}, false, true);
const std::string msg2str =
firstRun ? "PRESS ESC TO SKIP (OR F4 TO QUIT AT ANY TIME)" : "PRESS ESC TO CANCEL";
mMsg2 = std::make_shared<TextComponent>(mWindow, msg2str, Font::get(FONT_SIZE_SMALL),
0x777777FF, ALIGN_CENTER);
mGrid.setEntry(mMsg2, Vector2i(0, 3), false, true);
mGrid.setEntry(mMsg2, glm::ivec2{0, 3}, false, true);
// Currently held device.
mDeviceHeld = std::make_shared<TextComponent>(mWindow, "", Font::get(FONT_SIZE_MEDIUM),
0xFFFFFFFF, ALIGN_CENTER);
mGrid.setEntry(mDeviceHeld, Vector2i(0, 4), false, true);
mGrid.setEntry(mDeviceHeld, glm::ivec2{0, 4}, false, true);
// Adjust the width relative to the aspect ratio of the screen to make the GUI look coherent
// regardless of screen type. The 1.778 aspect ratio value is the 16:9 reference.
@ -87,20 +88,20 @@ GuiDetectDevice::GuiDetectDevice(Window* window,
float width = Math::clamp(0.60f * aspectValue, 0.50f, 0.80f) * Renderer::getScreenWidth();
setSize(width, Renderer::getScreenHeight() * 0.5f);
setPosition((Renderer::getScreenWidth() - mSize.x()) / 2.0f,
(Renderer::getScreenHeight() - mSize.y()) / 2.0f);
setPosition((Renderer::getScreenWidth() - mSize.x) / 2.0f,
(Renderer::getScreenHeight() - mSize.y) / 2.0f);
}
void GuiDetectDevice::onSizeChanged()
{
mBackground.fitTo(mSize, Vector3f::Zero(), Vector2f(-32.0f, -32.0f));
mBackground.fitTo(mSize, glm::vec3{}, glm::vec2{-32.0f, -32.0f});
// Grid.
mGrid.setSize(mSize);
mGrid.setRowHeightPerc(0, mTitle->getFont()->getHeight() / mSize.y());
mGrid.setRowHeightPerc(0, mTitle->getFont()->getHeight() / mSize.y);
// mGrid.setRowHeightPerc(1, mDeviceInfo->getFont()->getHeight() / mSize.y());
mGrid.setRowHeightPerc(2, mMsg1->getFont()->getHeight() / mSize.y());
mGrid.setRowHeightPerc(3, mMsg2->getFont()->getHeight() / mSize.y());
mGrid.setRowHeightPerc(2, mMsg1->getFont()->getHeight() / mSize.y);
mGrid.setRowHeightPerc(3, mMsg2->getFont()->getHeight() / mSize.y);
// mGrid.setRowHeightPerc(4, mDeviceHeld->getFont()->getHeight() / mSize.y());
}

32
es-core/src/guis/GuiInputConfig.cpp
View file

@ -33,7 +33,7 @@ GuiInputConfig::GuiInputConfig(Window* window,
const std::function<void()>& okCallback)
: GuiComponent(window)
, mBackground(window, ":/graphics/frame.svg")
, mGrid(window, Vector2i(1, 7))
, mGrid(window, glm::ivec2{1, 7})
, mTargetConfig(target)
, mHoldingInput(false)
{
@ -54,11 +54,11 @@ GuiInputConfig::GuiInputConfig(Window* window,
addChild(&mGrid);
// 0 is a spacer row.
mGrid.setEntry(std::make_shared<GuiComponent>(mWindow), Vector2i(0, 0), false);
mGrid.setEntry(std::make_shared<GuiComponent>(mWindow), glm::ivec2{0, 0}, false);
mTitle = std::make_shared<TextComponent>(mWindow, "CONFIGURING", Font::get(FONT_SIZE_LARGE),
0x555555FF, ALIGN_CENTER);
mGrid.setEntry(mTitle, Vector2i(0, 1), false, true);
mGrid.setEntry(mTitle, glm::ivec2{0, 1}, false, true);
std::stringstream ss;
if (target->getDeviceId() == DEVICE_KEYBOARD)
@ -70,7 +70,7 @@ GuiInputConfig::GuiInputConfig(Window* window,
mSubtitle1 =
std::make_shared<TextComponent>(mWindow, Utils::String::toUpper(ss.str()),
Font::get(FONT_SIZE_MEDIUM), 0x555555FF, ALIGN_CENTER);
mGrid.setEntry(mSubtitle1, Vector2i(0, 2), false, true);
mGrid.setEntry(mSubtitle1, glm::ivec2{0, 2}, false, true);
mSubtitle2 =
std::make_shared<TextComponent>(mWindow, "HOLD ANY BUTTON 1 SECOND TO SKIP",
@ -78,11 +78,11 @@ GuiInputConfig::GuiInputConfig(Window* window,
// The opacity will be set to visible for any row that is skippable.
mSubtitle2->setOpacity(0);
mGrid.setEntry(mSubtitle2, Vector2i(0, 3), false, true);
mGrid.setEntry(mSubtitle2, glm::ivec2{0, 3}, false, true);
// 4 is a spacer row.
mList = std::make_shared<ComponentList>(mWindow);
mGrid.setEntry(mList, Vector2i(0, 5), true, true);
mGrid.setEntry(mList, glm::ivec2{0, 5}, true, true);
for (int i = 0; i < inputCount; i++) {
ComponentListRow row;
@ -184,7 +184,7 @@ GuiInputConfig::GuiInputConfig(Window* window,
[this, okFunction] { okFunction(); }));
mButtonGrid = makeButtonGrid(mWindow, buttons);
mGrid.setEntry(mButtonGrid, Vector2i(0, 6), true, false);
mGrid.setEntry(mButtonGrid, glm::ivec2{0, 6}, true, false);
// Adjust the width relative to the aspect ratio of the screen to make the GUI look coherent
// regardless of screen type. The 1.778 aspect ratio value is the 16:9 reference.
@ -192,8 +192,8 @@ GuiInputConfig::GuiInputConfig(Window* window,
float width = Math::clamp(0.60f * aspectValue, 0.50f, 0.80f) * Renderer::getScreenWidth();
setSize(width, Renderer::getScreenHeight() * 0.75f);
setPosition((Renderer::getScreenWidth() - mSize.x()) / 2.0f,
(Renderer::getScreenHeight() - mSize.y()) / 2.0f);
setPosition((Renderer::getScreenWidth() - mSize.x) / 2.0f,
(Renderer::getScreenHeight() - mSize.y) / 2.0f);
}
void GuiInputConfig::populateConfigList()
@ -293,16 +293,16 @@ void GuiInputConfig::update(int deltaTime)
void GuiInputConfig::onSizeChanged()
{
mBackground.fitTo(mSize, Vector3f::Zero(), Vector2f(-32.0f, -32.0f));
mBackground.fitTo(mSize, glm::vec3{}, glm::vec2{-32.0f, -32.0f});
// Update grid.
mGrid.setSize(mSize);
mGrid.setRowHeightPerc(1, mTitle->getFont()->getHeight() * 0.75f / mSize.y());
mGrid.setRowHeightPerc(2, mSubtitle1->getFont()->getHeight() / mSize.y());
mGrid.setRowHeightPerc(3, mSubtitle2->getFont()->getHeight() / mSize.y());
mGrid.setRowHeightPerc(5, (mList->getRowHeight(0) * 5 + 2) / mSize.y());
mGrid.setRowHeightPerc(6, mButtonGrid->getSize().y() / mSize.y());
mGrid.setRowHeightPerc(1, mTitle->getFont()->getHeight() * 0.75f / mSize.y);
mGrid.setRowHeightPerc(2, mSubtitle1->getFont()->getHeight() / mSize.y);
mGrid.setRowHeightPerc(3, mSubtitle2->getFont()->getHeight() / mSize.y);
mGrid.setRowHeightPerc(5, (mList->getRowHeight(0) * 5.0f + 2.0f) / mSize.y);
mGrid.setRowHeightPerc(6, mButtonGrid->getSize().y / mSize.y);
}
void GuiInputConfig::rowDone()
@ -313,7 +313,7 @@ void GuiInputConfig::rowDone()
// At bottom of list, we're done.
mConfiguringAll = false;
mConfiguringRow = false;
mGrid.moveCursor(Vector2i(0, 1));
mGrid.moveCursor(glm::ivec2{0, 1});
}
else {
// On another row.

49
es-core/src/guis/GuiMsgBox.cpp
View file

@ -12,7 +12,7 @@
#include "components/ButtonComponent.h"
#include "components/MenuComponent.h"
#define HORIZONTAL_PADDING_PX 20
#define HORIZONTAL_PADDING_PX 20.0f
GuiMsgBox::GuiMsgBox(Window* window,
const HelpStyle& helpstyle,
@ -28,7 +28,7 @@ GuiMsgBox::GuiMsgBox(Window* window,
: GuiComponent(window)
, mHelpStyle(helpstyle)
, mBackground(window, ":/graphics/frame.svg")
, mGrid(window, Vector2i(1, 2))
, mGrid(window, glm::ivec2{1, 2})
, mDisableBackButton(disableBackButton)
, mDeleteOnButtonPress(deleteOnButtonPress)
{
@ -43,7 +43,7 @@ GuiMsgBox::GuiMsgBox(Window* window,
mMsg = std::make_shared<TextComponent>(mWindow, text, Font::get(FONT_SIZE_MEDIUM), 0x777777FF,
ALIGN_CENTER);
mGrid.setEntry(mMsg, Vector2i(0, 0), false, false);
mGrid.setEntry(mMsg, glm::ivec2{0, 0}, false, false);
// Create the buttons.
mButtons.push_back(std::make_shared<ButtonComponent>(
@ -71,28 +71,29 @@ GuiMsgBox::GuiMsgBox(Window* window,
// Put the buttons into a ComponentGrid.
mButtonGrid = makeButtonGrid(mWindow, mButtons);
mGrid.setEntry(mButtonGrid, Vector2i(0, 1), true, false, Vector2i(1, 1), GridFlags::BORDER_TOP);
mGrid.setEntry(mButtonGrid, glm::ivec2{0, 1}, true, false, glm::ivec2{1, 1},
GridFlags::BORDER_TOP);
// Decide final width.
if (mMsg->getSize().x() < width && mButtonGrid->getSize().x() < width) {
if (mMsg->getSize().x < width && mButtonGrid->getSize().x < width) {
// mMsg and buttons are narrower than width.
width = std::max(mButtonGrid->getSize().x(), mMsg->getSize().x());
width = std::max(mButtonGrid->getSize().x, mMsg->getSize().x);
width = std::max(width, minWidth);
}
else if (mButtonGrid->getSize().x() > width) {
width = mButtonGrid->getSize().x();
else if (mButtonGrid->getSize().x > width) {
width = mButtonGrid->getSize().x;
}
// Now that we know width, we can find height.
mMsg->setSize(width, 0); // mMsg->getSize.y() now returns the proper length.
mMsg->setSize(width, 0.0f); // mMsg->getSize.y() now returns the proper length.
const float msgHeight =
std::max(Font::get(FONT_SIZE_LARGE)->getHeight(), mMsg->getSize().y() * 1.225f);
setSize(width + HORIZONTAL_PADDING_PX * 2 * Renderer::getScreenWidthModifier(),
msgHeight + mButtonGrid->getSize().y());
std::max(Font::get(FONT_SIZE_LARGE)->getHeight(), mMsg->getSize().y * 1.225f);
setSize(width + HORIZONTAL_PADDING_PX * 2.0f * Renderer::getScreenWidthModifier(),
msgHeight + mButtonGrid->getSize().y);
// Center for good measure.
setPosition((Renderer::getScreenWidth() - mSize.x()) / 2.0f,
(Renderer::getScreenHeight() - mSize.y()) / 2.0f);
setPosition((Renderer::getScreenWidth() - mSize.x) / 2.0f,
(Renderer::getScreenHeight() - mSize.y) / 2.0f);
addChild(&mBackground);
addChild(&mGrid);
@ -113,21 +114,21 @@ void GuiMsgBox::changeText(const std::string& newText)
float minWidth = Renderer::getScreenWidth() * 0.3f;
// Decide final width.
if (mMsg->getSize().x() < width && mButtonGrid->getSize().x() < width) {
if (mMsg->getSize().x < width && mButtonGrid->getSize().x < width) {
// mMsg and buttons are narrower than width.
width = std::max(mButtonGrid->getSize().x(), mMsg->getSize().x());
width = std::max(mButtonGrid->getSize().x, mMsg->getSize().x);
width = std::max(width, minWidth);
}
else if (mButtonGrid->getSize().x() > mSize.x()) {
width = mButtonGrid->getSize().x();
else if (mButtonGrid->getSize().x > mSize.x) {
width = mButtonGrid->getSize().x;
}
// Now that we know width, we can find height.
mMsg->setSize(width, 0); // mMsg->getSize.y() now returns the proper length.
const float msgHeight =
std::max(Font::get(FONT_SIZE_LARGE)->getHeight(), mMsg->getSize().y() * 1.225f);
setSize(width + HORIZONTAL_PADDING_PX * 2 * Renderer::getScreenWidthModifier(),
msgHeight + mButtonGrid->getSize().y());
std::max(Font::get(FONT_SIZE_LARGE)->getHeight(), mMsg->getSize().y * 1.225f);
setSize(width + HORIZONTAL_PADDING_PX * 2.0f * Renderer::getScreenWidthModifier(),
msgHeight + mButtonGrid->getSize().y);
}
bool GuiMsgBox::input(InputConfig* config, Input input)
@ -153,14 +154,14 @@ bool GuiMsgBox::input(InputConfig* config, Input input)
void GuiMsgBox::onSizeChanged()
{
mGrid.setSize(mSize);
mGrid.setRowHeightPerc(1, mButtonGrid->getSize().y() / mSize.y());
mGrid.setRowHeightPerc(1, mButtonGrid->getSize().y / mSize.y);
// Update messagebox size.
mMsg->setSize(mSize.x() - HORIZONTAL_PADDING_PX * 2 * Renderer::getScreenWidthModifier(),
mMsg->setSize(mSize.x - HORIZONTAL_PADDING_PX * 2.0f * Renderer::getScreenWidthModifier(),
mGrid.getRowHeight(0));
mGrid.onSizeChanged();
mBackground.fitTo(mSize, Vector3f::Zero(), Vector2f(-32.0f, -32.0f));
mBackground.fitTo(mSize, glm::vec3{}, glm::vec2{-32.0f, -32.0f});
}
void GuiMsgBox::deleteMeAndCall(const std::function<void()>& func)

24
es-core/src/guis/GuiTextEditPopup.cpp
View file

@ -25,7 +25,7 @@ GuiTextEditPopup::GuiTextEditPopup(Window* window,
: GuiComponent(window)
, mHelpStyle(helpstyle)
, mBackground(window, ":/graphics/frame.svg")
, mGrid(window, Vector2i(1, 3))
, mGrid(window, glm::ivec2{1, 3})
, mMultiLine(multiLine)
, mInitValue(initValue)
, mOkCallback(okCallback)
@ -53,10 +53,10 @@ GuiTextEditPopup::GuiTextEditPopup(Window* window,
mButtonGrid = makeButtonGrid(mWindow, buttons);
mGrid.setEntry(mTitle, Vector2i(0, 0), false, true);
mGrid.setEntry(mText, Vector2i(0, 1), true, false, Vector2i(1, 1),
mGrid.setEntry(mTitle, glm::ivec2{0, 0}, false, true);
mGrid.setEntry(mText, glm::ivec2{0, 1}, true, false, glm::ivec2{1, 1},
GridFlags::BORDER_TOP | GridFlags::BORDER_BOTTOM);
mGrid.setEntry(mButtonGrid, Vector2i(0, 2), true, false);
mGrid.setEntry(mButtonGrid, glm::ivec2{0, 2}, true, false);
float textHeight = mText->getFont()->getHeight();
@ -69,22 +69,22 @@ GuiTextEditPopup::GuiTextEditPopup(Window* window,
float aspectValue = 1.778f / Renderer::getScreenAspectRatio();
float width = Math::clamp(0.50f * aspectValue, 0.40f, 0.70f) * Renderer::getScreenWidth();
setSize(width, mTitle->getFont()->getHeight() + textHeight + mButtonGrid->getSize().y() +
mButtonGrid->getSize().y() / 2.0f);
setPosition((Renderer::getScreenWidth() - mSize.x()) / 2.0f,
(Renderer::getScreenHeight() - mSize.y()) / 2.0f);
setSize(width, mTitle->getFont()->getHeight() + textHeight + mButtonGrid->getSize().y +
mButtonGrid->getSize().y / 2.0f);
setPosition((Renderer::getScreenWidth() - mSize.x) / 2.0f,
(Renderer::getScreenHeight() - mSize.y) / 2.0f);
mText->startEditing();
}
void GuiTextEditPopup::onSizeChanged()
{
mBackground.fitTo(mSize, Vector3f::Zero(), Vector2f(-32.0f, -32.0f));
mBackground.fitTo(mSize, glm::vec3{}, glm::vec2{-32.0f, -32.0f});
mText->setSize(mSize.x() - 40, mText->getSize().y());
mText->setSize(mSize.x - 40.0f, mText->getSize().y);
// Update grid.
mGrid.setRowHeightPerc(0, mTitle->getFont()->getHeight() / mSize.y());
mGrid.setRowHeightPerc(2, mButtonGrid->getSize().y() / mSize.y());
mGrid.setRowHeightPerc(0, mTitle->getFont()->getHeight() / mSize.y);
mGrid.setRowHeightPerc(2, mButtonGrid->getSize().y / mSize.y);
mGrid.setSize(mSize);
}

7
es-core/src/math/Misc.h
View file

@ -10,10 +10,11 @@
#define ES_CORE_MATH_MISC_H
#include <algorithm>
#include <glm/ext/matrix_clip_space.hpp>
#include <glm/ext/matrix_transform.hpp>
#include <glm/trigonometric.hpp>
#define ES_PI (3.1415926535897932384626433832795028841971693993751058209749445923)
#define ES_RAD_TO_DEG(_x) ((_x) * (180.0 / ES_PI))
#define ES_DEG_TO_RAD(_x) ((_x) * (ES_PI / 180.0))
#include <glm/gtc/round.hpp>
namespace Math
{

53
es-core/src/renderers/Renderer.cpp
View file

@ -12,8 +12,6 @@
#include "Log.h"
#include "Settings.h"
#include "Shader_GL21.h"
#include "math/Transform4x4f.h"
#include "math/Vector2i.h"
#include "resources/ResourceManager.h"
#include <SDL2/SDL.h>
@ -326,28 +324,19 @@ namespace Renderer
if (!createWindow())
return false;
Transform4x4f projection = Transform4x4f::Identity();
Rect viewport = Rect(0, 0, 0, 0);
glm::mat4 projection{getIdentity()};
Rect viewport{0, 0, 0, 0};
switch (screenRotate) {
case 0: {
viewport.x = screenOffsetX;
viewport.y = screenOffsetY;
viewport.w = screenWidth;
viewport.h = screenHeight;
projection.orthoProjection(0.0f, static_cast<float>(screenWidth),
static_cast<float>(screenHeight), 0.0f, -1.0f, 1.0f);
break;
}
case 1: {
viewport.x = windowWidth - screenOffsetY - screenHeight;
viewport.y = screenOffsetX;
viewport.w = screenHeight;
viewport.h = screenWidth;
projection.orthoProjection(0.0f, static_cast<float>(screenHeight),
projection = glm::ortho(0.0f, static_cast<float>(screenHeight),
static_cast<float>(screenWidth), 0.0f, -1.0f, 1.0f);
projection.rotate(static_cast<float>(ES_DEG_TO_RAD(90)), { 0, 0, 1 });
projection.translate({ 0, screenHeight * -1.0f, 0 });
projection = glm::rotate(projection, glm::radians(90.0f), {0.0f, 0.0f, 1.0f});
projection = glm::translate(projection, {0.0f, screenHeight * -1.0f, 0.0f});
break;
}
case 2: {
@ -355,10 +344,11 @@ namespace Renderer
viewport.y = windowHeight - screenOffsetY - screenHeight;
viewport.w = screenWidth;
viewport.h = screenHeight;
projection.orthoProjection(0.0f, static_cast<float>(screenWidth),
projection = glm::ortho(0.0f, static_cast<float>(screenWidth),
static_cast<float>(screenHeight), 0.0f, -1.0f, 1.0f);
projection.rotate(static_cast<float>(ES_DEG_TO_RAD(180)), { 0, 0, 1 });
projection.translate({ screenWidth * -1.0f, screenHeight * -1.0f, 0 });
projection = glm::rotate(projection, glm::radians(180.0f), {0.0f, 0.0f, 1.0f});
projection =
glm::translate(projection, {screenWidth * -1.0f, screenHeight * -1.0f, 0.0f});
break;
}
case 3: {
@ -366,10 +356,19 @@ namespace Renderer
viewport.y = windowHeight - screenOffsetX - screenWidth;
viewport.w = screenHeight;
viewport.h = screenWidth;
projection.orthoProjection(0.0f, static_cast<float>(screenHeight),
projection = glm::ortho(0.0f, static_cast<float>(screenHeight),
static_cast<float>(screenWidth), 0.0f, -1.0f, 1.0f);
projection.rotate(static_cast<float>(ES_DEG_TO_RAD(270)), { 0, 0, 1 });
projection.translate({ screenWidth * -1.0f, 0, 0 });
projection = glm::rotate(projection, glm::radians(270.0f), {0.0f, 0.0f, 1.0f});
projection = glm::translate(projection, {screenWidth * -1.0f, 0.0f, 0.0f});
break;
}
default: {
viewport.x = screenOffsetX;
viewport.y = screenOffsetY;
viewport.w = screenWidth;
viewport.h = screenHeight;
projection = glm::ortho(0.0f, static_cast<float>(screenWidth),
static_cast<float>(screenHeight), 0.0f, -1.0f, 1.0f);
break;
}
}
@ -393,9 +392,9 @@ namespace Renderer
destroyWindow();
}
void pushClipRect(const Vector2i& _pos, const Vector2i& _size)
void pushClipRect(const glm::ivec2& _pos, const glm::ivec2& _size)
{
Rect box(_pos.x(), _pos.y(), _size.x(), _size.y());
Rect box(_pos.x, _pos.y, _size.x, _size.y);
if (box.w == 0)
box.w = screenWidth - box.x;
@ -466,7 +465,7 @@ namespace Renderer
const unsigned int _colorEnd,
bool horizontalGradient,
const float _opacity,
const Transform4x4f& _trans,
const glm::mat4& _trans,
const Blend::Factor _srcBlendFactor,
const Blend::Factor _dstBlendFactor)
{
@ -493,7 +492,7 @@ namespace Renderer
// Round vertices.
for (int i = 0; i < 4; i++)
vertices[i].pos.round();
vertices[i].pos = glm::round(vertices[i].pos);
if (_opacity < 1.0) {
vertices[0].shaders = SHADER_OPACITY;
@ -542,7 +541,7 @@ namespace Renderer
return nullptr;
};
const Transform4x4f getProjectionMatrix() { return mProjectionMatrix; }
const glm::mat4 getProjectionMatrix() { return mProjectionMatrix; }
SDL_Window* getSDLWindow() { return sdlWindow; }
int getWindowWidth() { return windowWidth; }
int getWindowHeight() { return windowHeight; }

27
es-core/src/renderers/Renderer.h
View file

@ -11,17 +11,13 @@
#include "Log.h"
#include "Shader_GL21.h"
#include "math/Transform4x4f.h"
#include "math/Vector2f.h"
#include "math/Misc.h"
#include <string>
#include <vector>
struct SDL_Window;
class Transform4x4f;
class Vector2i;
namespace Renderer
{
const unsigned int SHADER_DESATURATE = 1;
@ -52,7 +48,8 @@ namespace Renderer
static std::vector<Shader*> sShaderProgramVector;
static GLuint shaderFBO;
static Transform4x4f mProjectionMatrix;
static glm::mat4 mProjectionMatrix;
static constexpr glm::mat4 getIdentity() { return glm::mat4{1.0f}; }
#if !defined(NDEBUG)
#define GL_CHECK_ERROR(Function) (Function, _GLCheckError(#Function))
@ -115,14 +112,14 @@ namespace Renderer
struct Vertex {
Vertex() {}
Vertex(const Vector2f& _pos, const Vector2f& _tex, const unsigned int _col)
Vertex(const glm::vec2& _pos, const glm::vec2& _tex, const unsigned int _col)
: pos(_pos)
, tex(_tex)
, col(_col)
{
}
Vector2f pos;
Vector2f tex;
glm::vec2 pos;
glm::vec2 tex;
unsigned int col;
float saturation = 1.0;
float opacity = 1.0;
@ -131,7 +128,7 @@ namespace Renderer
bool init();
void deinit();
void pushClipRect(const Vector2i& _pos, const Vector2i& _size);
void pushClipRect(const glm::ivec2& _pos, const glm::ivec2& _size);
void popClipRect();
void drawRect(const float _x,
const float _y,
@ -141,7 +138,7 @@ namespace Renderer
const unsigned int _colorEnd,
bool horizontalGradient = false,
const float _opacity = 1.0,
const Transform4x4f& _trans = Transform4x4f::Identity(),
const glm::mat4& _trans = getIdentity(),
const Blend::Factor _srcBlendFactor = Blend::SRC_ALPHA,
const Blend::Factor _dstBlendFactor = Blend::ONE_MINUS_SRC_ALPHA);
SDL_Window* getSDLWindow();
@ -160,7 +157,7 @@ namespace Renderer
unsigned int convertABGRToRGBA(unsigned int color);
Shader* getShaderProgram(unsigned int shaderID);
const Transform4x4f getProjectionMatrix();
const glm::mat4 getProjectionMatrix();
void shaderPostprocessing(unsigned int shaders,
const Renderer::shaderParameters& parameters = shaderParameters(),
unsigned char* textureRGBA = nullptr);
@ -191,12 +188,12 @@ namespace Renderer
const Blend::Factor _dstBlendFactor = Blend::ONE_MINUS_SRC_ALPHA);
void drawTriangleStrips(const Vertex* _vertices,
const unsigned int _numVertices,
const Transform4x4f& _trans = Transform4x4f::Identity(),
const glm::mat4& _trans = getIdentity(),
const Blend::Factor _srcBlendFactor = Blend::SRC_ALPHA,
const Blend::Factor _dstBlendFactor = Blend::ONE_MINUS_SRC_ALPHA,
const shaderParameters& _parameters = shaderParameters());
void setProjection(const Transform4x4f& _projection);
void setMatrix(const Transform4x4f& _matrix);
void setProjection(const glm::mat4& _projection);
void setMatrix(const glm::mat4& _matrix);
void setViewport(const Rect& _viewport);
void setScissor(const Rect& _scissor);
void setSwapInterval();

15
es-core/src/renderers/Renderer_GL21.cpp
View file

@ -10,7 +10,6 @@
#include "Settings.h"
#include "Shader_GL21.h"
#include "math/Transform4x4f.h"
#include "renderers/Renderer.h"
namespace Renderer
@ -239,7 +238,7 @@ namespace Renderer
void drawTriangleStrips(const Vertex* _vertices,
const unsigned int _numVertices,
const Transform4x4f& _trans,
const glm::mat4& _trans,
const Blend::Factor _srcBlendFactor,
const Blend::Factor _dstBlendFactor,
const shaderParameters& _parameters)
@ -353,16 +352,16 @@ namespace Renderer
#endif
}
void setProjection(const Transform4x4f& _projection)
void setProjection(const glm::mat4& _projection)
{
GL_CHECK_ERROR(glMatrixMode(GL_PROJECTION));
GL_CHECK_ERROR(glLoadMatrixf(reinterpret_cast<const GLfloat*>(&_projection)));
}
void setMatrix(const Transform4x4f& _matrix)
void setMatrix(const glm::mat4& _matrix)
{
Transform4x4f matrix = _matrix;
matrix.round();
glm::mat4 matrix{_matrix};
matrix[3] = glm::round(matrix[3]);
GL_CHECK_ERROR(glMatrixMode(GL_MODELVIEW));
GL_CHECK_ERROR(glLoadMatrixf(reinterpret_cast<const GLfloat*>(&matrix)));
@ -448,7 +447,7 @@ namespace Renderer
if (parameters.fragmentSaturation < 1.0)
vertices[0].saturation = parameters.fragmentSaturation;
setMatrix(Transform4x4f::Identity());
setMatrix(getIdentity());
GLuint screenTexture = createTexture(Texture::RGBA, false, false, width, height, nullptr);
GL_CHECK_ERROR(glBindFramebuffer(GL_READ_FRAMEBUFFER, 0));
@ -475,7 +474,7 @@ namespace Renderer
GL_COLOR_BUFFER_BIT, GL_NEAREST));
// Apply/render the shaders.
drawTriangleStrips(vertices, 4, Transform4x4f::Identity(), Blend::SRC_ALPHA,
drawTriangleStrips(vertices, 4, getIdentity(), Blend::SRC_ALPHA,
Blend::ONE_MINUS_SRC_ALPHA, parameters);
// If textureRGBA has an address, it means that the output should go to this

11
es-core/src/renderers/Renderer_GLES10.cpp
View file

@ -10,7 +10,6 @@
#include "Log.h"
#include "Settings.h"
#include "math/Transform4x4f.h"
#include "renderers/Renderer.h"
#include <SDL2/SDL.h>
@ -185,7 +184,7 @@ namespace Renderer
void drawTriangleStrips(const Vertex* _vertices,
const unsigned int _numVertices,
const Transform4x4f& _trans,
const glm::mat4& _trans,
const Blend::Factor _srcBlendFactor,
const Blend::Factor _dstBlendFactor,
const shaderParameters& _parameters)
@ -200,16 +199,16 @@ namespace Renderer
GL_CHECK_ERROR(glDrawArrays(GL_TRIANGLE_STRIP, 0, _numVertices));
}
void setProjection(const Transform4x4f& _projection)
void setProjection(const glm::mat4& _projection)
{
GL_CHECK_ERROR(glMatrixMode(GL_PROJECTION));
GL_CHECK_ERROR(glLoadMatrixf((GLfloat*)&_projection));
}
void setMatrix(const Transform4x4f& _matrix)
void setMatrix(const glm::mat4& _matrix)
{
Transform4x4f matrix = _matrix;
matrix.round();
glm::mat4 matrix{_matrix};
matrix[3] = glm::round(matrix[3]);
GL_CHECK_ERROR(glMatrixMode(GL_MODELVIEW));
GL_CHECK_ERROR(glLoadMatrixf((GLfloat*)&matrix));

2
es-core/src/renderers/Shader_GL21.cpp
View file

@ -114,7 +114,7 @@ namespace Renderer
shaderDimValue = glGetUniformLocation(mProgramID, "dimValue");
}
void Renderer::Shader::setModelViewProjectionMatrix(Transform4x4f mvpMatrix)
void Renderer::Shader::setModelViewProjectionMatrix(glm::mat4 mvpMatrix)
{
if (shaderMVPMatrix != -1)
GL_CHECK_ERROR(glUniformMatrix4fv(shaderMVPMatrix, 1, GL_FALSE,

Some files were not shown because too many files have changed in this diff Show more