jaildesigner-jailgames/coffee-crisis
1
0
Fork 1
Code Issues Pull Requests Projects Releases 14 Wiki Activity

treball en curs: correccions de tidy

Browse Source
This commit is contained in:
Sergio Valor
2026-05-16 17:19:40 +02:00
parent 3421f34a84
commit ee2dd0bc2c
30 changed files with 1220 additions and 1479 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/core/rendering/texture.cpp
+65 -65
View File
@@ -9,19 +9,19 @@
#include "core/resources/resource_helper.h" // for loadFile (pack + filesystem fallback)
#include "external/stb_image.h" // for stbi_failure_reason, stbi_image_free
SDL_ScaleMode Texture::currentScaleMode = SDL_SCALEMODE_NEAREST;
SDL_ScaleMode Texture::current_scale_mode = SDL_SCALEMODE_NEAREST;
void Texture::setGlobalScaleMode(SDL_ScaleMode mode) {
currentScaleMode = mode;
current_scale_mode = mode;
}
// Constructor
Texture::Texture(SDL_Renderer *renderer, const std::string &path, bool verbose)
: texture(nullptr),
renderer(renderer),
width(0),
height(0),
path(path) {
: texture_(nullptr),
renderer_(renderer),
width_(0),
height_(0),
path_(path) {
// Carga el fichero en la textura
if (!path.empty()) {
loadFromFile(path, renderer, verbose);
@@ -30,10 +30,10 @@ Texture::Texture(SDL_Renderer *renderer, const std::string &path, bool verbose)
// Constructor desde bytes
Texture::Texture(SDL_Renderer *renderer, const std::vector<uint8_t> &bytes, bool verbose)
: texture(nullptr),
renderer(renderer),
width(0),
height(0) {
: texture_(nullptr),
renderer_(renderer),
width_(0),
height_(0) {
if (!bytes.empty()) {
loadFromMemory(bytes.data(), bytes.size(), renderer, verbose);
}
@@ -47,24 +47,24 @@ Texture::~Texture() {
// Helper: convierte píxeles RGBA decodificados por stbi en SDL_Texture
static auto createTextureFromPixels(SDL_Renderer *renderer, unsigned char *data, int w, int h, int *out_w, int *out_h) -> SDL_Texture * {
const int pitch = 4 * w;
SDL_Surface *loadedSurface = SDL_CreateSurfaceFrom(w, h, SDL_PIXELFORMAT_RGBA32, static_cast<void *>(data), pitch);
if (loadedSurface == nullptr) {
const int PITCH = 4 * w;
SDL_Surface *loaded_surface = SDL_CreateSurfaceFrom(w, h, SDL_PIXELFORMAT_RGBA32, static_cast<void *>(data), PITCH);
if (loaded_surface == nullptr) {
return nullptr;
}
SDL_Texture *newTexture = SDL_CreateTextureFromSurface(renderer, loadedSurface);
if (newTexture != nullptr) {
*out_w = loadedSurface->w;
*out_h = loadedSurface->h;
SDL_SetTextureScaleMode(newTexture, Texture::currentScaleMode);
SDL_Texture *new_texture = SDL_CreateTextureFromSurface(renderer, loaded_surface);
if (new_texture != nullptr) {
*out_w = loaded_surface->w;
*out_h = loaded_surface->h;
SDL_SetTextureScaleMode(new_texture, Texture::current_scale_mode);
}
SDL_DestroySurface(loadedSurface);
return newTexture;
SDL_DestroySurface(loaded_surface);
return new_texture;
}
// Carga una imagen desde un fichero (vía ResourceHelper: pack si està inicialitzat, filesystem si no)
auto Texture::loadFromFile(const std::string &path, SDL_Renderer *renderer, bool verbose) -> bool {
const std::string filename = path.substr(path.find_last_of("\\/") + 1);
const std::string FILE_NAME = path.substr(path.find_last_of("\\/") + 1);
auto bytes = ResourceHelper::loadFile(path);
if (bytes.empty()) {
@@ -81,18 +81,18 @@ auto Texture::loadFromFile(const std::string &path, SDL_Renderer *renderer, bool
SDL_Log("Loading image failed: %s", stbi_failure_reason());
exit(1);
} else if (verbose) {
std::cout << "Image loaded: " << filename.c_str() << '\n';
std::cout << "Image loaded: " << FILE_NAME.c_str() << '\n';
}
unload();
SDL_Texture *newTexture = createTextureFromPixels(renderer, data, w, h, &this->width, &this->height);
if (newTexture == nullptr && verbose) {
SDL_Texture *new_texture = createTextureFromPixels(renderer, data, w, h, &this->width_, &this->height_);
if (new_texture == nullptr && verbose) {
std::cout << "Unable to load image " << path.c_str() << '\n';
}
stbi_image_free(data);
texture = newTexture;
return texture != nullptr;
texture_ = new_texture;
return texture_ != nullptr;
}
// Carga una imagen desde bytes en memoria
@@ -107,112 +107,112 @@ auto Texture::loadFromMemory(const uint8_t *data, size_t size, SDL_Renderer *ren
}
unload();
SDL_Texture *newTexture = createTextureFromPixels(renderer, pixels, w, h, &this->width, &this->height);
if (newTexture == nullptr && verbose) {
SDL_Texture *new_texture = createTextureFromPixels(renderer, pixels, w, h, &this->width_, &this->height_);
if (new_texture == nullptr && verbose) {
std::cout << "Unable to create texture from memory" << '\n';
}
stbi_image_free(pixels);
texture = newTexture;
return texture != nullptr;
texture_ = new_texture;
return texture_ != nullptr;
}
// Crea una textura en blanco
auto Texture::createBlank(SDL_Renderer *renderer, int width, int height, SDL_TextureAccess access) -> bool {
// Crea una textura sin inicializar
texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, access, width, height);
if (texture == nullptr) {
texture_ = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, access, width, height);
if (texture_ == nullptr) {
std::cout << "Unable to create blank texture! SDL Error: " << SDL_GetError() << '\n';
} else {
this->width = width;
this->height = height;
SDL_SetTextureScaleMode(texture, currentScaleMode);
this->width_ = width;
this->height_ = height;
SDL_SetTextureScaleMode(texture_, current_scale_mode);
}
return texture != nullptr;
return texture_ != nullptr;
}
// Libera la memoria de la textura
void Texture::unload() {
// Libera la textura si existe
if (texture != nullptr) {
SDL_DestroyTexture(texture);
texture = nullptr;
width = 0;
height = 0;
if (texture_ != nullptr) {
SDL_DestroyTexture(texture_);
texture_ = nullptr;
width_ = 0;
height_ = 0;
}
}
// Establece el color para la modulacion
void Texture::setColor(Uint8 red, Uint8 green, Uint8 blue) {
SDL_SetTextureColorMod(texture, red, green, blue);
SDL_SetTextureColorMod(texture_, red, green, blue);
}
// Establece el blending
void Texture::setBlendMode(SDL_BlendMode blending) {
SDL_SetTextureBlendMode(texture, blending);
SDL_SetTextureBlendMode(texture_, blending);
}
// Establece el alpha para la modulación
void Texture::setAlpha(Uint8 alpha) {
SDL_SetTextureAlphaMod(texture, alpha);
SDL_SetTextureAlphaMod(texture_, alpha);
}
// Renderiza la textura en un punto específico
void Texture::render(SDL_Renderer *renderer, int x, int y, SDL_Rect *clip, float zoomW, float zoomH, double angle, SDL_Point *center, SDL_FlipMode flip) {
void Texture::render(SDL_Renderer *renderer, int x, int y, SDL_Rect *clip, float zoom_w, float zoom_h, double angle, SDL_Point *center, SDL_FlipMode flip) {
// Establece el destino de renderizado en la pantalla
SDL_FRect renderQuad = {(float)x, (float)y, (float)width, (float)height};
SDL_FRect render_quad = {(float)x, (float)y, (float)width_, (float)height_};
// Obtiene las dimesiones del clip de renderizado
if (clip != nullptr) {
renderQuad.w = (float)clip->w;
renderQuad.h = (float)clip->h;
render_quad.w = (float)clip->w;
render_quad.h = (float)clip->h;
}
renderQuad.w = renderQuad.w * zoomW;
renderQuad.h = renderQuad.h * zoomH;
render_quad.w = render_quad.w * zoom_w;
render_quad.h = render_quad.h * zoom_h;
// Convierte el clip a SDL_FRect
SDL_FRect srcRect;
SDL_FRect *srcRectPtr = nullptr;
SDL_FRect src_rect;
SDL_FRect *src_rect_ptr = nullptr;
if (clip != nullptr) {
srcRect = {.x = (float)clip->x, .y = (float)clip->y, .w = (float)clip->w, .h = (float)clip->h};
srcRectPtr = &srcRect;
src_rect = {.x = (float)clip->x, .y = (float)clip->y, .w = (float)clip->w, .h = (float)clip->h};
src_rect_ptr = &src_rect;
}
// Convierte el centro a SDL_FPoint
SDL_FPoint fCenter;
SDL_FPoint *fCenterPtr = nullptr;
SDL_FPoint f_center;
SDL_FPoint *f_center_ptr = nullptr;
if (center != nullptr) {
fCenter = {.x = (float)center->x, .y = (float)center->y};
fCenterPtr = &fCenter;
f_center = {.x = (float)center->x, .y = (float)center->y};
f_center_ptr = &f_center;
}
// Renderiza a pantalla
SDL_RenderTextureRotated(renderer, texture, srcRectPtr, &renderQuad, angle, fCenterPtr, flip);
SDL_RenderTextureRotated(renderer, texture_, src_rect_ptr, &render_quad, angle, f_center_ptr, flip);
}
// Establece la textura como objetivo de renderizado
void Texture::setAsRenderTarget(SDL_Renderer *renderer) {
SDL_SetRenderTarget(renderer, texture);
SDL_SetRenderTarget(renderer, texture_);
}
// Obtiene el ancho de la imagen
auto Texture::getWidth() const -> int {
return width;
return width_;
}
// Obtiene el alto de la imagen
auto Texture::getHeight() const -> int {
return height;
return height_;
}
// Recarga la textura
auto Texture::reLoad() -> bool {
return loadFromFile(path, renderer);
return loadFromFile(path_, renderer_);
}
// Obtiene la textura
auto Texture::getSDLTexture() -> SDL_Texture * {
return texture;
return texture_;
}