games/vcmi
1
0
Fork 0
mirror of https://github.com/vcmi/vcmi.git synced 2025-11-25 22:42:04 +02:00
Code Issues Releases Activity

xBRZ-upscaled images now support common palette-transform effects:

Browse Source 
- Player coloring
- Flag color for map
- Glue selection for combat
This commit is contained in:
Ivan Savenko
2024-07-25 10:38:48 +00:00
parent 2d12cecded
commit ffba847f40
18 changed files with 464 additions and 291 deletions
Download Patch File Download Diff File Expand all files Collapse all files

126
client/renderSDL/RenderHandler.cpp
View File

@@ -15,6 +15,8 @@
#include "../render/CAnimation.h"
#include "../render/CDefFile.h"
#include "../render/Colors.h"
#include "../render/ColorFilter.h"
#include "../../lib/json/JsonUtils.h"
#include "../../lib/filesystem/Filesystem.h"
@@ -131,47 +133,28 @@ int RenderHandler::getScalingFactor() const
return 2;
}
std::shared_ptr<ISharedImage> RenderHandler::createScaledImage(std::shared_ptr<SDLImageShared> input)
std::shared_ptr<IImage> RenderHandler::createImageReference(const ImageLocator & locator, std::shared_ptr<ISharedImage> input, EImageBlitMode mode)
{
if (getScalingFactor() == 1)
return input;
return std::make_shared<ImageSharedScaled>(input);
if (getScalingFactor() == 1 || locator.scalingFactor != 1 || locator.empty())
return input->createImageReference(mode);
else
return std::make_shared<ImageScaled>(locator, input, mode);
}
std::shared_ptr<ISharedImage> RenderHandler::loadImageFromSingleFile(const ImagePath & path)
{
auto result = createScaledImage(std::make_shared<SDLImageShared>(path));
imageFiles[ImageLocator(path)] = result;
return result;
}
std::shared_ptr<ISharedImage> RenderHandler::loadImageFromAnimationFileUncached(const AnimationPath & path, int frame, int group)
ImageLocator RenderHandler::getLocatorForAnimationFrame(const AnimationPath & path, int frame, int group)
{
const auto & layout = getAnimationLayout(path);
if (!layout.count(group))
return loadImageFromSingleFile(ImagePath::builtin("DEFAULT"));
return ImageLocator(ImagePath::builtin("DEFAULT"));
if (frame >= layout.at(group).size())
return loadImageFromSingleFile(ImagePath::builtin("DEFAULT"));
return ImageLocator(ImagePath::builtin("DEFAULT"));
const auto & locator = layout.at(group).at(frame);
if (locator.image)
{
return loadImageImpl(locator);
}
else
{
auto defFile = getAnimationFile(path);
return createScaledImage(std::make_shared<SDLImageShared>(defFile.get(), frame, group));
}
}
if (locator.image || locator.defFile)
return locator;
std::shared_ptr<ISharedImage> RenderHandler::loadImageFromAnimationFile(const AnimationPath & path, int frame, int group)
{
auto result = loadImageFromAnimationFileUncached(path, frame, group);
imageFiles[ImageLocator(path, frame, group)] = result;
return result;
return ImageLocator(path, frame, group);
}
std::shared_ptr<ISharedImage> RenderHandler::loadImageImpl(const ImageLocator & locator)
@@ -180,15 +163,52 @@ std::shared_ptr<ISharedImage> RenderHandler::loadImageImpl(const ImageLocator &
if (it != imageFiles.end())
return it->second;
std::shared_ptr<ISharedImage> result;
// TODO: order should be different:
// 1) try to find correctly scaled image
// 2) if fails -> try to find correctly transformed
// 3) if also fails -> try to find image from correct file
// 4) load missing part of the sequence
// TODO: check whether (load -> transform -> scale) or (load -> scale -> transform) order should be used for proper loading of pre-scaled data
auto imageFromFile = loadImageFromFile(locator.copyFile());
auto transformedImage = transformImage(locator.copyFileTransform(), imageFromFile);
auto scaledImage = scaleImage(locator.copyFileTransformScale(), transformedImage);
return scaledImage;
}
std::shared_ptr<ISharedImage> RenderHandler::loadImageFromFileUncached(const ImageLocator & locator)
{
if (locator.image)
result = loadImageFromSingleFile(*locator.image);
else if (locator.defFile)
result = loadImageFromAnimationFile(*locator.defFile, locator.defFrame, locator.defGroup);
{
// TODO: create EmptySharedImage class that will be instantiated if image does not exists or fails to load
return std::make_shared<SDLImageShared>(*locator.image);
}
if (!result)
result = loadImageFromSingleFile(ImagePath::builtin("DEFAULT"));
if (locator.defFile)
{
auto defFile = getAnimationFile(*locator.defFile);
return std::make_shared<SDLImageShared>(defFile.get(), locator.defFrame, locator.defGroup);
}
throw std::runtime_error("Invalid image locator received!");
}
std::shared_ptr<ISharedImage> RenderHandler::loadImageFromFile(const ImageLocator & locator)
{
if (imageFiles.count(locator))
return imageFiles.at(locator);
auto result = loadImageFromFileUncached(locator);
imageFiles[locator] = result;
return result;
}
std::shared_ptr<ISharedImage> RenderHandler::transformImage(const ImageLocator & locator, std::shared_ptr<ISharedImage> image)
{
if (imageFiles.count(locator))
return imageFiles.at(locator);
auto result = image;
if (locator.verticalFlip)
result = result->verticalFlip();
@@ -200,24 +220,50 @@ std::shared_ptr<ISharedImage> RenderHandler::loadImageImpl(const ImageLocator &
return result;
}
std::shared_ptr<ISharedImage> RenderHandler::scaleImage(const ImageLocator & locator, std::shared_ptr<ISharedImage> image)
{
if (imageFiles.count(locator))
return imageFiles.at(locator);
auto handle = image->createImageReference(EImageBlitMode::OPAQUE);
assert(locator.scalingFactor != 1); // should be filtered-out before
handle->setOverlayEnabled(locator.layerOverlay);
handle->setBodyEnabled(locator.layerBody);
handle->setShadowEnabled(locator.layerShadow);
if (locator.layerBody && locator.playerColored != PlayerColor::CANNOT_DETERMINE)
handle->playerColored(locator.playerColored);
handle->scaleFast(handle->dimensions() * locator.scalingFactor);
// TODO: try to optimize image size (possibly even before scaling?) - trim image borders if they are completely transparent
auto result = handle->getSharedImage();
imageFiles[locator] = result;
return result;
}
std::shared_ptr<IImage> RenderHandler::loadImage(const ImageLocator & locator, EImageBlitMode mode)
{
return loadImageImpl(locator)->createImageReference(mode);
return createImageReference(locator, loadImageImpl(locator), mode);
}
std::shared_ptr<IImage> RenderHandler::loadImage(const AnimationPath & path, int frame, int group, EImageBlitMode mode)
{
return loadImageFromAnimationFile(path, frame, group)->createImageReference(mode);
auto locator = getLocatorForAnimationFrame(path, frame, group);
return loadImage(locator, mode);
}
std::shared_ptr<IImage> RenderHandler::loadImage(const ImagePath & path, EImageBlitMode mode)
{
return loadImageImpl(ImageLocator(path))->createImageReference(mode);
return loadImage(ImageLocator(path), mode);
}
std::shared_ptr<IImage> RenderHandler::createImage(SDL_Surface * source)
{
return std::make_shared<SDLImageShared>(source)->createImageReference(EImageBlitMode::ALPHA);
return createImageReference(ImageLocator(), std::make_shared<SDLImageShared>(source), EImageBlitMode::ALPHA);
}
std::shared_ptr<CAnimation> RenderHandler::loadAnimation(const AnimationPath & path, EImageBlitMode mode)