mirror of
https://github.com/vcmi/vcmi.git
synced 2025-03-21 21:17:49 +02:00
127 lines
4.4 KiB
C++
127 lines
4.4 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;
|
|
|
|
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);
|
|
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 maxScaling = 4;
|
|
static constexpr int maxFlips = 4;
|
|
|
|
using FlippedImages = std::array<std::shared_ptr<const ISharedImage>, maxFlips>;
|
|
using PlayerColoredImages = std::array<std::shared_ptr<const ISharedImage>, PlayerColor::PLAYER_LIMIT_I>;
|
|
|
|
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;
|
|
|
|
// player-colored images of this particular scale. These are never flipped in h3
|
|
PlayerColoredImages playerColored;
|
|
};
|
|
|
|
// 1x image, usually indexed. Array of 4 images for every potential flip
|
|
FlippedImages base;
|
|
|
|
// 1x-4x images. 1x versions are only used if dedicated image is present, othervice palette transform is applied to base image
|
|
std::array<ScaledImage, maxScaling> scaled;
|
|
|
|
const SharedImageLocator locator;
|
|
|
|
std::shared_ptr<const ISharedImage> loadOrGenerateImage(EImageBlitMode mode, int8_t scalingFactor, PlayerColor color) 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 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 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();
|
|
};
|
|
|