jaildesigner-jailgames/coffee_crisis_arcade_edition
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 13 Wiki Activity

Continuem estandaritzant noms

Browse Source
This commit is contained in:
Sergio
2024-10-11 13:54:43 +02:00
parent e1fa1d2102
commit a9ca23138d
15 changed files with 866 additions and 849 deletions
Download Patch File Download Diff File Expand all files Collapse all files

247
source/fade.cpp
View File

@@ -7,12 +7,12 @@
#include "utils.h" // for Param, ParamGame, ParamFade
// Constructor
Fade::Fade(SDL_Renderer *renderer)
: renderer(renderer)
Fade::Fade(SDL_Renderer *renderer_)
: renderer_(renderer_)
{
// 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);
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();
@@ -21,64 +21,65 @@ Fade::Fade(SDL_Renderer *renderer)
// Destructor
Fade::~Fade()
{
SDL_DestroyTexture(backbuffer);
backbuffer = nullptr;
SDL_DestroyTexture(backbuffer_);
backbuffer_ = nullptr;
}
// Inicializa las variables
void Fade::init()
{
type = FadeType::CENTER;
mode = FadeMode::OUT;
enabled = false;
finished = false;
counter = 0;
r = 0;
g = 0;
b = 0;
postDuration = 20;
postCounter = 0;
numSquaresWidth = param.fade.num_squares_width;
numSquaresHeight = param.fade.num_squares_height;
fadeRandomSquaresDelay = param.fade.random_squares_delay;
fadeRandomSquaresMult = param.fade.random_squares_mult;
type_ = FadeType::CENTER;
mode_ = FadeMode::OUT;
enabled_ = false;
finished_ = false;
counter_ = 0;
r_ = 0;
g_ = 0;
b_ = 0;
a_ = 0;
post_duration_ = 20;
post_counter_ = 0;
num_squares_width_ = param.fade.num_squares_width;
num_squares_height_ = param.fade.num_squares_height;
fade_random_squares_delay_ = param.fade.random_squares_delay;
fade_random_squares_mult_ = param.fade.random_squares_mult;
}
// Resetea algunas variables para volver a hacer el fade sin perder ciertos parametros
void Fade::reset()
{
enabled = false;
finished = false;
counter = 0;
enabled_ = false;
finished_ = false;
counter_ = 0;
}
// Pinta una transición en pantalla
void Fade::render()
{
if (enabled || finished)
if (enabled_ || finished_)
{
SDL_RenderCopy(renderer, backbuffer, nullptr, nullptr);
SDL_RenderCopy(renderer_, backbuffer_, nullptr, nullptr);
}
}
// Actualiza las variables internas
void Fade::update()
{
if (enabled)
if (enabled_)
{
switch (type)
switch (type_)
{
case FadeType::FULLSCREEN:
{
// Modifica la transparencia
a = mode == FadeMode::OUT ? std::min(counter * 4, 255) : 255 - std::min(counter * 4, 255);
a_ = mode_ == FadeMode::OUT ? std::min(counter_ * 4, 255) : 255 - std::min(counter_ * 4, 255);
SDL_SetTextureAlphaMod(backbuffer, a);
SDL_SetTextureAlphaMod(backbuffer_, a_);
// Comprueba si ha terminado
if (counter >= 255 / 4)
if (counter_ >= 255 / 4)
{
finished = true;
finished_ = true;
}
break;
@@ -86,62 +87,62 @@ void Fade::update()
case FadeType::CENTER:
{
// Dibuja sobre el backbuffer
auto *temp = SDL_GetRenderTarget(renderer);
SDL_SetRenderTarget(renderer, backbuffer);
// Dibuja sobre el backbuffer_
auto temp = SDL_GetRenderTarget(renderer_);
SDL_SetRenderTarget(renderer_, backbuffer_);
SDL_SetRenderDrawColor(renderer, r, g, b, a);
SDL_SetRenderDrawColor(renderer_, r_, g_, b_, a_);
for (int i = 0; i < counter; i++)
for (int i = 0; i < counter_; i++)
{
rect1.h = rect2.h = i * 4;
rect2.y = param.game.height - (i * 4);
rect1_.h = rect2_.h = i * 4;
rect2_.y = param.game.height - (i * 4);
SDL_RenderFillRect(renderer, &rect1);
SDL_RenderFillRect(renderer, &rect2);
SDL_RenderFillRect(renderer_, &rect1_);
SDL_RenderFillRect(renderer_, &rect2_);
}
// Deja el renderizador como estaba
SDL_SetRenderTarget(renderer, temp);
SDL_SetRenderTarget(renderer_, temp);
// Comprueba si ha terminado
if ((counter * 4) > param.game.height)
if ((counter_ * 4) > param.game.height)
{
finished = true;
a = 255;
finished_ = true;
a_ = 255;
}
break;
}
case FadeType::RANDOM_SQUARE:
{
if (counter % fadeRandomSquaresDelay == 0)
if (counter_ % fade_random_squares_delay_ == 0)
{
// Dibuja sobre el backbuffer
auto *temp = SDL_GetRenderTarget(renderer);
SDL_SetRenderTarget(renderer, backbuffer);
// Dibuja sobre el backbuffer_
auto *temp = SDL_GetRenderTarget(renderer_);
SDL_SetRenderTarget(renderer_, backbuffer_);
SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_NONE);
SDL_SetRenderDrawColor(renderer, r, g, b, a);
SDL_SetRenderDrawBlendMode(renderer_, SDL_BLENDMODE_NONE);
SDL_SetRenderDrawColor(renderer_, r_, g_, b_, a_);
// Dibuja el cuadrado correspondiente
const int index = std::min(counter / fadeRandomSquaresDelay, (numSquaresWidth * numSquaresHeight) - 1);
for (int i = 0; i < fadeRandomSquaresMult; ++i)
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 * fadeRandomSquaresMult + i, (int)square.size() - 1);
SDL_RenderFillRect(renderer, &square[index2]);
const int index2 = std::min(index * fade_random_squares_mult_ + i, (int)square_.size() - 1);
SDL_RenderFillRect(renderer_, &square_[index2]);
}
SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_BLEND);
SDL_SetRenderDrawBlendMode(renderer_, SDL_BLENDMODE_BLEND);
// Deja el renderizador como estaba
SDL_SetRenderTarget(renderer, temp);
SDL_SetRenderTarget(renderer_, temp);
}
// Comprueba si ha terminado
if (counter * fadeRandomSquaresMult / fadeRandomSquaresDelay >= numSquaresWidth * numSquaresHeight)
if (counter_ * fade_random_squares_mult_ / fade_random_squares_delay_ >= num_squares_width_ * num_squares_height_)
{
finished = true;
finished_ = true;
}
break;
@@ -150,47 +151,47 @@ void Fade::update()
case FadeType::VENETIAN:
{
// Counter debe ir de 0 a 150
if (square.back().h < param.fade.venetian_size)
if (square_.back().h < param.fade.venetian_size)
{
// Dibuja sobre el backbuffer
auto *temp = SDL_GetRenderTarget(renderer);
SDL_SetRenderTarget(renderer, backbuffer);
// Dibuja sobre el backbuffer_
auto *temp = SDL_GetRenderTarget(renderer_);
SDL_SetRenderTarget(renderer_, backbuffer_);
SDL_SetRenderDrawColor(renderer, r, g, b, a);
for (auto rect : square)
SDL_SetRenderDrawColor(renderer_, r_, g_, b_, a_);
for (auto rect : square_)
{
SDL_RenderFillRect(renderer, &rect);
SDL_RenderFillRect(renderer_, &rect);
}
// Deja el renderizador como estaba
SDL_SetRenderTarget(renderer, temp);
SDL_SetRenderTarget(renderer_, temp);
const auto h = counter / 3;
for (int i = 0; i < (int)square.size(); ++i)
const auto h = counter_ / 3;
for (int i = 0; i < (int)square_.size(); ++i)
{
// A partir del segundo rectangulo se pinta en función del anterior
square[i].h = i == 0 ? h : std::max(square[i - 1].h - 3, 0);
square_[i].h = i == 0 ? h : std::max(square_[i - 1].h - 3, 0);
}
}
else
{
finished = true;
finished_ = true;
}
break;
}
}
if (finished)
if (finished_)
{
// Actualiza el contador
postCounter == postDuration ? enabled = false : postCounter++;
post_counter_ == post_duration_ ? enabled_ = false : post_counter_++;
// Deja el backbuffer todo del mismo color
cleanBackbuffer(r, g, b, a);
// Deja el backbuffer_ todo del mismo color
cleanBackbuffer(r_, g_, b_, a_);
}
counter++;
counter_++;
}
}
@@ -198,67 +199,67 @@ void Fade::update()
void Fade::activate()
{
// Si ya está habilitado, no hay que volverlo a activar
if (enabled)
if (enabled_)
{
return;
}
enabled = true;
finished = false;
counter = 0;
postCounter = 0;
enabled_ = true;
finished_ = false;
counter_ = 0;
post_counter_ = 0;
switch (type)
switch (type_)
{
case FadeType::FULLSCREEN:
{
// Pinta el backbuffer de color sólido
cleanBackbuffer(r, g, b, 255);
// Pinta el backbuffer_ de color sólido
cleanBackbuffer(r_, g_, b_, 255);
break;
}
case FadeType::CENTER:
{
rect1 = {0, 0, param.game.width, 0};
rect2 = {0, 0, param.game.width, 0};
a = 64;
rect1_ = {0, 0, param.game.width, 0};
rect2_ = {0, 0, param.game.width, 0};
a_ = 64;
break;
}
case FadeType::RANDOM_SQUARE:
{
rect1 = {0, 0, param.game.width / numSquaresWidth, param.game.height / numSquaresHeight};
square.clear();
rect1_ = {0, 0, param.game.width / num_squares_width_, param.game.height / num_squares_height_};
square_.clear();
// Añade los cuadrados al vector
for (int i = 0; i < numSquaresWidth * numSquaresHeight; ++i)
for (int i = 0; i < num_squares_width_ * num_squares_height_; ++i)
{
rect1.x = (i % numSquaresWidth) * rect1.w;
rect1.y = (i / numSquaresWidth) * rect1.h;
square.push_back(rect1);
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 = numSquaresWidth * numSquaresHeight;
auto num = num_squares_width_ * num_squares_height_;
while (num > 1)
{
auto num_arreu = rand() % num;
SDL_Rect temp = square[num_arreu];
square[num_arreu] = square[num - 1];
square[num - 1] = temp;
SDL_Rect temp = square_[num_arreu];
square_[num_arreu] = square_[num - 1];
square_[num - 1] = temp;
num--;
}
// Limpia la textura
auto *temp = SDL_GetRenderTarget(renderer);
SDL_SetRenderTarget(renderer, backbuffer);
a = mode == FadeMode::OUT ? 0 : 255;
SDL_SetRenderDrawColor(renderer, r, g, b, a);
SDL_RenderClear(renderer);
SDL_SetRenderTarget(renderer, temp);
auto temp = SDL_GetRenderTarget(renderer_);
SDL_SetRenderTarget(renderer_, backbuffer_);
a_ = mode_ == FadeMode::OUT ? 0 : 255;
SDL_SetRenderDrawColor(renderer_, r_, g_, b_, a_);
SDL_RenderClear(renderer_);
SDL_SetRenderTarget(renderer_, temp);
// Deja el color listo para usar
a = mode == FadeMode::OUT ? 255 : 0;
a_ = mode_ == FadeMode::OUT ? 255 : 0;
break;
}
@@ -266,17 +267,17 @@ void Fade::activate()
case FadeType::VENETIAN:
{
cleanBackbuffer(0, 0, 0, 0);
rect1 = {0, 0, param.game.width, 0};
square.clear();
a = 255;
rect1_ = {0, 0, param.game.width, 0};
square_.clear();
a_ = 255;
// Añade los cuadrados al vector
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);
rect1_.y = i * param.fade.venetian_size;
square_.push_back(rect1_);
}
break;
@@ -287,53 +288,53 @@ void Fade::activate()
// Comprueba si está activo
bool Fade::isEnabled() const
{
return enabled;
return enabled_;
}
// Comprueba si ha terminado la transicion
bool Fade::hasEnded() const
{
// Ha terminado cuando ha finalizado la transición y se ha deshabilitado
return !enabled && finished;
return !enabled_ && finished_;
}
// Establece el tipo de fade
void Fade::setType(FadeType type)
void Fade::setType(FadeType type_)
{
this->type = type;
type_ = type_;
}
// Establece el modo de fade
void Fade::setMode(FadeMode mode)
{
this->mode = mode;
mode_ = mode;
}
// Establece el color del fade
void Fade::setColor(Uint8 r, Uint8 g, Uint8 b)
{
this->r = r;
this->g = g;
this->b = b;
r_ = r;
g_ = g;
b_ = b;
}
// Establece la duración posterior
void Fade::setPost(int value)
{
postDuration = value;
post_duration_ = value;
}
// 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);
// 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);
SDL_SetRenderDrawColor(renderer_, r, g, b, a);
SDL_RenderClear(renderer_);
// Vuelve a dejar el renderizador como estaba
SDL_SetRenderTarget(renderer, temp);
SDL_SetRenderTarget(renderer_, temp);
}