mirror of
https://github.com/vcmi/vcmi.git
synced 2025-03-21 21:17:49 +02:00
132 lines
4.7 KiB
C++
132 lines
4.7 KiB
C++
/*
|
|
* ScalableImage.h, part of VCMI engine
|
|
*
|
|
* Authors: listed in file AUTHORS in main folder
|
|
*
|
|
* License: GNU General Public License v2.0 or later
|
|
* Full text of license available in license.txt file, in main folder
|
|
*
|
|
*/
|
|
#pragma once
|
|
|
|
#include "../render/IImage.h"
|
|
#include "../render/ImageLocator.h"
|
|
#include "../render/Colors.h"
|
|
|
|
#include "../../lib/Color.h"
|
|
|
|
struct SDL_Palette;
|
|
|
|
class ScalableImageInstance;
|
|
class CanvasImage;
|
|
|
|
struct ScalableImageParameters : boost::noncopyable
|
|
{
|
|
SDL_Palette * palette = nullptr;
|
|
|
|
ColorRGBA colorMultiplier = Colors::WHITE_TRUE;
|
|
ColorRGBA ovelayColorMultiplier = Colors::WHITE_TRUE;
|
|
ColorRGBA effectColorMultiplier = Colors::TRANSPARENCY;
|
|
|
|
PlayerColor player = PlayerColor::CANNOT_DETERMINE;
|
|
uint8_t alphaValue = 255;
|
|
|
|
bool flipVertical = false;
|
|
bool flipHorizontal = false;
|
|
|
|
ScalableImageParameters(const SDL_Palette * originalPalette, EImageBlitMode blitMode);
|
|
~ScalableImageParameters();
|
|
|
|
void setShadowTransparency(const SDL_Palette * originalPalette, float factor);
|
|
void shiftPalette(const SDL_Palette * originalPalette, uint32_t firstColorID, uint32_t colorsToMove, uint32_t distanceToMove);
|
|
void playerColored(PlayerColor player);
|
|
void setOverlayColor(const SDL_Palette * originalPalette, const ColorRGBA & color, bool includeShadow);
|
|
void preparePalette(const SDL_Palette * originalPalette, EImageBlitMode blitMode);
|
|
void adjustPalette(const SDL_Palette * originalPalette, EImageBlitMode blitMode, const ColorFilter & shifter, uint32_t colorsToSkipMask);
|
|
};
|
|
|
|
class ScalableImageShared final : public std::enable_shared_from_this<ScalableImageShared>, boost::noncopyable
|
|
{
|
|
static constexpr int scalingSize = 5; // 0-4 range. TODO: switch to 1-4 since there is no '0' scaling
|
|
static constexpr int maxFlips = 4;
|
|
|
|
using ImageType = std::shared_ptr<const ISharedImage>;
|
|
using FlippedImages = std::array<ImageType, maxFlips>;
|
|
using PlayerColoredImages = std::array<ImageType, PlayerColor::PLAYER_LIMIT_I + 1>; // all valid colors+neutral
|
|
|
|
struct ScaledImage
|
|
{
|
|
/// Upscaled shadow of our image, may be null
|
|
FlippedImages shadow;
|
|
|
|
/// Upscaled main part of our image, may be null
|
|
FlippedImages body;
|
|
|
|
/// Upscaled overlay (player color, selection highlight) of our image, may be null
|
|
FlippedImages overlay;
|
|
|
|
/// Upscaled grayscale version of body, for special effects in combat (e.g clone / petrify / berserk)
|
|
FlippedImages bodyGrayscale;
|
|
|
|
/// player-colored images of this particular scale, mostly for UI. These are never flipped in h3
|
|
PlayerColoredImages playerColored;
|
|
};
|
|
|
|
/// 1x-4x images. body for 1x scaling is guaranteed to be loaded
|
|
std::array<ScaledImage, scalingSize> scaled;
|
|
|
|
/// Locator of this image, for loading additional (e.g. upscaled) images
|
|
const SharedImageLocator locator;
|
|
|
|
std::shared_ptr<const ISharedImage> loadOrGenerateImage(EImageBlitMode mode, int8_t scalingFactor, PlayerColor color, ImageType upscalingSource) const;
|
|
|
|
void loadScaledImages(int8_t scalingFactor, PlayerColor color);
|
|
|
|
public:
|
|
ScalableImageShared(const SharedImageLocator & locator, const std::shared_ptr<const ISharedImage> & baseImage);
|
|
|
|
Point dimensions() const;
|
|
void exportBitmap(const boost::filesystem::path & path, const ScalableImageParameters & parameters) const;
|
|
bool isTransparent(const Point & coords) const;
|
|
Rect contentRect() const;
|
|
void draw(SDL_Surface * where, const Point & dest, const Rect * src, const ScalableImageParameters & parameters, int scalingFactor);
|
|
|
|
const SDL_Palette * getPalette() const;
|
|
|
|
std::shared_ptr<ScalableImageInstance> createImageReference();
|
|
|
|
void prepareEffectImage();
|
|
void preparePlayerColoredImage(PlayerColor color);
|
|
};
|
|
|
|
class ScalableImageInstance final : public IImage
|
|
{
|
|
friend class ScalableImageShared;
|
|
|
|
std::shared_ptr<ScalableImageShared> image;
|
|
std::shared_ptr<CanvasImage> scaledImage;
|
|
|
|
ScalableImageParameters parameters;
|
|
EImageBlitMode blitMode;
|
|
|
|
public:
|
|
ScalableImageInstance(const std::shared_ptr<ScalableImageShared> & image, EImageBlitMode blitMode);
|
|
|
|
void scaleTo(const Point & size, EScalingAlgorithm algorithm) override;
|
|
void exportBitmap(const boost::filesystem::path & path) const override;
|
|
bool isTransparent(const Point & coords) const override;
|
|
Rect contentRect() const override;
|
|
Point dimensions() const override;
|
|
void setAlpha(uint8_t value) override;
|
|
void draw(SDL_Surface * where, const Point & pos, const Rect * src, int scalingFactor) const override;
|
|
void setOverlayColor(const ColorRGBA & color) override;
|
|
void setEffectColor(const ColorRGBA & color) override;
|
|
void playerColored(const PlayerColor & player) override;
|
|
void shiftPalette(uint32_t firstColorID, uint32_t colorsToMove, uint32_t distanceToMove) override;
|
|
void adjustPalette(const ColorFilter & shifter, uint32_t colorsToSkipMask) override;
|
|
|
|
void horizontalFlip();
|
|
void verticalFlip();
|
|
};
|
|
|