124 lines
5.1 KiB
C++
124 lines
5.1 KiB
C++
#include "core/rendering/surface.hpp"
|
|
|
|
#include <algorithm>
|
|
#include <cstring>
|
|
#include <stdexcept>
|
|
#include <vector>
|
|
|
|
#include "core/rendering/canvas.hpp"
|
|
#include "core/rendering/gif.hpp"
|
|
#include "core/resources/resource_helper.hpp"
|
|
#include "utils/utils.hpp"
|
|
|
|
auto loadPaletteFromGif(const std::string& file_path) -> Palette {
|
|
auto buffer = Resource::Helper::loadFile(file_path);
|
|
if (buffer.empty()) {
|
|
throw std::runtime_error("Surface: cannot open palette file " + file_path);
|
|
}
|
|
|
|
std::vector<std::uint32_t> rgb = GIF::Gif::loadPalette(buffer.data());
|
|
if (rgb.empty()) {
|
|
throw std::runtime_error("Surface: no palette in GIF " + file_path);
|
|
}
|
|
|
|
Palette palette = {};
|
|
// Convertim RGB → ARGB aplicant-hi el canal alpha opac constant.
|
|
const std::size_t COUNT = std::min(rgb.size(), palette.size());
|
|
for (std::size_t i = 0; i < COUNT; ++i) {
|
|
palette[i] = Rendering::OPAQUE_ALPHA | rgb[i];
|
|
}
|
|
return palette;
|
|
}
|
|
|
|
Surface::Surface(int w, int h)
|
|
: surface_data_(std::make_shared<SurfaceData>(w, h)) {
|
|
initializeSubPalette(sub_palette_);
|
|
}
|
|
|
|
Surface::Surface(const std::string& file_path) {
|
|
// Carreguem el fitxer una única vegada i n'extraiem pixels i paleta de
|
|
// passades independents sobre el mateix buffer en memòria — abans es
|
|
// parsejava dues voltes (loadSurface + loadPaletteFromGif).
|
|
auto buffer = Resource::Helper::loadFile(file_path);
|
|
if (buffer.empty()) {
|
|
throw std::runtime_error("Surface: cannot open " + file_path);
|
|
}
|
|
|
|
Uint16 w = 0;
|
|
Uint16 h = 0;
|
|
std::vector<Uint8> raw_pixels = GIF::Gif::loadGif(buffer.data(), w, h);
|
|
if (raw_pixels.empty()) {
|
|
throw std::runtime_error("Surface: failed to decode GIF " + file_path);
|
|
}
|
|
|
|
auto pixels = std::shared_ptr<Uint8[]>(new Uint8[raw_pixels.size()], std::default_delete<Uint8[]>());
|
|
std::memcpy(pixels.get(), raw_pixels.data(), raw_pixels.size());
|
|
surface_data_ = std::make_shared<SurfaceData>(static_cast<int>(w), static_cast<int>(h), pixels);
|
|
initializeSubPalette(sub_palette_);
|
|
|
|
std::vector<std::uint32_t> rgb = GIF::Gif::loadPalette(buffer.data());
|
|
const std::size_t COUNT = std::min(rgb.size(), palette_.size());
|
|
for (std::size_t i = 0; i < COUNT; ++i) {
|
|
palette_[i] = Rendering::OPAQUE_ALPHA | rgb[i];
|
|
}
|
|
|
|
printStatus("Surface", getFileName(file_path), StatusKind::SUCCESS);
|
|
}
|
|
|
|
void Surface::clear(Uint8 color) {
|
|
const std::size_t TOTAL = static_cast<std::size_t>(surface_data_->width) * static_cast<std::size_t>(surface_data_->height);
|
|
std::fill(surface_data_->data.get(), surface_data_->data.get() + TOTAL, color);
|
|
}
|
|
|
|
void Surface::putPixel(int x, int y, Uint8 color) {
|
|
if (x < 0 || y < 0 || x >= surface_data_->width || y >= surface_data_->height) { return; }
|
|
surface_data_->data.get()[x + (y * surface_data_->width)] = color;
|
|
}
|
|
|
|
auto Surface::getPixel(int x, int y) const -> Uint8 {
|
|
return surface_data_->data.get()[x + (y * surface_data_->width)];
|
|
}
|
|
|
|
void Surface::render(int x, int y, const SDL_FRect* src_rect, SDL_FlipMode flip) const {
|
|
// Delegem a la versió amb remap: fent source==target==transparent_color_,
|
|
// qualsevol píxel opaC tindrà COLOR != source_color (els transparents ja
|
|
// s'han filtrat), així que REMAPPED = sub_palette_[COLOR] — idèntic al
|
|
// camí sense remap. Això evita duplicar el bucle de blit.
|
|
renderWithColorReplace(x, y, transparent_color_, transparent_color_, src_rect, flip);
|
|
}
|
|
|
|
void Surface::renderWithColorReplace(int x, int y, Uint8 source_color, Uint8 target_color, const SDL_FRect* src_rect, SDL_FlipMode flip) const {
|
|
const auto CANVAS = Rendering::activeCanvas();
|
|
const auto CLIP = Rendering::activeClip();
|
|
Uint32* dst = CANVAS.pixels;
|
|
const int DST_W = CANVAS.width;
|
|
const int CLIP_X0 = CLIP.x;
|
|
const int CLIP_Y0 = CLIP.y;
|
|
const int CLIP_X1 = CLIP.x + CLIP.w;
|
|
const int CLIP_Y1 = CLIP.y + CLIP.h;
|
|
|
|
const int SX = (src_rect != nullptr) ? static_cast<int>(src_rect->x) : 0;
|
|
const int SY = (src_rect != nullptr) ? static_cast<int>(src_rect->y) : 0;
|
|
int sw = (src_rect != nullptr) ? static_cast<int>(src_rect->w) : surface_data_->width;
|
|
int sh = (src_rect != nullptr) ? static_cast<int>(src_rect->h) : surface_data_->height;
|
|
|
|
sw = std::min(sw, surface_data_->width - SX);
|
|
sh = std::min(sh, surface_data_->height - SY);
|
|
|
|
const Uint8* src = surface_data_->data.get();
|
|
for (int iy = 0; iy < sh; ++iy) {
|
|
for (int ix = 0; ix < sw; ++ix) {
|
|
const int SRC_X = (flip == SDL_FLIP_HORIZONTAL) ? (SX + sw - 1 - ix) : (SX + ix);
|
|
const int SRC_Y = (flip == SDL_FLIP_VERTICAL) ? (SY + sh - 1 - iy) : (SY + iy);
|
|
const int DST_X = x + ix;
|
|
const int DST_Y = y + iy;
|
|
if (DST_X < CLIP_X0 || DST_X >= CLIP_X1 || DST_Y < CLIP_Y0 || DST_Y >= CLIP_Y1) { continue; }
|
|
|
|
const Uint8 COLOR = src[SRC_X + (SRC_Y * surface_data_->width)];
|
|
if (COLOR == transparent_color_) { continue; }
|
|
const Uint8 REMAPPED = (COLOR == source_color) ? target_color : sub_palette_[COLOR];
|
|
dst[DST_X + (DST_Y * DST_W)] = palette_[REMAPPED];
|
|
}
|
|
}
|
|
}
|