From b0564ceccf5ac1d75bd12d500a5bf751d8e0176e Mon Sep 17 00:00:00 2001 From: Sergio Date: Wed, 23 Jul 2025 17:39:30 +0200 Subject: [PATCH] fade: readability-function-cognitive-complexity --- source/fade.cpp | 308 ++++++++++++++++++++++++++---------------------- source/fade.h | 29 ++++- 2 files changed, 193 insertions(+), 144 deletions(-) diff --git a/source/fade.cpp b/source/fade.cpp index 802b763..6c4b248 100644 --- a/source/fade.cpp +++ b/source/fade.cpp @@ -1,12 +1,13 @@ #include "fade.h" #include // Para SDL_SetRenderTarget, SDL_FRect, SDL_GetRenderTarget, SDL_RenderFillRect, SDL_SetRenderDrawBlendMode, SDL_SetRenderDrawColor, Uint8, SDL_GetRenderDrawBlendMode, SDL_BLENDMODE_NONE, SDL_BlendMode, SDL_CreateTexture, SDL_DestroyTexture, SDL_RenderClear, SDL_RenderTexture, SDL_SetTextureAlphaMod, SDL_SetTextureBlendMode, SDL_BLENDMODE_BLEND, SDL_PixelFormat, SDL_TextureAccess -#include // Para min, max -#include // Para rand, size_t -#include "color.h" // Para Color -#include "param.h" // Para Param, param, ParamGame, ParamFade -#include "screen.h" // Para Screen +#include // Para min, max +#include // Para rand, size_t + +#include "color.h" // Para Color +#include "param.h" // Para Param, param, ParamGame, ParamFade +#include "screen.h" // Para Screen // Constructor Fade::Fade() @@ -58,150 +59,177 @@ void Fade::render() { // Actualiza las variables internas void Fade::update() { - if (state_ == FadeState::PRE) { - // Actualiza el contador - if (pre_counter_ == pre_duration_) { - state_ = FadeState::FADING; - } else { - pre_counter_++; - } + switch (state_) { + case FadeState::PRE: + updatePreState(); + break; + case FadeState::FADING: + updateFadingState(); + break; + case FadeState::POST: + updatePostState(); + break; + default: + break; + } +} + +void Fade::updatePreState() { + if (pre_counter_ == pre_duration_) { + state_ = FadeState::FADING; + } else { + pre_counter_++; + } +} + +void Fade::updateFadingState() { + switch (type_) { + case FadeType::FULLSCREEN: + updateFullscreenFade(); + break; + case FadeType::CENTER: + updateCenterFade(); + break; + case FadeType::RANDOM_SQUARE: + updateRandomSquareFade(); + break; + case FadeType::VENETIAN: + updateVenetianFade(); + break; + default: + break; + } + counter_++; +} + +void Fade::updatePostState() { + if (post_counter_ == post_duration_) { + state_ = FadeState::FINISHED; + } else { + post_counter_++; + } + cleanBackbuffer(r_, g_, b_, a_); +} + +void Fade::updateFullscreenFade() { + // Modifica la transparencia + a_ = mode_ == FadeMode::OUT ? std::min(counter_ * 4, 255) : 255 - std::min(counter_ * 4, 255); + SDL_SetTextureAlphaMod(backbuffer_, a_); + + // Comprueba si ha terminado + if (counter_ >= 255 / 4) { + state_ = FadeState::POST; + } +} + +void Fade::updateCenterFade() { + drawCenterFadeRectangles(); + + // Comprueba si ha terminado + if ((counter_ * 4) > param.game.height) { + state_ = FadeState::POST; + a_ = 255; + } +} + +void Fade::drawCenterFadeRectangles() { + auto *temp = SDL_GetRenderTarget(renderer_); + SDL_SetRenderTarget(renderer_, backbuffer_); + SDL_SetRenderDrawColor(renderer_, r_, g_, b_, a_); + + for (int i = 0; i < counter_; i++) { + rect1_.h = rect2_.h = i * 4; + rect2_.y = param.game.height - (i * 4); + + SDL_RenderFillRect(renderer_, &rect1_); + SDL_RenderFillRect(renderer_, &rect2_); + + value_ = calculateValue(0, counter_, i); } - if (state_ == FadeState::FADING) { - switch (type_) { - case FadeType::FULLSCREEN: { - // Modifica la transparencia - a_ = mode_ == FadeMode::OUT ? std::min(counter_ * 4, 255) : 255 - std::min(counter_ * 4, 255); + SDL_SetRenderTarget(renderer_, temp); +} - SDL_SetTextureAlphaMod(backbuffer_, a_); - - // Comprueba si ha terminado - if (counter_ >= 255 / 4) { - state_ = FadeState::POST; - } - - break; - } - - case FadeType::CENTER: { - // Dibuja sobre el backbuffer_ - auto *temp = SDL_GetRenderTarget(renderer_); - SDL_SetRenderTarget(renderer_, backbuffer_); - - SDL_SetRenderDrawColor(renderer_, r_, g_, b_, a_); - - for (int i = 0; i < counter_; i++) { - rect1_.h = rect2_.h = i * 4; - rect2_.y = param.game.height - (i * 4); - - SDL_RenderFillRect(renderer_, &rect1_); - SDL_RenderFillRect(renderer_, &rect2_); - - value_ = calculateValue(0, counter_, i); - } - - // Deja el renderizador como estaba - SDL_SetRenderTarget(renderer_, temp); - - // Comprueba si ha terminado - if ((counter_ * 4) > param.game.height) { - state_ = FadeState::POST; - a_ = 255; - } - break; - } - - case FadeType::RANDOM_SQUARE: { - if (counter_ % fade_random_squares_delay_ == 0) { - // Cambia el renderizador al backbuffer_ y modifica sus opciones - auto *temp = SDL_GetRenderTarget(renderer_); - SDL_SetRenderTarget(renderer_, backbuffer_); - SDL_BlendMode blend_mode; - SDL_GetRenderDrawBlendMode(renderer_, &blend_mode); - SDL_SetRenderDrawBlendMode(renderer_, SDL_BLENDMODE_NONE); - SDL_SetRenderDrawColor(renderer_, r_, g_, b_, a_); - - // Dibuja el cuadrado correspondiente - const int INDEX = std::min(counter_ / fade_random_squares_delay_, (num_squares_width_ * num_squares_height_) - 1); - for (int i = 0; i < fade_random_squares_mult_; ++i) { - const int INDEX2 = std::min(INDEX * fade_random_squares_mult_ + i, (int)square_.size() - 1); - SDL_RenderFillRect(renderer_, &square_[INDEX2]); - } - - // Deja el renderizador como estaba - SDL_SetRenderDrawBlendMode(renderer_, blend_mode); - SDL_SetRenderTarget(renderer_, temp); - } - - value_ = calculateValue(0, (num_squares_width_ * num_squares_height_), (counter_ * fade_random_squares_mult_ / fade_random_squares_delay_)); - - // Comprueba si ha terminado - if (counter_ * fade_random_squares_mult_ / fade_random_squares_delay_ >= num_squares_width_ * num_squares_height_) { - state_ = FadeState::POST; - } - - break; - } - - case FadeType::VENETIAN: { - // Counter debe ir de 0 a 150 <-- comprobar si esto es aún cierto - if (square_.back().h < param.fade.venetian_size) { - // Dibuja sobre el backbuffer_ - auto *temp = SDL_GetRenderTarget(renderer_); - SDL_SetRenderTarget(renderer_, backbuffer_); - SDL_BlendMode blend_mode; - SDL_GetRenderDrawBlendMode(renderer_, &blend_mode); - SDL_SetRenderDrawBlendMode(renderer_, SDL_BLENDMODE_NONE); - SDL_SetRenderDrawColor(renderer_, r_, g_, b_, a_); - - // Dibuja el cuadrado correspondiente - for (const auto RECT : square_) { - SDL_RenderFillRect(renderer_, &RECT); - } - - // Deja el renderizador como estaba - SDL_SetRenderDrawBlendMode(renderer_, blend_mode); - SDL_SetRenderTarget(renderer_, temp); - - // Modifica el tamaño de los rectangulos - const auto H = counter_ / 2; - for (size_t i = 0; i < square_.size(); ++i) { - // A partir del segundo rectangulo se pinta en función del anterior - square_.at(i).h = i == 0 ? H : std::max(static_cast(square_.at(i - 1).h) - 2, 0); - } - - int completed = 0; - for (const auto &square : square_) { - if (square.h >= param.fade.venetian_size) { - ++completed; - } - } - value_ = calculateValue(0, square_.size() - 1, completed); - } else { - state_ = FadeState::POST; - } - - break; - } - default: - break; - } - counter_++; +void Fade::updateRandomSquareFade() { + if (counter_ % fade_random_squares_delay_ == 0) { + drawRandomSquares(); } - if (state_ == FadeState::POST) { - // Actualiza el contador - if (post_counter_ == post_duration_) { - state_ = FadeState::FINISHED; - } else { - post_counter_++; - } + value_ = calculateValue(0, (num_squares_width_ * num_squares_height_), (counter_ * fade_random_squares_mult_ / fade_random_squares_delay_)); - // Deja el backbuffer_ todo del mismo color - cleanBackbuffer(r_, g_, b_, a_); + // Comprueba si ha terminado + if (counter_ * fade_random_squares_mult_ / fade_random_squares_delay_ >= + num_squares_width_ * num_squares_height_) { + state_ = FadeState::POST; } } +void Fade::drawRandomSquares() { + auto *temp = SDL_GetRenderTarget(renderer_); + SDL_SetRenderTarget(renderer_, backbuffer_); + + SDL_BlendMode blend_mode; + SDL_GetRenderDrawBlendMode(renderer_, &blend_mode); + SDL_SetRenderDrawBlendMode(renderer_, SDL_BLENDMODE_NONE); + SDL_SetRenderDrawColor(renderer_, r_, g_, b_, a_); + + const int INDEX = std::min(counter_ / fade_random_squares_delay_, + (num_squares_width_ * num_squares_height_) - 1); + + for (int i = 0; i < fade_random_squares_mult_; ++i) { + const int INDEX2 = std::min(INDEX * fade_random_squares_mult_ + i, + static_cast(square_.size()) - 1); + SDL_RenderFillRect(renderer_, &square_[INDEX2]); + } + + SDL_SetRenderDrawBlendMode(renderer_, blend_mode); + SDL_SetRenderTarget(renderer_, temp); +} + +void Fade::updateVenetianFade() { + if (square_.back().h < param.fade.venetian_size) { + drawVenetianBlinds(); + updateVenetianRectangles(); + calculateVenetianProgress(); + } else { + state_ = FadeState::POST; + } +} + +void Fade::drawVenetianBlinds() { + auto *temp = SDL_GetRenderTarget(renderer_); + SDL_SetRenderTarget(renderer_, backbuffer_); + + SDL_BlendMode blend_mode; + SDL_GetRenderDrawBlendMode(renderer_, &blend_mode); + SDL_SetRenderDrawBlendMode(renderer_, SDL_BLENDMODE_NONE); + SDL_SetRenderDrawColor(renderer_, r_, g_, b_, a_); + + for (const auto &rect : square_) { + SDL_RenderFillRect(renderer_, &rect); + } + + SDL_SetRenderDrawBlendMode(renderer_, blend_mode); + SDL_SetRenderTarget(renderer_, temp); +} + +void Fade::updateVenetianRectangles() { + const auto H = counter_ / 2; + for (size_t i = 0; i < square_.size(); ++i) { + square_.at(i).h = i == 0 ? H : std::max(static_cast(square_.at(i - 1).h) - 2, 0); + } +} + +void Fade::calculateVenetianProgress() { + int completed = 0; + for (const auto &square : square_) { + if (square.h >= param.fade.venetian_size) { + ++completed; + } + } + value_ = calculateValue(0, square_.size() - 1, completed); +} + // Activa el fade void Fade::activate() { // Si ya está habilitado, no hay que volverlo a activar diff --git a/source/fade.h b/source/fade.h index aa84561..87a0b81 100644 --- a/source/fade.h +++ b/source/fade.h @@ -1,6 +1,7 @@ #pragma once #include // Para Uint8, SDL_FRect, SDL_Renderer, SDL_Texture, Uint16 + #include // Para vector struct Color; @@ -82,8 +83,28 @@ class Fade { // --- Valor de progreso --- int value_ = 0; // Estado del fade (0-100) - // --- Métodos internos --- - void init(); // Inicializa variables - void cleanBackbuffer(Uint8 r, Uint8 g, Uint8 b, Uint8 a); // Limpia el backbuffer - static auto calculateValue(int min, int max, int current) -> int; // Calcula el valor del fade + // --- Inicialización y limpieza --- + void init(); // Inicializa variables + void cleanBackbuffer(Uint8 r, Uint8 g, Uint8 b, Uint8 a); // Limpia el backbuffer con un color RGBA + + // --- Utilidades generales --- + static auto calculateValue(int min, int max, int current) -> int; // Calcula el valor del fade entre dos límites + + // --- Lógica de estado --- + void updatePreState(); // Actualiza el estado previo al fade + void updateFadingState(); // Actualiza el estado durante el fade + void updatePostState(); // Actualiza el estado posterior al fade + + // --- Efectos de fundido (fade) --- + void updateFullscreenFade(); // Actualiza el fundido de pantalla completa + void updateCenterFade(); // Actualiza el fundido desde el centro + void updateRandomSquareFade(); // Actualiza el fundido con cuadrados aleatorios + void updateVenetianFade(); // Actualiza el fundido tipo persiana veneciana + void updateVenetianRectangles(); // Actualiza los rectángulos del efecto veneciano + void calculateVenetianProgress(); // Calcula el progreso del efecto veneciano + + // --- Dibujo de efectos visuales --- + void drawCenterFadeRectangles(); // Dibuja los rectángulos del fundido central + void drawRandomSquares(); // Dibuja los cuadrados aleatorios del fundido + void drawVenetianBlinds(); // Dibuja las persianas venecianas del fundido }; \ No newline at end of file