// SPDX-License-Identifier: MIT
//
// ES-DE Frontend
// GridComponent.h
//
// Grid, usable in both the system and gamelist views.
//
#ifndef ES_CORE_COMPONENTS_PRIMARY_GRID_COMPONENT_H
#define ES_CORE_COMPONENTS_PRIMARY_GRID_COMPONENT_H
#include "components/IList.h"
#include "components/primary/PrimaryComponent.h"
struct GridEntry {
std::shared_ptr<GuiComponent> item;
std::string imagePath;
std::string defaultImagePath;
};
template <typename T>
class GridComponent : public PrimaryComponent<T>, protected IList<GridEntry, T>
{
protected:
using List = IList<GridEntry, T>;
using List::mColumns;
using List::mCursor;
using List::mEntries;
using List::mLastCursor;
using List::mRows;
using List::mScrollVelocity;
using List::mSize;
public:
using Entry = typename IList<GridEntry, T>::Entry;
GridComponent();
~GridComponent();
void addEntry(Entry& entry, const std::shared_ptr<ThemeData>& theme);
void updateEntry(Entry& entry, const std::shared_ptr<ThemeData>& theme);
void onDemandTextureLoad() override;
void calculateLayout();
const int getColumnCount() const { return mColumns; }
const int getRowCount() const { return mRows; }
void setScrollVelocity(int velocity) { mScrollVelocity = velocity; }
void setSuppressTransitions(bool state) { mSuppressTransitions = state; }
void setCancelTransitionsCallback(const std::function<void()>& func) override
{
mCancelTransitionsCallback = func;
}
void setCursorChangedCallback(const std::function<void(CursorState state)>& func) override
{
mCursorChangedCallback = func;
}
int getCursor() override { return mCursor; }
const size_t getNumEntries() override { return mEntries.size(); }
const bool getFadeAbovePrimary() const override { return mFadeAbovePrimary; }
const LetterCase getLetterCase() const override { return mLetterCase; }
const LetterCase getLetterCaseAutoCollections() const override
{
return mLetterCaseAutoCollections;
}
const LetterCase getLetterCaseCustomCollections() const override
{
return mLetterCaseCustomCollections;
}
const bool getSystemNameSuffix() const override { return mSystemNameSuffix; }
const LetterCase getLetterCaseSystemNameSuffix() const override
{
return mLetterCaseSystemNameSuffix;
}
const std::string& getDefaultGridImage() const { return mDefaultImagePath; }
const std::string& getDefaultGridFolderImage() const { return mDefaultFolderImagePath; }
void setDefaultImage(std::string defaultImage) { mDefaultImagePath = defaultImage; }
void setDefaultFolderImage(std::string defaultImage) { mDefaultFolderImagePath = defaultImage; }
bool input(InputConfig* config, Input input) override;
void update(int deltaTime) override;
void render(const glm::mat4& parentTrans) override;
void applyTheme(const std::shared_ptr<ThemeData>& theme,
const std::string& view,
const std::string& element,
unsigned int properties) override;
private:
void onShowPrimary() override { mEntries.at(mCursor).data.item->resetComponent(); }
void onScroll() override
{
if (mGamelistView)
NavigationSounds::getInstance().playThemeNavigationSound(SCROLLSOUND);
else
NavigationSounds::getInstance().playThemeNavigationSound(SYSTEMBROWSESOUND);
}
void onCursorChanged(const CursorState& state) override;
bool isScrolling() const override { return List::isScrolling(); }
void stopScrolling() override
{
List::stopScrolling();
// Only finish the animation if we're in the gamelist view.
if (mGamelistView)
GuiComponent::finishAnimation(0);
}
const int getScrollingVelocity() override { return List::getScrollingVelocity(); }
void clear() override { List::clear(); }
const T& getSelected() const override { return List::getSelected(); }
const T& getNext() const override { return List::getNext(); }
const T& getPrevious() const override { return List::getPrevious(); }
const T& getFirst() const override { return List::getFirst(); }
const T& getLast() const override { return List::getLast(); }
bool setCursor(const T& obj) override
{
mLastCursor = mCursor;
return List::setCursor(obj);
}
bool remove(const T& obj) override { return List::remove(obj); }
int size() const override { return List::size(); }
enum class ImageFit {
CONTAIN,
FILL,
COVER
};
enum class SelectorLayer {
TOP,
MIDDLE,
BOTTOM
};
Renderer* mRenderer;
std::function<void()> mCancelTransitionsCallback;
std::function<void(CursorState state)> mCursorChangedCallback;
float mEntryOffset;
float mScrollPos;
float mTransitionFactor;
float mVisibleRows;
int mPreviousScrollVelocity;
bool mPositiveDirection;
bool mGamelistView;
bool mLayoutValid;
bool mWasScrolling;
bool mJustCalculatedLayout;
bool mSuppressTransitions;
float mHorizontalMargin;
float mVerticalMargin;
std::vector<std::string> mImageTypes;
std::string mDefaultImagePath;
std::string mDefaultFolderImagePath;
std::shared_ptr<ImageComponent> mDefaultImage;
glm::vec2 mItemSize;
float mItemScale;
glm::vec2 mItemSpacing;
bool mScaleInwards;
bool mFractionalRows;
bool mInstantItemTransitions;
bool mInstantRowTransitions;
float mUnfocusedItemOpacity;
float mUnfocusedItemSaturation;
bool mHasUnfocusedItemSaturation;
float mUnfocusedItemDimming;
ImageFit mImagefit;
glm::vec2 mImageCropPos;
bool mImageLinearInterpolation;
float mImageRelativeScale;
float mImageCornerRadius;
unsigned int mImageColor;
unsigned int mImageColorEnd;
bool mImageColorGradientHorizontal;
unsigned int mImageSelectedColor;
unsigned int mImageSelectedColorEnd;
bool mImageSelectedColorGradientHorizontal;
bool mHasImageSelectedColor;
float mImageBrightness;
float mImageSaturation;
std::unique_ptr<ImageComponent> mBackgroundImage;
std::string mBackgroundImagePath;
float mBackgroundRelativeScale;
float mBackgroundCornerRadius;
unsigned int mBackgroundColor;
unsigned int mBackgroundColorEnd;
bool mBackgroundColorGradientHorizontal;
bool mHasBackgroundColor;
std::unique_ptr<ImageComponent> mSelectorImage;
std::string mSelectorImagePath;
float mSelectorRelativeScale;
SelectorLayer mSelectorLayer;
float mSelectorCornerRadius;
unsigned int mSelectorColor;
unsigned int mSelectorColorEnd;
bool mSelectorColorGradientHorizontal;
bool mHasSelectorColor;
float mTextRelativeScale;
float mTextBackgroundCornerRadius;
unsigned int mTextColor;
unsigned int mTextBackgroundColor;
unsigned int mTextSelectedColor;
unsigned int mTextSelectedBackgroundColor;
bool mHasTextSelectedColor;
bool mTextHorizontalScrolling;
float mTextHorizontalScrollSpeed;
float mTextHorizontalScrollDelay;
float mTextHorizontalScrollGap;
std::shared_ptr<Font> mFont;
LetterCase mLetterCase;
LetterCase mLetterCaseAutoCollections;
LetterCase mLetterCaseCustomCollections;
float mLineSpacing;
bool mSystemNameSuffix;
LetterCase mLetterCaseSystemNameSuffix;
bool mFadeAbovePrimary;
};
template <typename T>
GridComponent<T>::GridComponent()
: IList<GridEntry, T> {IList<GridEntry, T>::LIST_SCROLL_STYLE_SLOW,
ListLoopType::LIST_PAUSE_AT_END}
, mRenderer {Renderer::getInstance()}
, mEntryOffset {0.0f}
, mScrollPos {0.0f}
, mTransitionFactor {1.0f}
, mVisibleRows {1.0f}
, mPreviousScrollVelocity {0}
, mPositiveDirection {false}
, mGamelistView {std::is_same_v<T, FileData*> ? true : false}
, mLayoutValid {false}
, mWasScrolling {false}
, mJustCalculatedLayout {false}
, mSuppressTransitions {false}
, mHorizontalMargin {0.0f}
, mVerticalMargin {0.0f}
, mItemSize {glm::vec2 {mRenderer->getScreenWidth() * 0.15f,
mRenderer->getScreenHeight() * 0.25f}}
, mItemScale {1.05f}
, mItemSpacing {0.0f, 0.0f}
, mScaleInwards {false}
, mFractionalRows {false}
, mInstantItemTransitions {false}
, mInstantRowTransitions {false}
, mUnfocusedItemOpacity {1.0f}
, mUnfocusedItemSaturation {1.0f}
, mHasUnfocusedItemSaturation {false}
, mUnfocusedItemDimming {1.0f}
, mImagefit {ImageFit::CONTAIN}
, mImageCropPos {0.5f, 0.5f}
, mImageLinearInterpolation {true}
, mImageRelativeScale {1.0f}
, mImageCornerRadius {0.0f}
, mImageColor {0xFFFFFFFF}
, mImageColorEnd {0xFFFFFFFF}
, mImageColorGradientHorizontal {true}
, mImageSelectedColor {0xFFFFFFFF}
, mImageSelectedColorEnd {0xFFFFFFFF}
, mImageSelectedColorGradientHorizontal {true}
, mHasImageSelectedColor {false}
, mImageBrightness {0.0f}
, mImageSaturation {1.0f}
, mBackgroundRelativeScale {1.0f}
, mBackgroundCornerRadius {0.0f}
, mBackgroundColor {0xFFFFFFFF}
, mBackgroundColorEnd {0xFFFFFFFF}
, mBackgroundColorGradientHorizontal {true}
, mHasBackgroundColor {false}
, mSelectorRelativeScale {1.0f}
, mSelectorLayer {SelectorLayer::TOP}
, mSelectorCornerRadius {0.0f}
, mSelectorColor {0xFFFFFFFF}
, mSelectorColorEnd {0xFFFFFFFF}
, mSelectorColorGradientHorizontal {true}
, mHasSelectorColor {false}
, mTextRelativeScale {1.0f}
, mTextBackgroundCornerRadius {0.0f}
, mTextColor {0x000000FF}
, mTextBackgroundColor {0xFFFFFF00}
, mTextSelectedColor {0x000000FF}
, mTextSelectedBackgroundColor {0xFFFFFF00}
, mHasTextSelectedColor {false}
, mTextHorizontalScrolling {false}
, mTextHorizontalScrollSpeed {1.0f}
, mTextHorizontalScrollDelay {3000.0f}
, mTextHorizontalScrollGap {1.5f}
, mLetterCase {LetterCase::NONE}
, mLetterCaseAutoCollections {LetterCase::UNDEFINED}
, mLetterCaseCustomCollections {LetterCase::UNDEFINED}
, mLineSpacing {1.5f}
, mSystemNameSuffix {true}
, mLetterCaseSystemNameSuffix {LetterCase::UPPERCASE}
, mFadeAbovePrimary {false}
{
}
template <typename T> GridComponent<T>::~GridComponent()
{
// Manually flush the background and selector images from the texture cache on destruction
// when running in debug mode, otherwise a complete system view reload would be needed to
// get these images updated. This is useful during theme development when using the Ctrl-r
// keyboard combination to reload the theme configuration.
if (Settings::getInstance()->getBool("Debug")) {
TextureResource::manualUnload(mBackgroundImagePath, false);
TextureResource::manualUnload(mSelectorImagePath, false);
}
}
template <typename T>
void GridComponent<T>::addEntry(Entry& entry, const std::shared_ptr<ThemeData>& theme)
{
const bool dynamic {mGamelistView};
if (entry.data.imagePath != "" &&
ResourceManager::getInstance().fileExists(entry.data.imagePath)) {
auto item = std::make_shared<ImageComponent>(false, dynamic);
item->setLinearInterpolation(mImageLinearInterpolation);
item->setMipmapping(true);
if (mImagefit == ImageFit::CONTAIN) {
item->setMaxSize(glm::round(mItemSize * mImageRelativeScale));
}
else if (mImagefit == ImageFit::FILL) {
item->setResize(glm::round(mItemSize * mImageRelativeScale));
}
else if (mImagefit == ImageFit::COVER) {
item->setCropPos(mImageCropPos);
item->setCroppedSize(glm::round(mItemSize * mImageRelativeScale));
}
item->setCornerRadius(mImageCornerRadius);
item->setImage(entry.data.imagePath);
if (mImageBrightness != 0.0)
item->setBrightness(mImageBrightness);
if (mImageSaturation != 1.0)
item->setSaturation(mImageSaturation);
if (mImageColor != 0xFFFFFFFF)
item->setColorShift(mImageColor);
if (mImageColorEnd != mImageColor) {
item->setColorShiftEnd(mImageColorEnd);
if (!mImageColorGradientHorizontal)
item->setColorGradientHorizontal(false);
}
item->setOrigin(0.5f, 0.5f);
item->setRotateByTargetSize(true);
entry.data.item = item;
}
else if (entry.data.defaultImagePath != "" &&
ResourceManager::getInstance().fileExists(entry.data.defaultImagePath)) {
if (!mGamelistView)
entry.data.imagePath = "";
if (mDefaultImage.get() == nullptr || !mGamelistView) {
mDefaultImage = std::make_shared<ImageComponent>(false, dynamic);
mDefaultImage->setLinearInterpolation(mImageLinearInterpolation);
mDefaultImage->setMipmapping(true);
if (mImagefit == ImageFit::CONTAIN) {
mDefaultImage->setMaxSize(glm::round(mItemSize * mImageRelativeScale));
}
else if (mImagefit == ImageFit::FILL) {
mDefaultImage->setResize(glm::round(mItemSize * mImageRelativeScale));
}
else if (mImagefit == ImageFit::COVER) {
mDefaultImage->setCropPos(mImageCropPos);
mDefaultImage->setCroppedSize(glm::round(mItemSize * mImageRelativeScale));
}
mDefaultImage->setCornerRadius(mImageCornerRadius);
mDefaultImage->setImage(entry.data.defaultImagePath);
if (mImageBrightness != 0.0)
mDefaultImage->setBrightness(mImageBrightness);
if (mImageSaturation != 1.0)
mDefaultImage->setSaturation(mImageSaturation);
if (mImageColor != 0xFFFFFFFF)
mDefaultImage->setColorShift(mImageColor);
if (mImageColorEnd != mImageColor) {
mDefaultImage->setColorShiftEnd(mImageColorEnd);
if (!mImageColorGradientHorizontal)
mDefaultImage->setColorGradientHorizontal(false);
}
mDefaultImage->setOrigin(0.5f, 0.5f);
mDefaultImage->setRotateByTargetSize(true);
}
// For the gamelist view the default image is applied in onDemandTextureLoad().
if (!mGamelistView)
entry.data.item = mDefaultImage;
}
else if (!mGamelistView) {
entry.data.imagePath = "";
}
if (!entry.data.item) {
// Always add the item text as fallback in case there is no image. This is also displayed
// when quick-jumping as textures are not loaded in this case.
auto text = std::make_shared<TextComponent>(
entry.name, mFont, 0x000000FF, Alignment::ALIGN_CENTER, Alignment::ALIGN_CENTER,
glm::ivec2 {0, 0}, glm::vec3 {0.0f, 0.0f, 0.0f}, mItemSize * mTextRelativeScale,
0x00000000, mLineSpacing, 1.0f, mTextHorizontalScrolling, mTextHorizontalScrollSpeed,
mTextHorizontalScrollDelay, mTextHorizontalScrollGap);
text->setOrigin(0.5f, 0.5f);
text->setBackgroundCornerRadius(mTextBackgroundCornerRadius);
text->setColor(mTextColor);
text->setBackgroundColor(mTextBackgroundColor);
text->setRenderBackground(true);
entry.data.item = text;
}
List::add(entry);
}
template <typename T>
void GridComponent<T>::updateEntry(Entry& entry, const std::shared_ptr<ThemeData>& theme)
{
if (entry.data.imagePath != "") {
const glm::vec3& calculatedItemPos {entry.data.item->getPosition()};
auto item = std::make_shared<ImageComponent>(false, true);
item->setLinearInterpolation(mImageLinearInterpolation);
item->setMipmapping(true);
if (mImagefit == ImageFit::CONTAIN) {
item->setMaxSize(glm::round(mItemSize * mImageRelativeScale));
}
else if (mImagefit == ImageFit::FILL) {
item->setResize(glm::round(mItemSize * mImageRelativeScale));
}
else if (mImagefit == ImageFit::COVER) {
item->setCropPos(mImageCropPos);
item->setCroppedSize(glm::round(mItemSize * mImageRelativeScale));
}
item->setCornerRadius(mImageCornerRadius);
item->setImage(entry.data.imagePath);
if (mImageBrightness != 0.0)
item->setBrightness(mImageBrightness);
if (mImageSaturation != 1.0)
item->setSaturation(mImageSaturation);
if (mImageColor != 0xFFFFFFFF)
item->setColorShift(mImageColor);
if (mImageColorEnd != mImageColor) {
item->setColorShiftEnd(mImageColorEnd);
if (!mImageColorGradientHorizontal)
item->setColorGradientHorizontal(false);
}
item->setOrigin(0.5f, 0.5f);
item->setRotateByTargetSize(true);
entry.data.item = item;
entry.data.item->setPosition(calculatedItemPos);
}
else {
return;
}
}
template <typename T> void GridComponent<T>::onDemandTextureLoad()
{
if constexpr (std::is_same_v<T, FileData*>) {
if (size() == 0)
return;
if (mImageTypes.empty())
mImageTypes.emplace_back("marquee");
const int visibleRows {static_cast<int>(std::ceil(mVisibleRows))};
const int columnPos {mCursor % mColumns};
int loadItems {mColumns * visibleRows};
const int numEntries {size()};
int startPos {mCursor};
int loadedItems {0};
if (mCursor / mColumns <= visibleRows - 1)
startPos = 0;
else
startPos = mCursor - (mColumns * (visibleRows - 1)) - columnPos;
if (mItemSpacing.y < mVerticalMargin) {
loadItems += mColumns;
if (!mFractionalRows) {
loadItems += mColumns;
startPos -= mColumns;
if (startPos < 0)
startPos = 0;
}
}
for (int i {startPos}; i < size(); ++i) {
if (loadedItems == loadItems)
break;
++loadedItems;
int cursor {i};
while (cursor < 0)
cursor += numEntries;
while (cursor >= numEntries)
cursor -= numEntries;
auto& entry = mEntries.at(cursor);
if (entry.data.imagePath == "") {
FileData* game {entry.object};
for (auto& imageType : mImageTypes) {
if (imageType == "marquee")
entry.data.imagePath = game->getMarqueePath();
else if (imageType == "cover")
entry.data.imagePath = game->getCoverPath();
else if (imageType == "backcover")
entry.data.imagePath = game->getBackCoverPath();
else if (imageType == "3dbox")
entry.data.imagePath = game->get3DBoxPath();
else if (imageType == "physicalmedia")
entry.data.imagePath = game->getPhysicalMediaPath();
else if (imageType == "screenshot")
entry.data.imagePath = game->getScreenshotPath();
else if (imageType == "titlescreen")
entry.data.imagePath = game->getTitleScreenPath();
else if (imageType == "miximage")
entry.data.imagePath = game->getMiximagePath();
else if (imageType == "fanart")
entry.data.imagePath = game->getFanArtPath();
else if (imageType == "none") // Display the game name as text.
break;
if (entry.data.imagePath != "")
break;
}
if (entry.data.imagePath == "")
entry.data.imagePath = entry.data.defaultImagePath;
auto theme = game->getSystem()->getTheme();
updateEntry(entry, theme);
}
}
}
}
template <typename T> void GridComponent<T>::calculateLayout()
{
assert(!mEntries.empty());
if (mItemScale < 1.0f) {
mHorizontalMargin = 0.0f;
mVerticalMargin = 0.0f;
}
else {
mHorizontalMargin =
((mItemSize.x * (mScaleInwards ? 1.0f : mItemScale)) - mItemSize.x) / 2.0f;
mVerticalMargin =
((mItemSize.y * (mScaleInwards ? 1.0f : mItemScale)) - mItemSize.y) / 2.0f;
}
int columnCount {0};
mColumns = 0;
mRows = 0;
float width {mHorizontalMargin * 2.0f};
while (1) {
width += mItemSize.x;
if (mColumns != 0)
width += mItemSpacing.x;
if (width > mSize.x)
break;
++mColumns;
}
if (mColumns == 0)
++mColumns;
for (auto& entry : mEntries) {
entry.data.item->setPosition(glm::vec3 {
mHorizontalMargin + (mItemSize.x * columnCount) + (mItemSize.x * 0.5f) +
mItemSpacing.x * columnCount,
mVerticalMargin + (mItemSize.y * mRows) + (mItemSize.y * 0.5f) + mItemSpacing.y * mRows,
0.0f});
if (columnCount == mColumns - 1) {
++mRows;
columnCount = 0;
continue;
}
++columnCount;
}
mVisibleRows = mSize.y / (mItemSize.y + mItemSpacing.y);
mVisibleRows -= (mVerticalMargin / mSize.y) * mVisibleRows * 2.0f;
mVisibleRows += (mItemSpacing.y / mSize.y) * mVisibleRows;
if (!mFractionalRows)
mVisibleRows = std::floor(mVisibleRows);
if (mVisibleRows == 0.0f)
++mVisibleRows;
mLayoutValid = true;
mJustCalculatedLayout = true;
}
template <typename T> bool GridComponent<T>::input(InputConfig* config, Input input)
{
if (size() > 0) {
if (input.value != 0) {
if (config->isMappedLike("left", input)) {
if (mCancelTransitionsCallback)
mCancelTransitionsCallback();
List::listInput(-1);
return true;
}
if (config->isMappedLike("right", input)) {
if (mCancelTransitionsCallback)
mCancelTransitionsCallback();
List::listInput(1);
return true;
}
if (config->isMappedLike("up", input)) {
if (mCursor >= mColumns) {
if (mCancelTransitionsCallback)
mCancelTransitionsCallback();
List::listInput(-mColumns);
}
return true;
}
if (config->isMappedLike("down", input)) {
const int columnModulus {size() % mColumns};
if (mCursor < size() - (columnModulus == 0 ? mColumns : columnModulus)) {
if (mCancelTransitionsCallback)
mCancelTransitionsCallback();
List::listInput(mColumns);
}
return true;
}
if (config->isMappedLike("lefttrigger", input)) {
if (getCursor() == 0)
return true;
if (mCancelTransitionsCallback)
mCancelTransitionsCallback();
return this->listFirstRow();
}
if (config->isMappedLike("righttrigger", input)) {
if (getCursor() == static_cast<int>(mEntries.size()) - 1)
return true;
if (mCancelTransitionsCallback)
mCancelTransitionsCallback();
return this->listLastRow();
}
}
else {
if (config->isMappedLike("left", input) || config->isMappedLike("right", input) ||
config->isMappedLike("up", input) || config->isMappedLike("down", input) ||
config->isMappedLike("lefttrigger", input) ||
config->isMappedLike("righttrigger", input)) {
if (isScrolling())
onCursorChanged(CursorState::CURSOR_STOPPED);
List::listInput(0);
}
}
}
return GuiComponent::input(config, input);
}
template <typename T> void GridComponent<T>::update(int deltaTime)
{
mEntries.at(mCursor).data.item->update(deltaTime);
List::listUpdate(deltaTime);
GuiComponent::update(deltaTime);
}
template <typename T> void GridComponent<T>::render(const glm::mat4& parentTrans)
{
if (mEntries.empty())
return;
glm::mat4 trans {parentTrans * List::getTransform()};
mRenderer->setMatrix(trans);
// In image debug mode, draw a green rectangle covering the entire grid area.
if (Settings::getInstance()->getBool("DebugImage"))
mRenderer->drawRect(0.0f, 0.0f, mSize.x, mSize.y, 0x00FF0033, 0x00FF0033);
// Clip to element boundaries.
glm::vec3 dim {mSize.x, mSize.y, 0.0f};
if (!mFractionalRows && mSize.y > mItemSize.y)
dim.y = mVisibleRows * (mItemSize.y + mItemSpacing.y) + (mVerticalMargin * 2.0f) -
mItemSpacing.y;
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;
mRenderer->pushClipRect(glm::ivec2 {static_cast<int>(trans[3].x), static_cast<int>(trans[3].y)},
glm::ivec2 {static_cast<int>(dim.x), static_cast<int>(dim.y)});
// We want to render the currently selected item last and before that the last selected
// item to avoid incorrect overlapping in case the element has been configured with for
// example large scaling or small or no margins between items.
std::vector<size_t> renderEntries;
const int currRow {static_cast<int>(std::ceil(mScrollPos))};
const int visibleRows {static_cast<int>(std::ceil(mVisibleRows))};
int startPos {0};
int loadItems {mColumns * visibleRows};
int loadedItems {0};
if (currRow > 0) {
if (GuiComponent::isAnimationPlaying(0) || mItemSpacing.y <= mVerticalMargin) {
loadItems += mColumns;
startPos = (currRow - 1) * mColumns;
}
else {
if (mFractionalRows)
startPos = (currRow - 1) * mColumns;
else
startPos = currRow * mColumns;
}
if (mItemSpacing.y < mVerticalMargin) {
if (GuiComponent::isAnimationPlaying(0)) {
loadItems += mColumns;
startPos -= mColumns;
if (startPos < 0)
startPos = 0;
}
}
}
if (!mFractionalRows && mItemSpacing.y < mVerticalMargin)
loadItems += mColumns;
for (int i {startPos}; i < size(); ++i) {
if (loadedItems == loadItems)
break;
++loadedItems;
if (i == mCursor || i == mLastCursor)
continue;
renderEntries.emplace_back(i);
}
if (mLastCursor >= startPos && mLastCursor < startPos + loadItems)
renderEntries.emplace_back(mLastCursor);
if (mLastCursor != mCursor)
renderEntries.emplace_back(mCursor);
float scale {1.0f};
float opacity {1.0f};
float saturation {1.0f};
float dimming {1.0f};
trans[3].y -= (mItemSize.y + mItemSpacing.y) * mScrollPos;
auto calculateOffsetPos = [this](const glm::vec3& itemPos, const glm::vec2& origin,
const float scale,
const float relativeScale) -> const glm::vec2 {
const float sizeX {mItemSize.x * scale * relativeScale};
const float sizeY {mItemSize.y * scale * relativeScale};
glm::vec2 position {0.0f, 0.0f};
position.x = itemPos.x - (mItemSize.x / 2.0f);
position.x -= ((mItemSize.x * scale) - mItemSize.x) * origin.x;
position.x += ((mItemSize.x * scale) - sizeX) / 2.0f;
position.y = itemPos.y - (mItemSize.y / 2.0f);
position.y -= ((mItemSize.y * scale) - mItemSize.y) * origin.y;
position.y += ((mItemSize.y * scale) - sizeY) / 2.0f;
return position;
};
auto selectorRenderFunc = [this, &trans, calculateOffsetPos](
std::vector<size_t>::const_iterator it, const glm::vec3& itemPos,
const float scale, glm::vec2 origin, glm::vec2 offset,
const float opacity) {
if (mSelectorImage == nullptr && !mHasSelectorColor)
return;
const glm::vec2 position {
calculateOffsetPos(itemPos, origin, scale, mSelectorRelativeScale)};
if (mSelectorImage != nullptr) {
mSelectorImage->setOrigin(0.0f, 0.0f);
mSelectorImage->setPosition(position.x, position.y);
mSelectorImage->setScale(scale);
mSelectorImage->setOpacity(opacity);
mSelectorImage->render(trans);
}
else if (mHasSelectorColor) {
// If a selector color is set but no selector image, then render a rectangle.
const float sizeX {mItemSize.x * scale * mSelectorRelativeScale};
const float sizeY {mItemSize.y * scale * mSelectorRelativeScale};
const glm::mat4 drawTrans {
glm::translate(trans, glm::round(glm::vec3 {position.x, position.y, 0.0f}))};
mRenderer->setMatrix(drawTrans);
mRenderer->drawRect(0.0f, 0.0f, sizeX, sizeY, mSelectorColor, mSelectorColorEnd,
mSelectorColorGradientHorizontal, opacity, 1.0f,
Renderer::BlendFactor::SRC_ALPHA,
Renderer::BlendFactor::ONE_MINUS_SRC_ALPHA, mSelectorCornerRadius);
}
};
for (auto it = renderEntries.cbegin(); it != renderEntries.cend(); ++it) {
float metadataOpacity {1.0f};
bool cursorEntry {false};
if constexpr (std::is_same_v<T, FileData*>) {
// If a game is marked as hidden, lower the opacity a lot.
// If a game is marked to not be counted, lower the opacity a moderate amount.
if (mEntries.at(*it).object->getHidden())
metadataOpacity = 0.4f;
else if (!mEntries.at(*it).object->getCountAsGame())
metadataOpacity = 0.7f;
}
opacity = mUnfocusedItemOpacity * metadataOpacity;
if (mHasUnfocusedItemSaturation)
saturation = mUnfocusedItemSaturation;
dimming = mUnfocusedItemDimming;
if (*it == static_cast<size_t>(mCursor)) {
cursorEntry = true;
scale = glm::mix(1.0f, mItemScale, mTransitionFactor);
opacity = glm::mix(mUnfocusedItemOpacity * metadataOpacity, 1.0f * metadataOpacity,
mTransitionFactor);
if (mHasUnfocusedItemSaturation)
saturation =
glm::mix(mUnfocusedItemSaturation, mImageSaturation, mTransitionFactor);
dimming = glm::mix(mUnfocusedItemDimming, 1.0f, mTransitionFactor);
}
else if (*it == static_cast<size_t>(mLastCursor)) {
scale = glm::mix(mItemScale, 1.0f, mTransitionFactor);
opacity = glm::mix(1.0f * metadataOpacity, mUnfocusedItemOpacity * metadataOpacity,
mTransitionFactor);
if (mHasUnfocusedItemSaturation)
saturation =
glm::mix(mImageSaturation, mUnfocusedItemSaturation, mTransitionFactor);
dimming = glm::mix(1.0f, mUnfocusedItemDimming, mTransitionFactor);
}
const glm::vec3 itemPos {mEntries.at(*it).data.item->getPosition()};
glm::vec2 originInwards {0.5f, 0.5f};
glm::vec2 offsetInwards {0.0f, 0.0f};
if (mScaleInwards && scale != 1.0f) {
if (static_cast<int>(*it) < mColumns) {
// First row.
originInwards.y = 0.0f;
offsetInwards.y = mItemSize.y / 2.0f;
}
if ((itemPos.y + (mItemSize.y / 2.0f) * mItemScale) > mSize.y) {
// Scaled image won't fit vertically at the bottom.
originInwards.y = 1.0f;
offsetInwards.y = -(mItemSize.y / 2.0f);
}
if (static_cast<int>(*it) % mColumns == 0) {
// Leftmost column.
originInwards.x = 0.0f;
offsetInwards.x = mItemSize.x / 2.0f;
}
if (static_cast<int>(*it) % mColumns == mColumns - 1) {
// Rightmost column.
originInwards.x = 1.0f;
offsetInwards.x = -(mItemSize.x / 2.0f);
}
const bool textEntry {mEntries.at(*it).data.imagePath.empty() &&
mEntries.at(*it).data.defaultImagePath.empty()};
const glm::vec2 position {
calculateOffsetPos(itemPos, originInwards, scale,
(textEntry ? mTextRelativeScale : mImageRelativeScale))};
const glm::vec2 offset {textEntry ? glm::vec2 {0.0f, 0.0f} :
mItemSize * mImageRelativeScale * scale};
if (textEntry)
mEntries.at(*it).data.item->setOrigin(0.0f, 0.0f);
mEntries.at(*it).data.item->setPosition(position.x, position.y);
mEntries.at(*it).data.item->setPosition(position.x + (offset.x / 2.0f),
position.y + (offset.y / 2.0f));
}
if (cursorEntry && mSelectorLayer == SelectorLayer::BOTTOM)
selectorRenderFunc(it, itemPos, scale, originInwards, offsetInwards, opacity);
glm::vec2 backgroundPos {
calculateOffsetPos(itemPos, originInwards, scale, mBackgroundRelativeScale)};
if (mBackgroundImage != nullptr) {
if (mScaleInwards && scale != 1.0f) {
mBackgroundImage->setOrigin(0.0f, 0.0f);
mBackgroundImage->setPosition(backgroundPos.x, backgroundPos.y);
}
else {
mBackgroundImage->setPosition(mEntries.at(*it).data.item->getPosition());
}
mBackgroundImage->setScale(scale);
mBackgroundImage->setOpacity(opacity);
if (mHasUnfocusedItemSaturation)
mBackgroundImage->setSaturation(saturation);
if (mUnfocusedItemDimming != 1.0f)
mBackgroundImage->setDimming(dimming);
mBackgroundImage->render(trans);
if (mScaleInwards && scale != 1.0f)
mBackgroundImage->setOrigin(0.5f, 0.5f);
}
else if (mHasBackgroundColor) {
// If a background color is set but no background image, then render a rectangle.
const float sizeX {mItemSize.x * scale * mBackgroundRelativeScale};
const float sizeY {mItemSize.y * scale * mBackgroundRelativeScale};
const glm::mat4 drawTrans {glm::translate(
trans, glm::round(glm::vec3 {backgroundPos.x, backgroundPos.y, 0.0f}))};
mRenderer->setMatrix(drawTrans);
mRenderer->drawRect(
0.0f, 0.0f, sizeX, sizeY, mBackgroundColor, mBackgroundColorEnd,
mBackgroundColorGradientHorizontal, opacity, 1.0f, Renderer::BlendFactor::SRC_ALPHA,
Renderer::BlendFactor::ONE_MINUS_SRC_ALPHA, mBackgroundCornerRadius);
}
if (cursorEntry && mSelectorLayer == SelectorLayer::MIDDLE)
selectorRenderFunc(it, itemPos, scale, originInwards, offsetInwards, opacity);
mEntries.at(*it).data.item->setScale(scale);
mEntries.at(*it).data.item->setOpacity(opacity);
if (mHasUnfocusedItemSaturation)
mEntries.at(*it).data.item->setSaturation(saturation);
if (mUnfocusedItemDimming != 1.0f)
mEntries.at(*it).data.item->setDimming(dimming);
if (cursorEntry && (mHasTextSelectedColor || mHasImageSelectedColor)) {
if (mHasTextSelectedColor && mEntries.at(*it).data.imagePath == "" &&
mEntries.at(*it).data.defaultImagePath == "") {
mEntries.at(*it).data.item->setColor(mTextSelectedColor);
if (mTextSelectedBackgroundColor != mTextBackgroundColor)
mEntries.at(*it).data.item->setBackgroundColor(mTextSelectedBackgroundColor);
mEntries.at(*it).data.item->render(trans);
mEntries.at(*it).data.item->setColor(mTextColor);
if (mTextSelectedBackgroundColor != mTextBackgroundColor)
mEntries.at(*it).data.item->setBackgroundColor(mTextBackgroundColor);
}
else if (mHasImageSelectedColor) {
mEntries.at(*it).data.item->setColorShift(mImageSelectedColor);
if (mImageSelectedColorEnd != mImageSelectedColor)
mEntries.at(*it).data.item->setColorShiftEnd(mImageSelectedColorEnd);
if (mImageSelectedColorGradientHorizontal != mImageColorGradientHorizontal)
mEntries.at(*it).data.item->setColorGradientHorizontal(
mImageSelectedColorGradientHorizontal);
mEntries.at(*it).data.item->render(trans);
if (mImageSelectedColorGradientHorizontal != mImageColorGradientHorizontal)
mEntries.at(*it).data.item->setColorGradientHorizontal(
mImageColorGradientHorizontal);
mEntries.at(*it).data.item->setColorShift(mImageColor);
if (mImageColorEnd != mImageColor)
mEntries.at(*it).data.item->setColorShiftEnd(mImageColorEnd);
}
else {
mEntries.at(*it).data.item->render(trans);
}
}
else {
mEntries.at(*it).data.item->render(trans);
}
mEntries.at(*it).data.item->setScale(1.0f);
mEntries.at(*it).data.item->setOpacity(1.0f);
if (cursorEntry && mSelectorLayer == SelectorLayer::TOP)
selectorRenderFunc(it, itemPos, scale, originInwards, offsetInwards, opacity);
if (mScaleInwards && scale != 1.0f) {
mEntries.at(*it).data.item->setOrigin(0.5f, 0.5f);
mEntries.at(*it).data.item->setPosition(itemPos);
}
}
mRenderer->popClipRect();
GuiComponent::renderChildren(trans);
}
template <typename T>
void GridComponent<T>::applyTheme(const std::shared_ptr<ThemeData>& theme,
const std::string& view,
const std::string& element,
unsigned int properties)
{
mSize.x = Renderer::getScreenWidth();
mSize.y = Renderer::getScreenHeight() * 0.8f;
GuiComponent::mPosition.x = 0.0f;
GuiComponent::mPosition.y = Renderer::getScreenHeight() * 0.1f;
mItemSpacing.x = ((mItemSize.x * mItemScale) - mItemSize.x) / 2.0f;
mItemSpacing.y = ((mItemSize.y * mItemScale) - mItemSize.y) / 2.0f;
mHorizontalMargin = ((mItemSize.x * mItemScale) - mItemSize.x) / 2.0f;
mVerticalMargin = ((mItemSize.y * mItemScale) - mItemSize.y) / 2.0f;
GuiComponent::applyTheme(theme, view, element, properties);
using namespace ThemeFlags;
const ThemeData::ThemeElement* elem {theme->getElement(view, element, "grid")};
if (!elem)
return;
if (mGamelistView && properties && elem->has("imageType")) {
const std::vector<std::string> supportedImageTypes {
"marquee", "cover", "backcover", "3dbox", "physicalmedia",
"screenshot", "titlescreen", "miximage", "fanart", "none"};
std::string imageTypesString {elem->get<std::string>("imageType")};
for (auto& character : imageTypesString) {
if (std::isspace(character))
character = ',';
}
imageTypesString = Utils::String::replace(imageTypesString, ",,", ",");
mImageTypes = Utils::String::delimitedStringToVector(imageTypesString, ",");
// Only allow two imageType entries due to performance reasons.
if (mImageTypes.size() > 2)
mImageTypes.erase(mImageTypes.begin() + 2, mImageTypes.end());
if (mImageTypes.empty()) {
LOG(LogWarning) << "GridComponent: Invalid theme configuration, property \"imageType\" "
"for element \""
<< element.substr(5) << "\" contains no values";
}
for (std::string& type : mImageTypes) {
if (std::find(supportedImageTypes.cbegin(), supportedImageTypes.cend(), type) ==
supportedImageTypes.cend()) {
LOG(LogWarning)
<< "GridComponent: Invalid theme configuration, property \"imageType\" "
"for element \""
<< element.substr(5) << "\" defined as \"" << type << "\"";
mImageTypes.clear();
break;
}
}
if (mImageTypes.size() == 2 && mImageTypes.front() == mImageTypes.back()) {
LOG(LogError) << "GridComponent: Invalid theme configuration, property \"imageType\" "
"for element \""
<< element.substr(5) << "\" contains duplicate values";
mImageTypes.clear();
}
}
mFractionalRows = (elem->has("fractionalRows") && elem->get<bool>("fractionalRows"));
if (elem->has("itemSize")) {
const glm::vec2& itemSize {elem->get<glm::vec2>("itemSize")};
if (!(itemSize.x == -1 && itemSize.y == -1)) {
if (itemSize.x == -1) {
mItemSize.y =
glm::clamp(itemSize.y, 0.05f, 1.0f) * (mRenderer->getIsVerticalOrientation() ?
mRenderer->getScreenWidth() :
mRenderer->getScreenHeight());
mItemSize.x = mItemSize.y;
}
else if (itemSize.y == -1) {
mItemSize.x = glm::clamp(itemSize.x, 0.05f, 1.0f) * mRenderer->getScreenWidth();
mItemSize.y = mItemSize.x;
}
else {
mItemSize = glm::clamp(itemSize, 0.05f, 1.0f) *
glm::vec2(mRenderer->getScreenWidth(), mRenderer->getScreenHeight());
}
}
}
if (elem->has("itemScale"))
mItemScale = glm::clamp(elem->get<float>("itemScale"), 0.5f, 2.0f);
if (elem->has("imageRelativeScale"))
mImageRelativeScale = glm::clamp(elem->get<float>("imageRelativeScale"), 0.2f, 1.0f);
mScaleInwards =
(mItemScale > 1.0f && elem->has("scaleInwards") && elem->get<bool>("scaleInwards"));
if (elem->has("imageFit")) {
const std::string& imageFit {elem->get<std::string>("imageFit")};
if (imageFit == "contain") {
mImagefit = ImageFit::CONTAIN;
}
else if (imageFit == "fill") {
mImagefit = ImageFit::FILL;
}
else if (imageFit == "cover") {
mImagefit = ImageFit::COVER;
if (elem->has("imageCropPos"))
mImageCropPos = glm::clamp(elem->get<glm::vec2>("imageCropPos"), 0.0f, 1.0f);
}
else {
mImagefit = ImageFit::CONTAIN;
LOG(LogWarning) << "GridComponent: Invalid theme configuration, property "
"\"imageFit\" for element \""
<< element.substr(5) << "\" defined as \"" << imageFit << "\"";
}
}
if (elem->has("imageInterpolation")) {
const std::string& imageInterpolation {elem->get<std::string>("imageInterpolation")};
if (imageInterpolation == "linear") {
mImageLinearInterpolation = true;
}
else if (imageInterpolation == "nearest") {
mImageLinearInterpolation = false;
}
else {
mImageLinearInterpolation = true;
LOG(LogWarning) << "GridComponent: Invalid theme configuration, property "
"\"imageInterpolation\" for element \""
<< element.substr(5) << "\" defined as \"" << imageInterpolation
<< "\"";
}
}
if (elem->has("backgroundRelativeScale"))
mBackgroundRelativeScale =
glm::clamp(elem->get<float>("backgroundRelativeScale"), 0.2f, 1.0f);
mHasBackgroundColor = false;
if (elem->has("backgroundColor")) {
mHasBackgroundColor = true;
mBackgroundColor = elem->get<unsigned int>("backgroundColor");
mBackgroundColorEnd = mBackgroundColor;
}
if (elem->has("backgroundColorEnd"))
mBackgroundColorEnd = elem->get<unsigned int>("backgroundColorEnd");
if (elem->has("backgroundGradientType")) {
const std::string& gradientType {elem->get<std::string>("backgroundGradientType")};
if (gradientType == "horizontal") {
mBackgroundColorGradientHorizontal = true;
}
else if (gradientType == "vertical") {
mBackgroundColorGradientHorizontal = false;
}
else {
mBackgroundColorGradientHorizontal = true;
LOG(LogWarning) << "GridComponent: Invalid theme configuration, property "
"\"backgroundGradientType\" for element \""
<< element.substr(5) << "\" defined as \"" << gradientType << "\"";
}
}
if (elem->has("selectorRelativeScale"))
mSelectorRelativeScale = glm::clamp(elem->get<float>("selectorRelativeScale"), 0.2f, 1.0f);
mHasSelectorColor = false;
if (elem->has("selectorColor")) {
mHasSelectorColor = true;
mSelectorColor = elem->get<unsigned int>("selectorColor");
mSelectorColorEnd = mSelectorColor;
}
if (elem->has("selectorColorEnd"))
mSelectorColorEnd = elem->get<unsigned int>("selectorColorEnd");
if (elem->has("selectorGradientType")) {
const std::string& gradientType {elem->get<std::string>("selectorGradientType")};
if (gradientType == "horizontal") {
mSelectorColorGradientHorizontal = true;
}
else if (gradientType == "vertical") {
mSelectorColorGradientHorizontal = false;
}
else {
mSelectorColorGradientHorizontal = true;
LOG(LogWarning) << "GridComponent: Invalid theme configuration, property "
"\"selectorGradientType\" for element \""
<< element.substr(5) << "\" defined as \"" << gradientType << "\"";
}
}
if (elem->has("backgroundImage")) {
const std::string& path {elem->get<std::string>("backgroundImage")};
if (Utils::FileSystem::exists(path) && !Utils::FileSystem::isDirectory(path)) {
mBackgroundImage = std::make_unique<ImageComponent>(false, false);
mBackgroundImage->setLinearInterpolation(true);
mBackgroundImage->setMipmapping(true);
mBackgroundImage->setResize(mItemSize * mBackgroundRelativeScale);
mBackgroundImage->setOrigin(0.5f, 0.5f);
if (mHasBackgroundColor) {
mBackgroundImage->setColorShift(mBackgroundColor);
if (mBackgroundColor != mBackgroundColorEnd) {
mBackgroundImage->setColorShiftEnd(mBackgroundColorEnd);
if (!mBackgroundColorGradientHorizontal)
mBackgroundImage->setColorGradientHorizontal(false);
}
}
float backgroundCornerRadius {0.0f};
if (elem->has("backgroundCornerRadius")) {
backgroundCornerRadius =
glm::clamp(elem->get<float>("backgroundCornerRadius"), 0.0f, 0.5f) *
(mItemScale >= 1.0f ? mItemScale : 1.0f) * mRenderer->getScreenWidth();
}
mBackgroundImage->setCornerRadius(backgroundCornerRadius);
mBackgroundImage->setImage(elem->get<std::string>("backgroundImage"));
mBackgroundImagePath = path;
}
else {
LOG(LogWarning) << "GridComponent: Invalid theme configuration, property "
"\"backgroundImage\" for element \""
<< element.substr(5) << "\", image does not exist: \"" << path << "\"";
}
}
else if (elem->has("backgroundCornerRadius")) {
mBackgroundCornerRadius =
glm::clamp(elem->get<float>("backgroundCornerRadius"), 0.0f, 0.5f) *
(mItemScale >= 1.0f ? mItemScale : 1.0f) * mRenderer->getScreenWidth();
}
if (elem->has("selectorImage")) {
const std::string& path {elem->get<std::string>("selectorImage")};
if (Utils::FileSystem::exists(path) && !Utils::FileSystem::isDirectory(path)) {
mSelectorImage = std::make_unique<ImageComponent>(false, false);
mSelectorImage->setLinearInterpolation(true);
mSelectorImage->setMipmapping(true);
mSelectorImage->setResize(mItemSize * mSelectorRelativeScale);
mSelectorImage->setOrigin(0.5f, 0.5f);
if (mHasSelectorColor) {
mSelectorImage->setColorShift(mSelectorColor);
if (mBackgroundColor != mBackgroundColorEnd) {
mSelectorImage->setColorShiftEnd(mSelectorColorEnd);
if (!mSelectorColorGradientHorizontal)
mSelectorImage->setColorGradientHorizontal(false);
}
}
float selectorCornerRadius {0.0f};
if (elem->has("selectorCornerRadius")) {
selectorCornerRadius =
glm::clamp(elem->get<float>("selectorCornerRadius"), 0.0f, 0.5f) *
(mItemScale >= 1.0f ? mItemScale : 1.0f) * mRenderer->getScreenWidth();
}
mSelectorImage->setCornerRadius(selectorCornerRadius);
mSelectorImage->setImage(elem->get<std::string>("selectorImage"));
mSelectorImagePath = path;
}
else {
LOG(LogWarning) << "GridComponent: Invalid theme configuration, property "
"\"selectorImage\" for element \""
<< element.substr(5) << "\", image does not exist: \"" << path << "\"";
}
}
else if (elem->has("selectorCornerRadius")) {
mSelectorCornerRadius = glm::clamp(elem->get<float>("selectorCornerRadius"), 0.0f, 0.5f) *
(mItemScale >= 1.0f ? mItemScale : 1.0f) *
mRenderer->getScreenWidth();
}
if (elem->has("selectorLayer")) {
const std::string& selectorLayer {elem->get<std::string>("selectorLayer")};
if (selectorLayer == "top") {
mSelectorLayer = SelectorLayer::TOP;
}
else if (selectorLayer == "middle") {
mSelectorLayer = SelectorLayer::MIDDLE;
}
else if (selectorLayer == "bottom") {
mSelectorLayer = SelectorLayer::BOTTOM;
}
else {
mSelectorLayer = SelectorLayer::TOP;
LOG(LogWarning) << "GridComponent: Invalid theme configuration, property "
"\"selectorLayer\" for element \""
<< element.substr(5) << "\" defined as \"" << selectorLayer << "\"";
}
}
if (elem->has("itemTransitions")) {
const std::string& itemTransitions {elem->get<std::string>("itemTransitions")};
if (itemTransitions == "animate") {
mInstantItemTransitions = false;
}
else if (itemTransitions == "instant") {
mInstantItemTransitions = true;
}
else {
mInstantItemTransitions = false;
LOG(LogWarning) << "GridComponent: Invalid theme configuration, property "
"\"itemTransitions\" for element \""
<< element.substr(5) << "\" defined as \"" << itemTransitions << "\"";
}
}
if (elem->has("rowTransitions")) {
const std::string& rowTransitions {elem->get<std::string>("rowTransitions")};
if (rowTransitions == "animate") {
mInstantRowTransitions = false;
}
else if (rowTransitions == "instant") {
mInstantRowTransitions = true;
}
else {
mInstantRowTransitions = false;
LOG(LogWarning) << "GridComponent: Invalid theme configuration, property "
"\"rowTransitions\" for element \""
<< element.substr(5) << "\" defined as \"" << rowTransitions << "\"";
}
}
// If itemSpacing is not defined, then it's automatically calculated so that scaled items
// don't overlap. If the property is present but one axis is defined as -1 then set this
// axis to the same pixel value as the other axis.
if (elem->has("itemSpacing")) {
const glm::vec2& itemSpacing {elem->get<glm::vec2>("itemSpacing")};
if (itemSpacing.x == -1 && itemSpacing.y == -1) {
mItemSpacing = {0.0f, 0.0f};
}
else if (itemSpacing.x == -1) {
mItemSpacing.y = glm::clamp(itemSpacing.y, 0.0f, 0.1f) * mRenderer->getScreenHeight();
mItemSpacing.x = mItemSpacing.y;
}
else if (itemSpacing.y == -1) {
mItemSpacing.x = glm::clamp(itemSpacing.x, 0.0f, 0.1f) * mRenderer->getScreenWidth();
mItemSpacing.y = mItemSpacing.x;
}
else {
mItemSpacing = glm::clamp(itemSpacing, 0.0f, 0.1f) *
glm::vec2(Renderer::getScreenWidth(), Renderer::getScreenHeight());
}
}
else if (mItemScale < 1.0f) {
mItemSpacing = glm::vec2 {0.0f, 0.0f};
}
else {
mItemSpacing.x = ((mItemSize.x * mItemScale) - mItemSize.x) / 2.0f;
mItemSpacing.y = ((mItemSize.y * mItemScale) - mItemSize.y) / 2.0f;
}
if (elem->has("imageCornerRadius"))
mImageCornerRadius = glm::clamp(elem->get<float>("imageCornerRadius"), 0.0f, 0.5f) *
(mItemScale >= 1.0f ? mItemScale : 1.0f) * mRenderer->getScreenWidth();
if (elem->has("imageColor")) {
mImageColor = elem->get<unsigned int>("imageColor");
mImageColorEnd = mImageColor;
}
if (elem->has("imageColorEnd"))
mImageColorEnd = elem->get<unsigned int>("imageColorEnd");
if (elem->has("imageGradientType")) {
const std::string& gradientType {elem->get<std::string>("imageGradientType")};
if (gradientType == "horizontal") {
mImageColorGradientHorizontal = true;
}
else if (gradientType == "vertical") {
mImageColorGradientHorizontal = false;
}
else {
mImageColorGradientHorizontal = true;
LOG(LogWarning) << "GridComponent: Invalid theme configuration, property "
"\"imageGradientType\" for element \""
<< element.substr(5) << "\" defined as \"" << gradientType << "\"";
}
}
mImageSelectedColor = mImageColor;
mImageSelectedColorEnd = mImageColorEnd;
if (elem->has("imageSelectedColor")) {
mImageSelectedColor = elem->get<unsigned int>("imageSelectedColor");
mImageSelectedColorEnd = mImageSelectedColor;
mHasImageSelectedColor = true;
}
if (elem->has("imageSelectedColorEnd")) {
mImageSelectedColorEnd = elem->get<unsigned int>("imageSelectedColorEnd");
mHasImageSelectedColor = true;
}
if (elem->has("imageSelectedGradientType")) {
const std::string& gradientType {elem->get<std::string>("imageSelectedGradientType")};
if (gradientType == "horizontal") {
mImageSelectedColorGradientHorizontal = true;
}
else if (gradientType == "vertical") {
mImageSelectedColorGradientHorizontal = false;
}
else {
mImageSelectedColorGradientHorizontal = true;
LOG(LogWarning) << "GridComponent: Invalid theme configuration, property "
"\"imageSelectedGradientType\" for element \""
<< element.substr(5) << "\" defined as \"" << gradientType << "\"";
}
}
if (elem->has("imageBrightness"))
mImageBrightness = glm::clamp(elem->get<float>("imageBrightness"), -2.0f, 2.0f);
if (elem->has("imageSaturation"))
mImageSaturation = glm::clamp(elem->get<float>("imageSaturation"), 0.0f, 1.0f);
if (elem->has("unfocusedItemOpacity"))
mUnfocusedItemOpacity = glm::clamp(elem->get<float>("unfocusedItemOpacity"), 0.1f, 1.0f);
if (elem->has("unfocusedItemSaturation")) {
mUnfocusedItemSaturation =
glm::clamp(elem->get<float>("unfocusedItemSaturation"), 0.0f, 1.0f);
mHasUnfocusedItemSaturation = true;
}
if (elem->has("unfocusedItemDimming"))
mUnfocusedItemDimming = glm::clamp(elem->get<float>("unfocusedItemDimming"), 0.0f, 1.0f);
mFont = Font::getFromTheme(elem, properties, mFont);
if (elem->has("textRelativeScale"))
mTextRelativeScale = glm::clamp(elem->get<float>("textRelativeScale"), 0.2f, 1.0f);
if (elem->has("textBackgroundCornerRadius")) {
mTextBackgroundCornerRadius =
glm::clamp(elem->get<float>("textBackgroundCornerRadius"), 0.0f, 0.5f) *
(mItemScale >= 1.0f ? mItemScale : 1.0f) * mRenderer->getScreenWidth();
}
if (elem->has("textColor"))
mTextColor = elem->get<unsigned int>("textColor");
if (elem->has("textBackgroundColor"))
mTextBackgroundColor = elem->get<unsigned int>("textBackgroundColor");
mTextSelectedColor = mTextColor;
mTextSelectedBackgroundColor = mTextBackgroundColor;
if (elem->has("textSelectedColor")) {
mTextSelectedColor = elem->get<unsigned int>("textSelectedColor");
mHasTextSelectedColor = true;
}
if (elem->has("textSelectedBackgroundColor")) {
mTextSelectedBackgroundColor = elem->get<unsigned int>("textSelectedBackgroundColor");
mHasTextSelectedColor = true;
}
if (elem->has("textHorizontalScrolling"))
mTextHorizontalScrolling = elem->get<bool>("textHorizontalScrolling");
if (elem->has("textHorizontalScrollSpeed")) {
mTextHorizontalScrollSpeed =
glm::clamp(elem->get<float>("textHorizontalScrollSpeed"), 0.1f, 10.0f);
}
if (elem->has("textHorizontalScrollDelay")) {
mTextHorizontalScrollDelay =
glm::clamp(elem->get<float>("textHorizontalScrollDelay"), 0.0f, 10.0f) * 1000.0f;
}
if (elem->has("textHorizontalScrollGap")) {
mTextHorizontalScrollGap =
glm::clamp(elem->get<float>("textHorizontalScrollGap"), 0.1f, 5.0f);
}
if (elem->has("lineSpacing"))
mLineSpacing = glm::clamp(elem->get<float>("lineSpacing"), 0.5f, 3.0f);
if (elem->has("letterCase")) {
const std::string& letterCase {elem->get<std::string>("letterCase")};
if (letterCase == "uppercase") {
mLetterCase = LetterCase::UPPERCASE;
}
else if (letterCase == "lowercase") {
mLetterCase = LetterCase::LOWERCASE;
}
else if (letterCase == "capitalize") {
mLetterCase = LetterCase::CAPITALIZE;
}
else if (letterCase != "none") {
LOG(LogWarning) << "GridComponent: Invalid theme configuration, property "
"\"letterCase\" for element \""
<< element.substr(5) << "\" defined as \"" << letterCase << "\"";
}
}
if (elem->has("letterCaseAutoCollections")) {
const std::string& letterCase {elem->get<std::string>("letterCaseAutoCollections")};
if (letterCase == "uppercase") {
mLetterCaseAutoCollections = LetterCase::UPPERCASE;
}
else if (letterCase == "lowercase") {
mLetterCaseAutoCollections = LetterCase::LOWERCASE;
}
else if (letterCase == "capitalize") {
mLetterCaseAutoCollections = LetterCase::CAPITALIZE;
}
else if (letterCase == "none") {
mLetterCaseAutoCollections = LetterCase::NONE;
}
else {
LOG(LogWarning) << "GridComponent: Invalid theme configuration, property "
"\"letterCaseAutoCollections\" for element \""
<< element.substr(5) << "\" defined as \"" << letterCase << "\"";
}
}
if (elem->has("letterCaseCustomCollections")) {
const std::string& letterCase {elem->get<std::string>("letterCaseCustomCollections")};
if (letterCase == "uppercase") {
mLetterCaseCustomCollections = LetterCase::UPPERCASE;
}
else if (letterCase == "lowercase") {
mLetterCaseCustomCollections = LetterCase::LOWERCASE;
}
else if (letterCase == "capitalize") {
mLetterCaseCustomCollections = LetterCase::CAPITALIZE;
}
else if (letterCase == "none") {
mLetterCaseCustomCollections = LetterCase::NONE;
}
else {
LOG(LogWarning) << "GridComponent: Invalid theme configuration, property "
"\"letterCaseCustomCollections\" for element \""
<< element.substr(5) << "\" defined as \"" << letterCase << "\"";
}
}
if (mGamelistView && elem->has("systemNameSuffix"))
mSystemNameSuffix = elem->get<bool>("systemNameSuffix");
if (mGamelistView && properties & LETTER_CASE && elem->has("letterCaseSystemNameSuffix")) {
const std::string& letterCase {elem->get<std::string>("letterCaseSystemNameSuffix")};
if (letterCase == "uppercase") {
mLetterCaseSystemNameSuffix = LetterCase::UPPERCASE;
}
else if (letterCase == "lowercase") {
mLetterCaseSystemNameSuffix = LetterCase::LOWERCASE;
}
else if (letterCase == "capitalize") {
mLetterCaseSystemNameSuffix = LetterCase::CAPITALIZE;
}
else {
LOG(LogWarning) << "GridComponent: Invalid theme configuration, property "
"\"letterCaseSystemNameSuffix\" for element \""
<< element.substr(5) << "\" defined as \"" << letterCase << "\"";
}
}
if (elem->has("fadeAbovePrimary"))
mFadeAbovePrimary = elem->get<bool>("fadeAbovePrimary");
mSize.x = glm::clamp(mSize.x, mRenderer->getScreenWidth() * 0.05f,
mRenderer->getScreenWidth() * 1.0f);
mSize.y = glm::clamp(mSize.y, mRenderer->getScreenHeight() * 0.05f,
mRenderer->getScreenHeight() * 1.0f);
}
template <typename T> void GridComponent<T>::onCursorChanged(const CursorState& state)
{
if (mEntries.size() > static_cast<size_t>(mLastCursor))
mEntries.at(mLastCursor).data.item->resetComponent();
if (mColumns == 0)
return;
if (mWasScrolling && state == CursorState::CURSOR_STOPPED && mScrollVelocity != 0) {
mWasScrolling = false;
if (mCursorChangedCallback)
mCursorChangedCallback(state);
return;
}
if (mCursor == mLastCursor && !mJustCalculatedLayout) {
mWasScrolling = false;
if (mCursorChangedCallback)
mCursorChangedCallback(state);
return;
}
else {
mJustCalculatedLayout = false;
}
float startPos {mEntryOffset};
float posMax {static_cast<float>(mEntries.size())};
float target {static_cast<float>(mCursor)};
// Find the shortest path to the target.
float endPos {target}; // Directly.
if (mPreviousScrollVelocity > 0 && mScrollVelocity == 0 && mEntryOffset > posMax - 1.0f)
startPos = 0.0f;
float dist {std::fabs(endPos - startPos)};
if (std::fabs(target + posMax - startPos - mScrollVelocity) < dist)
endPos = target + posMax; // Loop around the end (0 -> max).
if (std::fabs(target - posMax - startPos - mScrollVelocity) < dist)
endPos = target - posMax; // Loop around the start (max - 1 -> -1).
// Make sure there are no reverse jumps between items.
bool changedDirection {false};
if (mPreviousScrollVelocity != 0 && mPreviousScrollVelocity != mScrollVelocity)
changedDirection = true;
if (!changedDirection && mScrollVelocity > 0 && endPos < startPos)
endPos = endPos + posMax;
if (!changedDirection && mScrollVelocity < 0 && endPos > startPos)
endPos = endPos - posMax;
if (mScrollVelocity != 0)
mPreviousScrollVelocity = mScrollVelocity;
// Needed to make sure that overlapping items are renderered correctly.
if (startPos > endPos)
mPositiveDirection = true;
else
mPositiveDirection = false;
float animTime {250.0f};
// If startPos is inbetween two positions then reduce the time slightly as the distance will
// be shorter meaning the animation would play for too long if not compensated for.
// float timeDiff {1.0f};
// if (mScrollVelocity == 1)
// timeDiff = endPos - startPos;
// else if (mScrollVelocity == -1)
// timeDiff = startPos - endPos;
// if (timeDiff != 1.0f)
// animTime =
// glm::clamp(std::fabs(glm::mix(0.0f, animTime, timeDiff * 1.5f)), 180.0f,
// animTime);
if (mSuppressTransitions)
animTime = 0.0f;
const float visibleRows {mVisibleRows - 1.0f};
const float startRow {static_cast<float>(mScrollPos)};
float endRow {static_cast<float>(mCursor / mColumns)};
if (endRow <= visibleRows)
endRow = 0.0f;
else
endRow -= visibleRows;
Animation* anim {new LambdaAnimation(
[this, startPos, endPos, posMax, startRow, endRow](float t) {
// Non-linear interpolation.
t = 1.0f - (1.0f - t) * (1.0f - t);
float f {(endPos * t) + (startPos * (1.0f - t))};
if (f < 0)
f += posMax;
if (f >= posMax)
f -= posMax;
mEntryOffset = f;
if (mInstantRowTransitions)
mScrollPos = endRow;
else
mScrollPos = {(endRow * t) + (startRow * (1.0f - t))};
if (mInstantItemTransitions) {
mTransitionFactor = 1.0f;
}
else {
// Linear interpolation.
mTransitionFactor = t;
// Non-linear interpolation doesn't seem to be a good match for this component.
// mTransitionFactor = {(1.0f * t) + (0.0f * (1.0f - t))};
}
},
static_cast<int>(animTime))};
GuiComponent::setAnimation(anim, 0, nullptr, false, 0);
if (mCursorChangedCallback)
mCursorChangedCallback(state);
mWasScrolling = (state == CursorState::CURSOR_SCROLLING);
}
#endif // ES_CORE_COMPONENTS_PRIMARY_GRID_COMPONENT_H