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

ja funciona el audio

Browse Source
This commit is contained in:
Sergio
2025-03-27 18:34:04 +01:00
parent e2339bd54a
commit c6288918b2
10 changed files with 221 additions and 184 deletions
Download Patch File Download Diff File Expand all files Collapse all files

174
source/screen.cpp
View File

@@ -1,6 +1,8 @@
#include "screen.h"
#include <SDL3/SDL.h> // Para SDL_PixelFormat
#include <SDL3/SDL_pixels.h> // Para SDL_PixelFormat
#include <SDL3/SDL_timer.h> // Para SDL_GetTicks
#include <SDL3/SDL_init.h> // Para SDL_Init, SDL_INIT_VIDEO
#include <algorithm> // Para max, min
#include <fstream> // Para basic_ifstream, ifstream
#include <iterator> // Para istreambuf_iterator, operator==
@@ -19,7 +21,7 @@
Screen *Screen::screen_ = nullptr;
// [SINGLETON] Crearemos el objeto con esta función estática
void Screen::init(SDL_Window *window, SDL_Renderer *renderer) { Screen::screen_ = new Screen(window, renderer); }
void Screen::init() { Screen::screen_ = new Screen(); }
// [SINGLETON] Destruiremos el objeto con esta función estática
void Screen::destroy() { delete Screen::screen_; }
@@ -28,13 +30,17 @@ void Screen::destroy() { delete Screen::screen_; }
Screen *Screen::get() { return Screen::screen_; }
// Constructor
Screen::Screen(SDL_Window *window, SDL_Renderer *renderer)
: window_(window),
renderer_(renderer),
game_canvas_(SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, param.game.width, param.game.height)),
src_rect_(SDL_FRect{0, 0, static_cast<float>(param.game.width), static_cast<float>(param.game.height)}),
Screen::Screen()
: src_rect_(SDL_FRect{0, 0, static_cast<float>(param.game.width), static_cast<float>(param.game.height)}),
dst_rect_(SDL_FRect{0, 0, static_cast<float>(param.game.width), static_cast<float>(param.game.height)})
{
// Arranca SDL VIDEO, crea la ventana y el renderizador
initSDL();
// Crea la textura de destino
game_canvas_ = SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, param.game.width, param.game.height);
SDL_SetTextureScaleMode(game_canvas_, SDL_SCALEMODE_NEAREST);
// Inicializa variables
adjustRenderLogicalSize();
@@ -46,7 +52,13 @@ Screen::Screen(SDL_Window *window, SDL_Renderer *renderer)
}
// Destructor
Screen::~Screen() { SDL_DestroyTexture(game_canvas_); }
Screen::~Screen()
{
SDL_DestroyTexture(game_canvas_);
SDL_DestroyRenderer(renderer_);
SDL_DestroyWindow(window_);
}
// Limpia la pantalla
void Screen::clean(Color color)
@@ -109,7 +121,7 @@ void Screen::toggleFullscreen()
// Cambia el tamaño de la ventana
void Screen::setWindowZoom(int zoom)
{
options.video.window.zoom = zoom;
options.window.zoom = zoom;
adjustWindowSize();
}
@@ -118,11 +130,11 @@ bool Screen::decWindowZoom()
{
if (!options.video.fullscreen)
{
const int PREVIOUS_ZOOM = options.video.window.zoom;
--options.video.window.zoom;
options.video.window.zoom = std::max(options.video.window.zoom, 1);
const int PREVIOUS_ZOOM = options.window.zoom;
--options.window.zoom;
options.window.zoom = std::max(options.window.zoom, 1);
if (options.video.window.zoom != PREVIOUS_ZOOM)
if (options.window.zoom != PREVIOUS_ZOOM)
{
adjustWindowSize();
return true;
@@ -137,11 +149,11 @@ bool Screen::incWindowZoom()
{
if (!options.video.fullscreen)
{
const int PREVIOUS_ZOOM = options.video.window.zoom;
++options.video.window.zoom;
options.video.window.zoom = std::min(options.video.window.zoom, options.video.window.max_zoom);
const int PREVIOUS_ZOOM = options.window.zoom;
++options.window.zoom;
options.window.zoom = std::min(options.window.zoom, options.window.max_zoom);
if (options.video.window.zoom != PREVIOUS_ZOOM)
if (options.window.zoom != PREVIOUS_ZOOM)
{
adjustWindowSize();
return true;
@@ -236,13 +248,11 @@ void Screen::initShaders()
// Calcula el tamaño de la ventana
void Screen::adjustWindowSize()
{
options.video.window.max_zoom = getMaxZoom();
// Establece el nuevo tamaño
if (!options.video.fullscreen)
{
const int WIDTH = param.game.width * options.video.window.zoom;
const int HEIGHT = param.game.height * options.video.window.zoom;
const int WIDTH = param.game.width * options.window.zoom;
const int HEIGHT = param.game.height * options.window.zoom;
int old_width, old_height;
SDL_GetWindowSize(window_, &old_width, &old_height);
@@ -263,21 +273,6 @@ void Screen::adjustWindowSize()
}
}
// Obtiene el tamaño máximo de zoom posible para la ventana
int Screen::getMaxZoom()
{
// Obtiene información sobre la pantalla
auto DM = SDL_GetCurrentDisplayMode(0);
// Calcula el máximo factor de zoom que se puede aplicar a la pantalla
const int MAX_ZOOM = std::min(DM->w / param.game.width, (DM->h - WINDOWS_DECORATIONS_) / param.game.height);
// Normaliza los valores de zoom
options.video.window.zoom = std::min(options.video.window.zoom, MAX_ZOOM);
return MAX_ZOOM;
}
// Renderiza todos los overlays y efectos
void Screen::renderOverlays()
{
@@ -298,4 +293,113 @@ void Screen::renderAttenuate()
SDL_SetRenderDrawColor(renderer_, 0, 0, 0, 64);
SDL_RenderFillRect(renderer_, nullptr);
}
}
// Arranca SDL VIDEO y crea la ventana
bool Screen::initSDL()
{
// Indicador de éxito
auto success = true;
// Inicializa SDL
if (!SDL_Init(SDL_INIT_VIDEO))
{
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "SDL_VIDEO could not initialize! SDL Error: %s", SDL_GetError());
success = false;
}
else
{
getDisplayInfo();
// Establece el filtro de la textura
/*if (!SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, std::to_string(static_cast<int>(options.video.filter)).c_str()))
{
SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION, "Warning: texture filtering not enabled!");
}*/
if (!SDL_SetHint(SDL_HINT_RENDER_DRIVER, "opengl"))
{
SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION, "Warning: opengl not enabled!");
}
// Crea la ventana
window_ = SDL_CreateWindow(options.window.caption.c_str(), param.game.width * options.window.zoom, param.game.height * options.window.zoom, SDL_WINDOW_OPENGL);
if (!window_)
{
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Window could not be created! SDL Error: %s", SDL_GetError());
success = false;
}
else
{
// Crea un renderizador para la ventana. El vsync se activa en función de las opciones
// Uint32 flags = 0;
if (options.video.v_sync)
{
// flags = SDL_RENDERER_PRESENTVSYNC;
}
// La aceleración se activa según el define
// flags = flags | SDL_RENDERER_ACCELERATED | SDL_RENDERER_TARGETTEXTURE;
renderer_ = SDL_CreateRenderer(window_, nullptr);
if (!renderer_)
{
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Renderer could not be created! SDL Error: %s", SDL_GetError());
success = false;
}
else
{
SDL_SetRenderDrawColor(renderer_, 0x00, 0x00, 0x00, 0xFF);
SDL_SetRenderLogicalPresentation(renderer_, param.game.width, param.game.height, SDL_LOGICAL_PRESENTATION_INTEGER_SCALE);
SDL_SetWindowFullscreen(window_, static_cast<Uint32>(options.video.fullscreen));
SDL_SetRenderDrawBlendMode(renderer_, SDL_BLENDMODE_BLEND);
}
}
}
SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, "SDL_VIDEO: Initialization complete.");
return success;
}
// Obtiene información sobre la pantalla
void Screen::getDisplayInfo()
{
int i, num_displays = 0;
SDL_DisplayID *displays = SDL_GetDisplays(&num_displays);
if (displays)
{
for (i = 0; i < num_displays; ++i)
{
SDL_DisplayID instance_id = displays[i];
const char *name = SDL_GetDisplayName(instance_id);
SDL_Log("Display %" SDL_PRIu32 ": %s", instance_id, name ? name : "Unknown");
}
auto DM = SDL_GetCurrentDisplayMode(displays[0]);
// Calcula el máximo factor de zoom que se puede aplicar a la pantalla
options.window.max_zoom = std::min(DM->w / param.game.width, DM->h / param.game.height);
options.window.zoom = std::min(options.window.zoom, options.window.max_zoom);
// Muestra información sobre el tamaño de la pantalla y de la ventana de juego
SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, "Current display mode: %dx%d @ %dHz",
static_cast<int>(DM->w), static_cast<int>(DM->h), static_cast<int>(DM->refresh_rate));
SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, "Window resolution: %dx%d x%d",
static_cast<int>(param.game.width), static_cast<int>(param.game.height), options.window.zoom);
options.video.info = std::to_string(static_cast<int>(DM->w)) + " X " +
std::to_string(static_cast<int>(DM->h)) + " AT " +
std::to_string(static_cast<int>(DM->refresh_rate)) + " HZ";
// Calcula el máximo factor de zoom que se puede aplicar a la pantalla
const int MAX_ZOOM = std::min(DM->w / param.game.width, (DM->h - WINDOWS_DECORATIONS_) / param.game.height);
// Normaliza los valores de zoom
options.window.zoom = std::min(options.window.zoom, MAX_ZOOM);
SDL_free(displays);
}
}