724 lines
25 KiB
C++
724 lines
25 KiB
C++
#include "fade.h"
|
|
|
|
#include <SDL3/SDL.h> // 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 <algorithm> // Para min, max
|
|
#include <cstdlib> // 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()
|
|
: renderer_(Screen::get()->getRenderer()) {
|
|
// Crea la textura donde dibujar el fade
|
|
backbuffer_ = SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, param.game.width, param.game.height);
|
|
SDL_SetTextureBlendMode(backbuffer_, SDL_BLENDMODE_BLEND);
|
|
|
|
// Inicializa las variables
|
|
init();
|
|
}
|
|
|
|
// Destructor
|
|
Fade::~Fade() {
|
|
SDL_DestroyTexture(backbuffer_);
|
|
}
|
|
|
|
// Inicializa las variables
|
|
void Fade::init() {
|
|
type_ = Type::CENTER;
|
|
mode_ = Mode::OUT;
|
|
counter_ = 0;
|
|
r_ = 0;
|
|
g_ = 0;
|
|
b_ = 0;
|
|
a_ = 0;
|
|
post_duration_ = 0;
|
|
post_start_time_ = 0;
|
|
pre_duration_ = 0;
|
|
pre_start_time_ = 0;
|
|
num_squares_width_ = param.fade.num_squares_width;
|
|
num_squares_height_ = param.fade.num_squares_height;
|
|
random_squares_duration_ = param.fade.random_squares_duration_ms; // Usar como duración en ms
|
|
square_transition_duration_ = random_squares_duration_ / 4; // 25% del tiempo total para la transición individual
|
|
random_squares_start_time_ = 0;
|
|
}
|
|
|
|
// Resetea algunas variables para volver a hacer el fade sin perder ciertos parametros
|
|
void Fade::reset() {
|
|
state_ = State::NOT_ENABLED;
|
|
counter_ = 0;
|
|
post_start_time_ = 0;
|
|
pre_start_time_ = 0;
|
|
}
|
|
|
|
// Pinta una transición en pantalla
|
|
void Fade::render() {
|
|
if (state_ != State::NOT_ENABLED) {
|
|
// Para fade IN terminado, no renderizar (auto-desactivación visual)
|
|
if (state_ == State::FINISHED && mode_ == Mode::IN) {
|
|
return;
|
|
}
|
|
|
|
SDL_RenderTexture(renderer_, backbuffer_, nullptr, nullptr);
|
|
}
|
|
}
|
|
|
|
// Actualiza las variables internas
|
|
void Fade::update() {
|
|
switch (state_) {
|
|
case State::PRE:
|
|
updatePreState();
|
|
break;
|
|
case State::FADING:
|
|
updateFadingState();
|
|
break;
|
|
case State::POST:
|
|
updatePostState();
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Compatibilidad delta-time (ignora el parámetro ya que usa SDL_GetTicks)
|
|
void Fade::update(float delta_time) {
|
|
update(); // Llama al método original
|
|
}
|
|
|
|
void Fade::updatePreState() {
|
|
// Sistema basado en tiempo únicamente
|
|
Uint32 elapsed_time = SDL_GetTicks() - pre_start_time_;
|
|
|
|
if (elapsed_time >= static_cast<Uint32>(pre_duration_)) {
|
|
state_ = State::FADING;
|
|
// CRÍTICO: Reinicializar tiempo de inicio para tipos que usan random_squares_start_time_
|
|
if (type_ == Type::RANDOM_SQUARE2 || type_ == Type::DIAGONAL) {
|
|
random_squares_start_time_ = SDL_GetTicks();
|
|
}
|
|
}
|
|
}
|
|
|
|
void Fade::updateFadingState() {
|
|
switch (type_) {
|
|
case Type::FULLSCREEN:
|
|
updateFullscreenFade();
|
|
break;
|
|
case Type::CENTER:
|
|
updateCenterFade();
|
|
break;
|
|
case Type::RANDOM_SQUARE:
|
|
updateRandomSquareFade();
|
|
break;
|
|
case Type::RANDOM_SQUARE2:
|
|
updateRandomSquare2Fade();
|
|
break;
|
|
case Type::DIAGONAL:
|
|
updateDiagonalFade();
|
|
break;
|
|
case Type::VENETIAN:
|
|
updateVenetianFade();
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
counter_++;
|
|
}
|
|
|
|
void Fade::changeToPostState() {
|
|
state_ = State::POST;
|
|
post_start_time_ = SDL_GetTicks();
|
|
}
|
|
|
|
void Fade::updatePostState() {
|
|
// Sistema basado en tiempo únicamente
|
|
Uint32 elapsed_time = SDL_GetTicks() - post_start_time_;
|
|
|
|
if (elapsed_time >= static_cast<Uint32>(post_duration_)) {
|
|
state_ = State::FINISHED;
|
|
}
|
|
|
|
// Mantener el alpha final correcto para cada tipo de fade
|
|
Uint8 post_alpha = a_;
|
|
if (type_ == Type::RANDOM_SQUARE2 || type_ == Type::DIAGONAL) {
|
|
post_alpha = (mode_ == Mode::OUT) ? 255 : 0;
|
|
}
|
|
|
|
cleanBackbuffer(r_, g_, b_, post_alpha);
|
|
}
|
|
|
|
void Fade::updateFullscreenFade() {
|
|
// Modifica la transparencia
|
|
a_ = mode_ == Mode::OUT ? std::min(counter_ * 4, 255) : 255 - std::min(counter_ * 4, 255);
|
|
SDL_SetTextureAlphaMod(backbuffer_, a_);
|
|
|
|
// Comprueba si ha terminado
|
|
if (counter_ >= 255 / 4) {
|
|
changeToPostState();
|
|
}
|
|
}
|
|
|
|
void Fade::updateCenterFade() {
|
|
drawCenterFadeRectangles();
|
|
|
|
// Comprueba si ha terminado
|
|
if ((counter_ * 4) > param.game.height) {
|
|
a_ = 255;
|
|
changeToPostState();
|
|
}
|
|
}
|
|
|
|
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);
|
|
}
|
|
|
|
SDL_SetRenderTarget(renderer_, temp);
|
|
}
|
|
|
|
void Fade::updateRandomSquareFade() {
|
|
Uint32 elapsed_time = SDL_GetTicks() - random_squares_start_time_;
|
|
float progress = static_cast<float>(elapsed_time) / random_squares_duration_;
|
|
|
|
// Calcula cuántos cuadrados deberían estar activos
|
|
int total_squares = num_squares_width_ * num_squares_height_;
|
|
int active_squares = static_cast<int>(progress * total_squares);
|
|
active_squares = std::min(active_squares, total_squares);
|
|
|
|
// Dibuja los cuadrados activos
|
|
drawRandomSquares(active_squares);
|
|
|
|
value_ = calculateValue(0, total_squares, active_squares);
|
|
|
|
// Comprueba si ha terminado
|
|
if (elapsed_time >= static_cast<Uint32>(random_squares_duration_)) {
|
|
changeToPostState();
|
|
}
|
|
}
|
|
|
|
void Fade::updateRandomSquare2Fade() {
|
|
Uint32 elapsed_time = SDL_GetTicks() - random_squares_start_time_;
|
|
|
|
int total_squares = num_squares_width_ * num_squares_height_;
|
|
|
|
// Calcula el tiempo de activación: total - tiempo que necesitan los últimos cuadrados
|
|
int activation_time = random_squares_duration_ - square_transition_duration_;
|
|
activation_time = std::max(activation_time, square_transition_duration_); // Mínimo igual a la duración de transición
|
|
|
|
// Lógica diferente según el modo
|
|
int squares_to_activate = 0;
|
|
|
|
if (mode_ == Mode::OUT) {
|
|
// OUT: Activa cuadrados gradualmente
|
|
if (elapsed_time < static_cast<Uint32>(activation_time)) {
|
|
float activation_progress = static_cast<float>(elapsed_time) / activation_time;
|
|
squares_to_activate = static_cast<int>(activation_progress * total_squares);
|
|
} else {
|
|
squares_to_activate = total_squares; // Activar todos
|
|
}
|
|
|
|
// Activa nuevos cuadrados y guarda su tiempo de activación
|
|
for (int i = 0; i < squares_to_activate && i < total_squares; ++i) {
|
|
if (square_age_[i] == -1) {
|
|
square_age_[i] = elapsed_time; // Guarda el tiempo de activación
|
|
}
|
|
}
|
|
} else {
|
|
// IN: Todos los cuadrados empiezan activos desde el inicio
|
|
squares_to_activate = total_squares;
|
|
|
|
// Activa cuadrados gradualmente con tiempo de inicio escalonado
|
|
float activation_progress = static_cast<float>(elapsed_time) / activation_time;
|
|
int squares_starting_transition = static_cast<int>(activation_progress * total_squares);
|
|
|
|
// Asegurar que al menos 1 cuadrado se active desde el primer frame
|
|
squares_starting_transition = std::max(squares_starting_transition, 1);
|
|
squares_starting_transition = std::min(squares_starting_transition, total_squares);
|
|
|
|
for (int i = 0; i < squares_starting_transition; ++i) {
|
|
if (square_age_[i] == -1) {
|
|
square_age_[i] = elapsed_time; // Empieza la transición a transparente
|
|
}
|
|
}
|
|
}
|
|
|
|
drawRandomSquares2();
|
|
|
|
value_ = calculateValue(0, total_squares, squares_to_activate);
|
|
|
|
// Comprueba si ha terminado - todos los cuadrados han completado su transición
|
|
bool all_completed = (squares_to_activate >= total_squares);
|
|
if (all_completed) {
|
|
// Verificar que todos han completado su transición individual
|
|
for (int i = 0; i < total_squares; ++i) {
|
|
if (square_age_[i] >= 0) { // Cuadrado activado
|
|
Uint32 square_elapsed = elapsed_time - square_age_[i];
|
|
if (square_elapsed < static_cast<Uint32>(square_transition_duration_)) {
|
|
all_completed = false;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (all_completed) {
|
|
// Pintar textura final: OUT opaca, IN transparente
|
|
Uint8 final_alpha = (mode_ == Mode::OUT) ? 255 : 0;
|
|
cleanBackbuffer(r_, g_, b_, final_alpha);
|
|
changeToPostState();
|
|
}
|
|
}
|
|
}
|
|
|
|
void Fade::updateDiagonalFade() {
|
|
Uint32 elapsed_time = SDL_GetTicks() - random_squares_start_time_;
|
|
|
|
int total_squares = num_squares_width_ * num_squares_height_;
|
|
|
|
// Calcula el tiempo de activación: total - tiempo que necesitan los últimos cuadrados
|
|
int activation_time = random_squares_duration_ - square_transition_duration_;
|
|
activation_time = std::max(activation_time, square_transition_duration_);
|
|
|
|
// Calcula cuántas diagonales deberían estar activas
|
|
int max_diagonal = num_squares_width_ + num_squares_height_ - 1; // Número total de diagonales
|
|
int active_diagonals = 0;
|
|
|
|
if (mode_ == Mode::OUT) {
|
|
// OUT: Activa diagonales gradualmente desde esquina superior izquierda
|
|
if (elapsed_time < static_cast<Uint32>(activation_time)) {
|
|
float activation_progress = static_cast<float>(elapsed_time) / activation_time;
|
|
active_diagonals = static_cast<int>(activation_progress * max_diagonal);
|
|
} else {
|
|
active_diagonals = max_diagonal; // Activar todas
|
|
}
|
|
|
|
// Activa cuadrados por diagonales
|
|
for (int diagonal = 0; diagonal < active_diagonals; ++diagonal) {
|
|
activateDiagonal(diagonal, elapsed_time);
|
|
}
|
|
} else {
|
|
// IN: Todas las diagonales empiezan activas, van desapareciendo
|
|
active_diagonals = max_diagonal;
|
|
|
|
// Activa diagonales gradualmente para transición
|
|
if (elapsed_time < static_cast<Uint32>(activation_time)) {
|
|
float activation_progress = static_cast<float>(elapsed_time) / activation_time;
|
|
int diagonals_starting_transition = static_cast<int>(activation_progress * max_diagonal);
|
|
|
|
for (int diagonal = 0; diagonal < diagonals_starting_transition; ++diagonal) {
|
|
activateDiagonal(diagonal, elapsed_time);
|
|
}
|
|
} else {
|
|
// Activar transición en todas las diagonales restantes
|
|
for (int diagonal = 0; diagonal < max_diagonal; ++diagonal) {
|
|
activateDiagonal(diagonal, elapsed_time);
|
|
}
|
|
}
|
|
}
|
|
|
|
drawDiagonal();
|
|
|
|
value_ = calculateValue(0, total_squares, active_diagonals * (total_squares / max_diagonal));
|
|
|
|
// Comprueba si ha terminado - todas las diagonales activadas y último cuadrado completó transición
|
|
bool all_completed = (active_diagonals >= max_diagonal);
|
|
if (all_completed) {
|
|
// Verificar que todos han completado su transición individual
|
|
for (int i = 0; i < total_squares; ++i) {
|
|
if (square_age_[i] >= 0) { // Cuadrado activado
|
|
Uint32 square_elapsed = elapsed_time - square_age_[i];
|
|
if (square_elapsed < static_cast<Uint32>(square_transition_duration_)) {
|
|
all_completed = false;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (all_completed) {
|
|
// Pintar textura final: OUT opaca, IN transparente
|
|
Uint8 final_alpha = (mode_ == Mode::OUT) ? 255 : 0;
|
|
cleanBackbuffer(r_, g_, b_, final_alpha);
|
|
changeToPostState();
|
|
}
|
|
}
|
|
}
|
|
|
|
void Fade::activateDiagonal(int diagonal_index, Uint32 current_time) {
|
|
// Para cada diagonal, activamos los cuadrados que pertenecen a esa diagonal
|
|
// Diagonal 0: (0,0)
|
|
// Diagonal 1: (1,0), (0,1)
|
|
// Diagonal 2: (2,0), (1,1), (0,2)
|
|
// etc.
|
|
|
|
for (int x = 0; x < num_squares_width_; ++x) {
|
|
int y = diagonal_index - x;
|
|
|
|
// Verificar que y está dentro de los límites
|
|
if (y >= 0 && y < num_squares_height_) {
|
|
// Convertir coordenadas (x,y) a índice en el vector
|
|
int index = y * num_squares_width_ + x;
|
|
|
|
if (index >= 0 && index < static_cast<int>(square_age_.size())) {
|
|
if (square_age_[index] == -1) {
|
|
square_age_[index] = current_time; // Guarda el tiempo de activación
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void Fade::drawDiagonal() {
|
|
auto *temp = SDL_GetRenderTarget(renderer_);
|
|
SDL_SetRenderTarget(renderer_, backbuffer_);
|
|
|
|
// CRÍTICO: Limpiar la textura antes de dibujar
|
|
SDL_SetRenderDrawColor(renderer_, 0, 0, 0, 0);
|
|
SDL_RenderClear(renderer_);
|
|
|
|
SDL_BlendMode blend_mode;
|
|
SDL_GetRenderDrawBlendMode(renderer_, &blend_mode);
|
|
SDL_SetRenderDrawBlendMode(renderer_, SDL_BLENDMODE_BLEND); // Usar BLEND para alpha
|
|
|
|
Uint32 current_time = SDL_GetTicks() - random_squares_start_time_;
|
|
|
|
// Lógica unificada: sobre textura transparente, pintar cuadrados según su estado
|
|
for (size_t i = 0; i < square_.size(); ++i) {
|
|
Uint8 current_alpha = 0;
|
|
|
|
if (square_age_[i] == -1) {
|
|
// Cuadrado no activado
|
|
if (mode_ == Mode::OUT) {
|
|
current_alpha = 0; // OUT: transparente si no activado
|
|
} else {
|
|
current_alpha = a_; // IN: opaco si no activado
|
|
}
|
|
} else {
|
|
// Cuadrado activado - calculamos progreso
|
|
Uint32 square_elapsed = current_time - square_age_[i];
|
|
float progress = std::min(static_cast<float>(square_elapsed) / square_transition_duration_, 1.0f);
|
|
|
|
if (mode_ == Mode::OUT) {
|
|
current_alpha = static_cast<Uint8>(progress * a_); // 0 → 255
|
|
} else {
|
|
current_alpha = static_cast<Uint8>((1.0f - progress) * a_); // 255 → 0
|
|
}
|
|
}
|
|
|
|
if (current_alpha > 0) {
|
|
SDL_SetRenderDrawColor(renderer_, r_, g_, b_, current_alpha);
|
|
SDL_RenderFillRect(renderer_, &square_[i]);
|
|
}
|
|
}
|
|
|
|
SDL_SetRenderDrawBlendMode(renderer_, blend_mode);
|
|
SDL_SetRenderTarget(renderer_, temp);
|
|
}
|
|
|
|
void Fade::drawRandomSquares(int active_count) {
|
|
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 solo los cuadrados activos
|
|
for (int i = 0; i < active_count && i < static_cast<int>(square_.size()); ++i) {
|
|
SDL_RenderFillRect(renderer_, &square_[i]);
|
|
}
|
|
|
|
SDL_SetRenderDrawBlendMode(renderer_, blend_mode);
|
|
SDL_SetRenderTarget(renderer_, temp);
|
|
}
|
|
|
|
void Fade::drawRandomSquares2() {
|
|
auto *temp = SDL_GetRenderTarget(renderer_);
|
|
SDL_SetRenderTarget(renderer_, backbuffer_);
|
|
|
|
// CRÍTICO: Limpiar la textura antes de dibujar
|
|
SDL_SetRenderDrawColor(renderer_, 0, 0, 0, 0);
|
|
SDL_RenderClear(renderer_);
|
|
|
|
SDL_BlendMode blend_mode;
|
|
SDL_GetRenderDrawBlendMode(renderer_, &blend_mode);
|
|
SDL_SetRenderDrawBlendMode(renderer_, SDL_BLENDMODE_BLEND); // Usar BLEND para alpha
|
|
|
|
Uint32 current_time = SDL_GetTicks() - random_squares_start_time_;
|
|
|
|
// Lógica unificada: sobre textura transparente, pintar cuadrados según su estado
|
|
for (size_t i = 0; i < square_.size(); ++i) {
|
|
Uint8 current_alpha = 0;
|
|
|
|
if (square_age_[i] == -1) {
|
|
// Cuadrado no activado
|
|
if (mode_ == Mode::OUT) {
|
|
current_alpha = 0; // OUT: transparente si no activado
|
|
} else {
|
|
current_alpha = a_; // IN: opaco si no activado
|
|
}
|
|
} else {
|
|
// Cuadrado activado - calculamos progreso
|
|
Uint32 square_elapsed = current_time - square_age_[i];
|
|
float progress = std::min(static_cast<float>(square_elapsed) / square_transition_duration_, 1.0f);
|
|
|
|
if (mode_ == Mode::OUT) {
|
|
current_alpha = static_cast<Uint8>(progress * a_); // 0 → 255
|
|
} else {
|
|
current_alpha = static_cast<Uint8>((1.0f - progress) * a_); // 255 → 0
|
|
}
|
|
}
|
|
|
|
if (current_alpha > 0) {
|
|
SDL_SetRenderDrawColor(renderer_, r_, g_, b_, current_alpha);
|
|
SDL_RenderFillRect(renderer_, &square_[i]);
|
|
}
|
|
}
|
|
|
|
SDL_SetRenderDrawBlendMode(renderer_, blend_mode);
|
|
SDL_SetRenderTarget(renderer_, temp);
|
|
}
|
|
|
|
void Fade::updateVenetianFade() {
|
|
if (square_.back().h < param.fade.venetian_size) {
|
|
drawVenetianBlinds();
|
|
updateVenetianRectangles();
|
|
calculateVenetianProgress();
|
|
} else {
|
|
changeToPostState();
|
|
}
|
|
}
|
|
|
|
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<int>(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
|
|
if (state_ != State::NOT_ENABLED) {
|
|
return;
|
|
}
|
|
|
|
state_ = State::PRE;
|
|
counter_ = 0;
|
|
pre_start_time_ = SDL_GetTicks();
|
|
|
|
switch (type_) {
|
|
case Type::FULLSCREEN: {
|
|
// Pinta el backbuffer_ de color sólido
|
|
cleanBackbuffer(r_, g_, b_, 255);
|
|
break;
|
|
}
|
|
|
|
case Type::CENTER: {
|
|
rect1_ = {.x = 0, .y = 0, .w = param.game.width, .h = 0};
|
|
rect2_ = {.x = 0, .y = 0, .w = param.game.width, .h = 0};
|
|
a_ = 64;
|
|
break;
|
|
}
|
|
|
|
case Type::RANDOM_SQUARE: {
|
|
rect1_ = {.x = 0, .y = 0, .w = static_cast<float>(param.game.width / num_squares_width_), .h = static_cast<float>(param.game.height / num_squares_height_)};
|
|
square_.clear();
|
|
|
|
// Añade los cuadrados al vector
|
|
for (int i = 0; i < num_squares_width_ * num_squares_height_; ++i) {
|
|
rect1_.x = (i % num_squares_width_) * rect1_.w;
|
|
rect1_.y = (i / num_squares_width_) * rect1_.h;
|
|
square_.push_back(rect1_);
|
|
}
|
|
|
|
// Desordena el vector de cuadrados
|
|
auto num = num_squares_width_ * num_squares_height_;
|
|
while (num > 1) {
|
|
auto num_arreu = rand() % num;
|
|
SDL_FRect temp = square_[num_arreu];
|
|
square_[num_arreu] = square_[num - 1];
|
|
square_[num - 1] = temp;
|
|
num--;
|
|
}
|
|
|
|
// Limpia la textura
|
|
a_ = mode_ == Mode::OUT ? 0 : 255;
|
|
cleanBackbuffer(r_, g_, b_, a_);
|
|
|
|
// Deja el color listo para usar
|
|
a_ = mode_ == Mode::OUT ? 255 : 0;
|
|
|
|
// Inicializa el tiempo de inicio
|
|
random_squares_start_time_ = SDL_GetTicks();
|
|
|
|
break;
|
|
}
|
|
|
|
case Type::RANDOM_SQUARE2: {
|
|
rect1_ = {.x = 0, .y = 0, .w = static_cast<float>(param.game.width / num_squares_width_), .h = static_cast<float>(param.game.height / num_squares_height_)};
|
|
square_.clear();
|
|
square_age_.clear();
|
|
|
|
// Añade los cuadrados al vector
|
|
for (int i = 0; i < num_squares_width_ * num_squares_height_; ++i) {
|
|
rect1_.x = (i % num_squares_width_) * rect1_.w;
|
|
rect1_.y = (i / num_squares_width_) * rect1_.h;
|
|
square_.push_back(rect1_);
|
|
square_age_.push_back(-1); // -1 indica cuadrado no activado aún
|
|
}
|
|
|
|
// Desordena el vector de cuadrados y edades
|
|
auto num = num_squares_width_ * num_squares_height_;
|
|
while (num > 1) {
|
|
auto num_arreu = rand() % num;
|
|
SDL_FRect temp_rect = square_[num_arreu];
|
|
int temp_age = square_age_[num_arreu];
|
|
square_[num_arreu] = square_[num - 1];
|
|
square_age_[num_arreu] = square_age_[num - 1];
|
|
square_[num - 1] = temp_rect;
|
|
square_age_[num - 1] = temp_age;
|
|
num--;
|
|
}
|
|
|
|
// Textura inicial: OUT transparente, IN opaca
|
|
Uint8 initial_alpha = (mode_ == Mode::OUT) ? 0 : 255;
|
|
cleanBackbuffer(r_, g_, b_, initial_alpha);
|
|
|
|
// Deja el color listo para usar (alpha target para los cuadrados)
|
|
a_ = 255; // Siempre usar 255 como alpha target
|
|
|
|
// Inicializa el tiempo de inicio y recalcula la duración de transición
|
|
random_squares_start_time_ = SDL_GetTicks();
|
|
square_transition_duration_ = std::max(random_squares_duration_ / 4, 100); // Mínimo 100ms
|
|
|
|
break;
|
|
}
|
|
|
|
case Type::DIAGONAL: {
|
|
rect1_ = {.x = 0, .y = 0, .w = static_cast<float>(param.game.width / num_squares_width_), .h = static_cast<float>(param.game.height / num_squares_height_)};
|
|
square_.clear();
|
|
square_age_.clear();
|
|
|
|
// Añade los cuadrados al vector en orden (sin desordenar)
|
|
for (int i = 0; i < num_squares_width_ * num_squares_height_; ++i) {
|
|
rect1_.x = (i % num_squares_width_) * rect1_.w;
|
|
rect1_.y = (i / num_squares_width_) * rect1_.h;
|
|
square_.push_back(rect1_);
|
|
square_age_.push_back(-1); // -1 indica cuadrado no activado aún
|
|
}
|
|
|
|
// Textura inicial: OUT transparente, IN opaca
|
|
Uint8 initial_alpha = (mode_ == Mode::OUT) ? 0 : 255;
|
|
cleanBackbuffer(r_, g_, b_, initial_alpha);
|
|
|
|
// Deja el color listo para usar (alpha target para los cuadrados)
|
|
a_ = 255; // Siempre usar 255 como alpha target
|
|
|
|
// Inicializa el tiempo de inicio y recalcula la duración de transición
|
|
random_squares_start_time_ = SDL_GetTicks();
|
|
square_transition_duration_ = std::max(random_squares_duration_ / 4, 100); // Mínimo 100ms
|
|
|
|
break;
|
|
}
|
|
|
|
case Type::VENETIAN: {
|
|
// Limpia la textura
|
|
a_ = mode_ == Mode::OUT ? 0 : 255;
|
|
cleanBackbuffer(r_, g_, b_, a_);
|
|
|
|
// Deja el color listo para usar
|
|
a_ = mode_ == Mode::OUT ? 255 : 0;
|
|
|
|
// Añade los cuadrados al vector
|
|
square_.clear();
|
|
rect1_ = {.x = 0, .y = 0, .w = param.game.width, .h = 0};
|
|
const int MAX = param.game.height / param.fade.venetian_size;
|
|
|
|
for (int i = 0; i < MAX; ++i) {
|
|
rect1_.y = i * param.fade.venetian_size;
|
|
square_.push_back(rect1_);
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Establece el color del fade
|
|
void Fade::setColor(Uint8 r, Uint8 g, Uint8 b) {
|
|
r_ = r;
|
|
g_ = g;
|
|
b_ = b;
|
|
}
|
|
|
|
// Establece el color del fade
|
|
void Fade::setColor(Color color) {
|
|
r_ = color.r;
|
|
g_ = color.g;
|
|
b_ = color.b;
|
|
}
|
|
|
|
// Limpia el backbuffer
|
|
void Fade::cleanBackbuffer(Uint8 r, Uint8 g, Uint8 b, Uint8 a) {
|
|
// Dibujamos sobre el backbuffer_
|
|
auto *temp = SDL_GetRenderTarget(renderer_);
|
|
SDL_SetRenderTarget(renderer_, backbuffer_);
|
|
|
|
// Pintamos la textura con el color del fade
|
|
SDL_SetRenderDrawColor(renderer_, r, g, b, a);
|
|
SDL_RenderClear(renderer_);
|
|
|
|
// Vuelve a dejar el renderizador como estaba
|
|
SDL_SetRenderTarget(renderer_, temp);
|
|
}
|
|
|
|
// Calcula el valor del estado del fade
|
|
auto Fade::calculateValue(int min, int max, int current) -> int {
|
|
if (current < min) {
|
|
return 0;
|
|
}
|
|
|
|
if (current > max) {
|
|
return 100;
|
|
}
|
|
|
|
return static_cast<int>(100.0 * (current - min) / (max - min));
|
|
} |