jaildesigner-demos/demo5_sprites_bouncing
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

migrat a SDL3

Browse Source
This commit is contained in:
Sergio
2025-03-24 12:48:32 +01:00
parent 111cbb2217
commit 4a2e5c27e2
13 changed files with 366 additions and 309 deletions
Download Patch File Download Diff File Expand all files Collapse all files

109
.gitignore vendored
View File

@@ -1,4 +1,107 @@
*.exe demo5_sprites_bouncing
*.dll
*.out
build/ build/
# ---> C++
# Prerequisites
*.d
# Compiled Object files
*.slo
*.lo
*.o
*.obj
# Precompiled Headers
*.gch
*.pch
# Compiled Dynamic libraries
*.so
*.dylib
*.dll
# Fortran module files
*.mod
*.smod
# Compiled Static libraries
*.lai
*.la
*.a
*.lib
# Executables
*.exe
*.out
*.app
# ---> macOS
# General
.DS_Store
.AppleDouble
.LSOverride
# Icon must end with two \r
Icon
# Thumbnails
._*
# Files that might appear in the root of a volume
.DocumentRevisions-V100
.fseventsd
.Spotlight-V100
.TemporaryItems
.Trashes
.VolumeIcon.icns
.com.apple.timemachine.donotpresent
# Directories potentially created on remote AFP share
.AppleDB
.AppleDesktop
Network Trash Folder
Temporary Items
.apdisk
# ---> Windows
# Windows thumbnail cache files
Thumbs.db
Thumbs.db:encryptable
ehthumbs.db
ehthumbs_vista.db
# Dump file
*.stackdump
# Folder config file
[Dd]esktop.ini
# Recycle Bin used on file shares
$RECYCLE.BIN/
# Windows Installer files
*.cab
*.msi
*.msix
*.msm
*.msp
# Windows shortcuts
*.lnk
# ---> Linux
*~
# temporary files which can be created if a process still has a handle open of a deleted file
.fuse_hidden*
# KDE directory preferences
.directory
# Linux trash folder which might appear on any partition or disk
.Trash-*
# .nfs files are created when an open file is removed but is still being accessed
.nfs*

50
.vscode/settings.json vendored
View File

@@ -1,50 +0,0 @@
{
"files.associations": {
"iostream": "cpp",
"array": "cpp",
"atomic": "cpp",
"bit": "cpp",
"*.tcc": "cpp",
"cctype": "cpp",
"clocale": "cpp",
"cmath": "cpp",
"compare": "cpp",
"concepts": "cpp",
"cstdarg": "cpp",
"cstddef": "cpp",
"cstdint": "cpp",
"cstdio": "cpp",
"cstdlib": "cpp",
"cwchar": "cpp",
"cwctype": "cpp",
"deque": "cpp",
"string": "cpp",
"unordered_map": "cpp",
"vector": "cpp",
"exception": "cpp",
"algorithm": "cpp",
"functional": "cpp",
"iterator": "cpp",
"memory": "cpp",
"memory_resource": "cpp",
"numeric": "cpp",
"optional": "cpp",
"random": "cpp",
"string_view": "cpp",
"system_error": "cpp",
"tuple": "cpp",
"type_traits": "cpp",
"utility": "cpp",
"initializer_list": "cpp",
"iosfwd": "cpp",
"istream": "cpp",
"limits": "cpp",
"new": "cpp",
"numbers": "cpp",
"ostream": "cpp",
"stdexcept": "cpp",
"streambuf": "cpp",
"cinttypes": "cpp",
"typeinfo": "cpp"
}
}

49
CMakeLists.txt Normal file
View File

@@ -0,0 +1,49 @@
cmake_minimum_required(VERSION 3.20)
project(demo5_sprites_bouncing)
# Establecer el estándar de C++
set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
# Opciones comunes de compilación
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Os -ffunction-sections -fdata-sections")
# Buscar SDL3 automáticamente
find_package(SDL3 REQUIRED)
# Si no se encuentra SDL3, generar un error
if (NOT SDL3_FOUND)
message(FATAL_ERROR "SDL3 no encontrado. Por favor, verifica su instalación.")
endif()
# Archivos fuente
file(GLOB SOURCE_FILES source/*.cpp)
# Comprobar si se encontraron archivos fuente
if(NOT SOURCE_FILES)
message(FATAL_ERROR "No se encontraron archivos fuente en el directorio 'source/'. Verifica la ruta.")
endif()
# Detectar la plataforma y configuraciones específicas
if(WIN32)
set(PLATFORM windows)
set(LINK_LIBS ${SDL3_LIBRARIES} mingw32 ws2_32)
elseif(UNIX AND NOT APPLE)
set(PLATFORM linux)
set(LINK_LIBS ${SDL3_LIBRARIES})
elseif(APPLE)
set(PLATFORM macos)
set(LINK_LIBS ${SDL3_LIBRARIES})
endif()
# Incluir directorios de SDL3
include_directories(${SDL3_INCLUDE_DIRS})
# Añadir el ejecutable reutilizando el nombre del proyecto
add_executable(${PROJECT_NAME} ${SOURCE_FILES})
# Especificar la ubicación del ejecutable (en la raíz del proyecto)
set_target_properties(${PROJECT_NAME} PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR})
# Enlazar las bibliotecas necesarias
target_link_libraries(${PROJECT_NAME} ${LINK_LIBS})

45
Makefile
View File

@@ -1,43 +1,22 @@
# Variables comunes # Variables comunes
source := source/*.cpp SOURCE := source/*.cpp
executable_name := demo_pelotas2 EXECUTABLE_NAME := demo5_sprites_bouncing
CXX := g++ # Cambiar a clang++ si lo prefieres CXXFLAGS := -std=c++20 -Wall -Os -ffunction-sections -fdata-sections # Opciones comunes de compilación
CXXFLAGS := -std=c++11 -Wall # Opciones comunes de compilación LDFLAGS := -lSDL3 # Flags de enlace comunes
LDFLAGS := -lSDL2 # Opciones comunes de enlace OUTPUT_EXT :=
# Detectar plataforma # Detectar plataforma y configurar
ifeq ($(OS),Windows_NT) ifeq ($(OS),Windows_NT)
PLATFORM := windows LDFLAGS += -lmingw32 -lws2_32
LDFLAGS += -lmingw32 -lws2_32 -lSDL2main
OUTPUT_EXT := .exe OUTPUT_EXT := .exe
else else
UNAME_S := $(shell uname -s)
ifeq ($(UNAME_S),Linux)
PLATFORM := linux
OUTPUT_EXT := .out OUTPUT_EXT := .out
endif
ifeq ($(UNAME_S),Darwin) # macOS
PLATFORM := macos
CXX := clang++ # Usar clang++ en macOS
OUTPUT_EXT := .out
endif
endif endif
# Regla principal: compilar según la plataforma detectada # Regla principal: compilar el ejecutable
all: $(PLATFORM) all:
$(CXX) $(SOURCE) $(CXXFLAGS) $(LDFLAGS) -o $(EXECUTABLE_NAME)$(OUTPUT_EXT)
# Regla para Windows # Regla para limpiar archivos generados
windows:
$(CXX) $(source) $(CXXFLAGS) $(LDFLAGS) -o $(executable_name)$(OUTPUT_EXT)
# Regla para Linux
linux:
$(CXX) $(source) $(CXXFLAGS) $(LDFLAGS) -o $(executable_name)$(OUTPUT_EXT)
# Regla para macOS
macos:
$(CXX) $(source) $(CXXFLAGS) $(LDFLAGS) -o $(executable_name)$(OUTPUT_EXT)
# Regla para limpiar los archivos generados
clean: clean:
rm -f $(executable_name)* rm -f $(EXECUTABLE_NAME)$(OUTPUT_EXT)

106
source/ball.cpp
View File

@@ -2,123 +2,121 @@
#include "defines.h" #include "defines.h"
// Constructor // Constructor
Ball::Ball(float x, float vx, float vy, color_t color, Texture *texture) Ball::Ball(float x, float vx, float vy, Color color, Texture *texture)
{ {
this->x = x; x_ = x;
this->y = 0.0f; y_ = 0.0f;
this->w = BALL_SIZE; w_ = BALL_SIZE;
this->h = BALL_SIZE; h_ = BALL_SIZE;
this->vx = vx; vx_ = vx;
this->vy = vy; vy_ = vy;
sprite = new Sprite(texture); sprite_ = new Sprite(texture);
sprite->setPos({(int)x, (int)y}); sprite_->setPos({(int)x, (int)y_});
sprite->setSize(BALL_SIZE, BALL_SIZE); sprite_->setSize(BALL_SIZE, BALL_SIZE);
sprite->setClip({0, 0, BALL_SIZE, BALL_SIZE}); sprite_->setClip({0, 0, BALL_SIZE, BALL_SIZE});
this->color = color; color_ = color;
g = GRAVITY; gravity_force_ = GRAVITY_FORCE;
onFloor = false; on_floor_ = false;
stopped = false; stopped_ = false;
loss = ((rand() % 30) * 0.01f) + 0.6f; loss_ = ((rand() % 30) * 0.01f) + 0.6f;
} }
// Destructor // Destructor
Ball::~Ball() Ball::~Ball()
{ {
if (sprite) if (sprite_)
{ {
delete sprite; delete sprite_;
} }
} }
// Actualiza la lógica de la clase // Actualiza la lógica de la clase
void Ball::update() void Ball::update()
{ {
if (stopped) if (stopped_)
{ {
return; return;
} }
// Aplica la gravedad a la velocidad // Aplica la gravedad a la velocidad
if (!onFloor && (y - SCREEN_HEIGHT) < BALL_SIZE * 2) if (!on_floor_ && (y_ - SCREEN_HEIGHT) < BALL_SIZE * 2)
{ {
vy += g; vy_ += gravity_force_;
} }
// Actualiza la posición en función de la velocidad // Actualiza la posición en función de la velocidad
x += vx; x_ += vx_;
y += vy; y_ += vy_;
// Comprueba las colisiones con el lateral izquierdo // Comprueba las colisiones con el lateral izquierdo
if (x < 0) if (x_ < 0)
{ {
x = 0; x_ = 0;
vx = -vx; vx_ = -vx_;
} }
// Comprueba las colisiones con el lateral derecho // Comprueba las colisiones con el lateral derecho
if (x + w > SCREEN_WIDTH) if (x_ + w_ > SCREEN_WIDTH)
{ {
x = SCREEN_WIDTH - w; x_ = SCREEN_WIDTH - w_;
vx = -vx; vx_ = -vx_;
} }
// Comprueba las colisiones con la parte superior // Comprueba las colisiones con la parte superior
if (y < 0) if (y_ < 0)
{ {
y = 0; y_ = 0;
vy = -vy; vy_ = -vy_;
//vy = -vy * loss;
} }
// Comprueba las colisiones con la parte inferior // Comprueba las colisiones con la parte inferior
if (y + h > SCREEN_HEIGHT) if (y_ + h_ > SCREEN_HEIGHT)
{ {
y = SCREEN_HEIGHT - h; y_ = SCREEN_HEIGHT - h_;
vy = -vy * loss; vy_ = -vy_ * loss_;
if (abs(vy) < 0.1f) if (abs(vy_) < 0.1f)
{ {
vy = 0.0f; vy_ = 0.0f;
onFloor = true; on_floor_ = true;
} }
} }
// Aplica rozamiento al rodar por el suelo // Aplica rozamiento al rodar por el suelo
if (onFloor) if (on_floor_)
{ {
vx = vx * 0.97f; vx_ = vx_ * 0.97f;
if (abs(vx) < 0.1f) if (abs(vx_) < 0.1f)
{ {
vx = 0.0f; vx_ = 0.0f;
stopped = true; stopped_ = true;
} }
} }
// Actualiza la posición del sprite // Actualiza la posición del sprite
sprite->setPos({(int)x, (int)y}); sprite_->setPos({(int)x_, (int)y_});
sprite->update();
} }
// Pinta la clase // Pinta la clase
void Ball::render() void Ball::render()
{ {
sprite->setColor(color.r, color.g, color.b); sprite_->setColor(color_.r, color_.g, color_.b);
sprite->render(); sprite_->render();
} }
// Modifica la velocidad // Modifica la velocidad
void Ball::modVel(float vx, float vy) void Ball::modVel(float vx, float vy)
{ {
if (stopped) if (stopped_)
{ {
this->vx = this->vx + vx; vx_ = vx_ + vx;
} }
this->vy = this->vy + vy; vy_ = vy_ + vy;
onFloor = false; on_floor_ = false;
stopped = false; stopped_ = false;
} }
// Cambia la gravedad // Cambia la gravedad
void Ball::switchGravity() void Ball::switchGravity()
{ {
g = g == 0.0f ? GRAVITY : 0.0f; gravity_force_ = gravity_force_ == 0.0f ? GRAVITY_FORCE : 0.0f;
} }

24
source/ball.h
View File

@@ -7,21 +7,21 @@
class Ball class Ball
{ {
private: private:
Sprite *sprite; // Sprite para pintar la clase Sprite *sprite_; // Sprite para pintar la clase
float x; // Posición x float x_; // Posición x
float y; // Posición y float y_; // Posición y
int w; // Ancho int w_; // Ancho
int h; // Alto int h_; // Alto
float vx, vy; // Velocidad float vx_, vy_; // Velocidad
float g; // Gravedad float gravity_force_; // Gravedad
color_t color; // Color de la pelota Color color_; // Color de la pelota
bool onFloor; // Indica si la pelota está ya en el suelo bool on_floor_; // Indica si la pelota está ya en el suelo
bool stopped; // Indica si la pelota ha terminado de moverse; bool stopped_; // Indica si la pelota ha terminado de moverse;
float loss; // Coeficiente de rebote. Pérdida de energía en cada rebote float loss_; // Coeficiente de rebote. Pérdida de energía en cada rebote
public: public:
// Constructor // Constructor
Ball(float x, float vx, float vy, color_t color, Texture *texture); Ball(float x, float vx, float vy, Color color, Texture *texture);
// Destructor // Destructor
~Ball(); ~Ball();

35
source/dbgtxt.h
View File

@@ -1,37 +1,42 @@
#pragma once #pragma once
#include <SDL2/SDL.h>
namespace
namespace { {
SDL_Texture *dbg_tex = NULL; SDL_Texture *dbg_tex = nullptr;
SDL_Renderer *dbg_ren = NULL; SDL_Renderer *dbg_ren = nullptr;
} }
void dbg_init(SDL_Renderer *renderer) { void dbg_init(SDL_Renderer *renderer)
{
dbg_ren = renderer; dbg_ren = renderer;
Uint8 font[448] = {0x42, 0x4D, 0xC0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x82, 0x01, 0x00, 0x00, 0x12, 0x0B, 0x00, 0x00, 0x12, 0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x18, 0xF3, 0x83, 0x83, 0xCF, 0x83, 0x87, 0x00, 0x00, 0xF3, 0x39, 0x39, 0xCF, 0x79, 0xF3, 0x00, 0x00, 0x01, 0xF9, 0x39, 0xCF, 0x61, 0xF9, 0x00, 0x00, 0x33, 0xF9, 0x03, 0xE7, 0x87, 0x81, 0x00, 0x00, 0x93, 0x03, 0x3F, 0xF3, 0x1B, 0x39, 0x00, 0x00, 0xC3, 0x3F, 0x9F, 0x39, 0x3B, 0x39, 0x00, 0x41, 0xE3, 0x03, 0xC3, 0x01, 0x87, 0x83, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0xE7, 0x01, 0xC7, 0x81, 0x01, 0x83, 0x00, 0x00, 0xE7, 0x1F, 0x9B, 0xE7, 0x1F, 0x39, 0x00, 0x00, 0xE7, 0x8F, 0x39, 0xE7, 0x87, 0xF9, 0x00, 0x00, 0xC3, 0xC7, 0x39, 0xE7, 0xC3, 0xC3, 0x00, 0x00, 0x99, 0xE3, 0x39, 0xE7, 0xF1, 0xE7, 0x00, 0x00, 0x99, 0xF1, 0xB3, 0xC7, 0x39, 0xF3, 0x00, 0x00, 0x99, 0x01, 0xC7, 0xE7, 0x83, 0x81, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x83, 0xE7, 0x83, 0xEF, 0x39, 0x39, 0x00, 0x00, 0x39, 0xE7, 0x39, 0xC7, 0x11, 0x11, 0x00, 0x00, 0xF9, 0xE7, 0x39, 0x83, 0x01, 0x83, 0x00, 0x00, 0x83, 0xE7, 0x39, 0x11, 0x01, 0xC7, 0x00, 0x00, 0x3F, 0xE7, 0x39, 0x39, 0x29, 0x83, 0x00, 0x00, 0x33, 0xE7, 0x39, 0x39, 0x39, 0x11, 0x00, 0x00, 0x87, 0x81, 0x39, 0x39, 0x39, 0x39, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x39, 0x39, 0x83, 0x3F, 0x85, 0x31, 0x00, 0x00, 0x39, 0x31, 0x39, 0x3F, 0x33, 0x23, 0x00, 0x00, 0x29, 0x21, 0x39, 0x03, 0x21, 0x07, 0x00, 0x00, 0x01, 0x01, 0x39, 0x39, 0x39, 0x31, 0x00, 0x00, 0x01, 0x09, 0x39, 0x39, 0x39, 0x39, 0x00, 0x00, 0x11, 0x19, 0x39, 0x39, 0x39, 0x39, 0x00, 0x00, 0x39, 0x39, 0x83, 0x03, 0x83, 0x03, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0xC1, 0x39, 0x81, 0x83, 0x31, 0x01, 0x00, 0x00, 0x99, 0x39, 0xE7, 0x39, 0x23, 0x3F, 0x00, 0x00, 0x39, 0x39, 0xE7, 0xF9, 0x07, 0x3F, 0x00, 0x00, 0x31, 0x01, 0xE7, 0xF9, 0x0F, 0x3F, 0x00, 0x00, 0x3F, 0x39, 0xE7, 0xF9, 0x27, 0x3F, 0x00, 0x00, 0x9F, 0x39, 0xE7, 0xF9, 0x33, 0x3F, 0x00, 0x00, 0xC1, 0x39, 0x81, 0xF9, 0x39, 0x3F, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x39, 0x03, 0xC3, 0x07, 0x01, 0x3F, 0x00, 0x00, 0x39, 0x39, 0x99, 0x33, 0x3F, 0x3F, 0x00, 0x00, 0x01, 0x39, 0x3F, 0x39, 0x3F, 0x3F, 0x00, 0x00, 0x39, 0x03, 0x3F, 0x39, 0x03, 0x03, 0x00, 0x00, 0x39, 0x39, 0x3F, 0x39, 0x3F, 0x3F, 0x00, 0x00, 0x93, 0x39, 0x99, 0x33, 0x3F, 0x3F, 0x00, 0x00, 0xC7, 0x03, 0xC3, 0x07, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00}; Uint8 font[448] = {0x42, 0x4D, 0xC0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x82, 0x01, 0x00, 0x00, 0x12, 0x0B, 0x00, 0x00, 0x12, 0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x18, 0xF3, 0x83, 0x83, 0xCF, 0x83, 0x87, 0x00, 0x00, 0xF3, 0x39, 0x39, 0xCF, 0x79, 0xF3, 0x00, 0x00, 0x01, 0xF9, 0x39, 0xCF, 0x61, 0xF9, 0x00, 0x00, 0x33, 0xF9, 0x03, 0xE7, 0x87, 0x81, 0x00, 0x00, 0x93, 0x03, 0x3F, 0xF3, 0x1B, 0x39, 0x00, 0x00, 0xC3, 0x3F, 0x9F, 0x39, 0x3B, 0x39, 0x00, 0x41, 0xE3, 0x03, 0xC3, 0x01, 0x87, 0x83, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0xE7, 0x01, 0xC7, 0x81, 0x01, 0x83, 0x00, 0x00, 0xE7, 0x1F, 0x9B, 0xE7, 0x1F, 0x39, 0x00, 0x00, 0xE7, 0x8F, 0x39, 0xE7, 0x87, 0xF9, 0x00, 0x00, 0xC3, 0xC7, 0x39, 0xE7, 0xC3, 0xC3, 0x00, 0x00, 0x99, 0xE3, 0x39, 0xE7, 0xF1, 0xE7, 0x00, 0x00, 0x99, 0xF1, 0xB3, 0xC7, 0x39, 0xF3, 0x00, 0x00, 0x99, 0x01, 0xC7, 0xE7, 0x83, 0x81, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x83, 0xE7, 0x83, 0xEF, 0x39, 0x39, 0x00, 0x00, 0x39, 0xE7, 0x39, 0xC7, 0x11, 0x11, 0x00, 0x00, 0xF9, 0xE7, 0x39, 0x83, 0x01, 0x83, 0x00, 0x00, 0x83, 0xE7, 0x39, 0x11, 0x01, 0xC7, 0x00, 0x00, 0x3F, 0xE7, 0x39, 0x39, 0x29, 0x83, 0x00, 0x00, 0x33, 0xE7, 0x39, 0x39, 0x39, 0x11, 0x00, 0x00, 0x87, 0x81, 0x39, 0x39, 0x39, 0x39, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x39, 0x39, 0x83, 0x3F, 0x85, 0x31, 0x00, 0x00, 0x39, 0x31, 0x39, 0x3F, 0x33, 0x23, 0x00, 0x00, 0x29, 0x21, 0x39, 0x03, 0x21, 0x07, 0x00, 0x00, 0x01, 0x01, 0x39, 0x39, 0x39, 0x31, 0x00, 0x00, 0x01, 0x09, 0x39, 0x39, 0x39, 0x39, 0x00, 0x00, 0x11, 0x19, 0x39, 0x39, 0x39, 0x39, 0x00, 0x00, 0x39, 0x39, 0x83, 0x03, 0x83, 0x03, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0xC1, 0x39, 0x81, 0x83, 0x31, 0x01, 0x00, 0x00, 0x99, 0x39, 0xE7, 0x39, 0x23, 0x3F, 0x00, 0x00, 0x39, 0x39, 0xE7, 0xF9, 0x07, 0x3F, 0x00, 0x00, 0x31, 0x01, 0xE7, 0xF9, 0x0F, 0x3F, 0x00, 0x00, 0x3F, 0x39, 0xE7, 0xF9, 0x27, 0x3F, 0x00, 0x00, 0x9F, 0x39, 0xE7, 0xF9, 0x33, 0x3F, 0x00, 0x00, 0xC1, 0x39, 0x81, 0xF9, 0x39, 0x3F, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x39, 0x03, 0xC3, 0x07, 0x01, 0x3F, 0x00, 0x00, 0x39, 0x39, 0x99, 0x33, 0x3F, 0x3F, 0x00, 0x00, 0x01, 0x39, 0x3F, 0x39, 0x3F, 0x3F, 0x00, 0x00, 0x39, 0x03, 0x3F, 0x39, 0x03, 0x03, 0x00, 0x00, 0x39, 0x39, 0x3F, 0x39, 0x3F, 0x3F, 0x00, 0x00, 0x93, 0x39, 0x99, 0x33, 0x3F, 0x3F, 0x00, 0x00, 0xC7, 0x03, 0xC3, 0x07, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00};
dbg_tex = SDL_CreateTextureFromSurface(dbg_ren, SDL_LoadBMP_RW(SDL_RWFromMem(font, 448), 1)); dbg_tex = SDL_CreateTextureFromSurface(dbg_ren, SDL_LoadBMP_IO(SDL_IOFromMem(font, 448), 1));
} }
void dbg_print(int x, int y, const char* text, Uint8 r, Uint8 g, Uint8 b) { void dbg_print(int x, int y, const char *text, Uint8 r, Uint8 g, Uint8 b)
{
int cc = 0; int cc = 0;
SDL_SetTextureColorMod(dbg_tex, r, g, b); SDL_SetTextureColorMod(dbg_tex, r, g, b);
SDL_Rect src = {0, 0, 8, 8}; SDL_FRect src = {0, 0, 8, 8};
SDL_Rect dst = {x, y, 8, 8}; SDL_FRect dst = {static_cast<float>(x), static_cast<float>(y), 8, 8};
while (text[cc] != 0) { while (text[cc] != 0)
{
if (text[cc] != 32) if (text[cc] != 32)
{ {
if (text[cc] >= 65) if (text[cc] >= 65)
{ {
src.x = ((text[cc]-65)%6)*8; src.y = ((text[cc]-65)/6)*8; src.x = ((text[cc] - 65) % 6) * 8;
src.y = ((text[cc] - 65) / 6) * 8;
} }
else else
{ {
src.x = ((text[cc]-22)%6)*8; src.y = ((text[cc]-22)/6)*8; src.x = ((text[cc] - 22) % 6) * 8;
src.y = ((text[cc] - 22) / 6) * 8;
} }
SDL_RenderCopy(dbg_ren, dbg_tex, &src, &dst); SDL_RenderTexture(dbg_ren, dbg_tex, &src, &dst);
} }
cc++; dst.x+=8; cc++;
dst.x += 8;
} }
} }

21
source/defines.h
View File

@@ -1,14 +1,17 @@
#pragma once #pragma once
#define WINDOW_CAPTION "demo_pelotas2" constexpr char WINDOW_CAPTION[] = "demo5_sprites_bouncing";
#define SCREEN_WIDTH 320
#define SCREEN_HEIGHT 240
#define WINDOW_SIZE 3
#define BALL_SIZE 8
#define GRAVITY 0.2f
#define TEXT_TIME 100
struct color_t constexpr int SCREEN_WIDTH = 320;
constexpr int SCREEN_HEIGHT = 240;
constexpr int WINDOW_SIZE = 3;
constexpr int BALL_SIZE = 8;
constexpr float GRAVITY_FORCE = 0.2f;
constexpr Uint64 DEMO_SPEED = 1000 / 60;
constexpr Uint64 TEXT_DURATION = 2000;
struct Color
{ {
int r,g,b; int r, g, b;
}; };

80
source/main.cpp
View File

@@ -1,4 +1,4 @@
#include <SDL2/SDL.h> #include <SDL3/SDL.h>
#include "texture.h" #include "texture.h"
#include "ball.h" #include "ball.h"
#include "defines.h" #include "defines.h"
@@ -13,25 +13,25 @@ Texture *texture = nullptr;
std::vector<Ball *> balls; std::vector<Ball *> balls;
int test[8] = {1, 10, 100, 500, 1000, 10000, 50000, 100000}; int test[8] = {1, 10, 100, 500, 1000, 10000, 50000, 100000};
bool shouldExit = false; // Controla si la aplicación debe cerrarse bool should_exit = false; // Controla si la aplicación debe cerrarse
Uint32 ticks = 0; // Tiempo en milisegundos para controlar la actualización Uint64 ticks = 0; // Tiempo en milisegundos para controlar la actualización
int scenario = 0; // Escenario actual basado en el número de bolas int scenario = 0; // Escenario actual basado en el número de bolas
std::string text = ""; // Texto a mostrar en pantalla std::string text = ""; // Texto a mostrar en pantalla
int textPos = 0; // Posición del texto en la pantalla int text_pos = 0; // Posición del texto en la pantalla
bool showText = true; // Determina si el texto se debe mostrar bool show_text = true; // Determina si el texto se debe mostrar
int counter = 0; // Temporizador para mostrar el texto Uint64 text_init_time = 0; // Temporizador para mostrar el texto
void deleteBalls(); // Declaración de una función para eliminar bolas void deleteBalls(); // Declaración de una función para eliminar bolas
// Establece el texto en pantalla mostrando el número de bolas actuales // Establece el texto en pantalla mostrando el número de bolas actuales
void setText() void setText()
{ {
const std::string text2 = test[scenario] == 1 ? " PELOTA" : " PELOTAS"; const std::string TEXT2 = test[scenario] == 1 ? " PELOTA" : " PELOTAS";
text = std::to_string(test[scenario]) + text2; text = std::to_string(test[scenario]) + TEXT2;
const int size = text.size() * 8; const int SIZE = text.size() * 8;
textPos = SCREEN_WIDTH / 2 - size / 2; text_pos = SCREEN_WIDTH / 2 - SIZE / 2;
counter = TEXT_TIME; text_init_time = SDL_GetTicks();
showText = true; show_text = true;
} }
// Inicializa las bolas según el escenario seleccionado // Inicializa las bolas según el escenario seleccionado
@@ -40,12 +40,12 @@ void initBalls(int value)
deleteBalls(); // Limpia las bolas actuales deleteBalls(); // Limpia las bolas actuales
for (int i = 0; i < test[value]; ++i) for (int i = 0; i < test[value]; ++i)
{ {
const int sign = ((rand() % 2) * 2) - 1; // Genera un signo aleatorio (+ o -) const int SIGN = ((rand() % 2) * 2) - 1; // Genera un signo aleatorio (+ o -)
const float x = (rand() % (SCREEN_WIDTH / 2)) + (SCREEN_WIDTH / 4); // Posición inicial en X const float X = (rand() % (SCREEN_WIDTH / 2)) + (SCREEN_WIDTH / 4); // Posición inicial en X
const float vx = (((rand() % 20) + 10) * 0.1f) * sign; // Velocidad en X const float VX = (((rand() % 20) + 10) * 0.1f) * SIGN; // Velocidad en X
const float vy = ((rand() % 60) - 30) * 0.1f; // Velocidad en Y const float VY = ((rand() % 60) - 30) * 0.1f; // Velocidad en Y
const color_t color = {(rand() % 192) + 32, (rand() % 192) + 32, (rand() % 192) + 32}; // Color aleatorio const Color COLOR = {(rand() % 192) + 32, (rand() % 192) + 32, (rand() % 192) + 32}; // Color aleatorio
Ball *b = new Ball(x, vx, vy, color, texture); Ball *b = new Ball(X, VX, VY, COLOR, texture);
balls.push_back(b); // Añadir la nueva bola al vector balls.push_back(b); // Añadir la nueva bola al vector
} }
setText(); // Actualizar el texto setText(); // Actualizar el texto
@@ -56,10 +56,10 @@ void pushUpBalls()
{ {
for (auto ball : balls) for (auto ball : balls)
{ {
const int sign = ((rand() % 2) * 2) - 1; const int SIGN = ((rand() % 2) * 2) - 1;
const float vx = (((rand() % 20) + 10) * 0.1f) * sign; const float VX = (((rand() % 20) + 10) * 0.1f) * SIGN;
const float vy = ((rand() % 40) * 0.1f) + 5; const float VY = ((rand() % 40) * 0.1f) + 5;
ball->modVel(vx, -vy); // Modifica la velocidad de la bola ball->modVel(VX, -VY); // Modifica la velocidad de la bola
} }
} }
@@ -95,7 +95,7 @@ bool init()
bool success = true; // Bandera de éxito bool success = true; // Bandera de éxito
// Inicializa SDL // Inicializa SDL
if (SDL_Init(SDL_INIT_VIDEO) < 0) if (!SDL_Init(SDL_INIT_VIDEO))
{ {
printf("¡SDL no se pudo inicializar! Error de SDL: %s\n", SDL_GetError()); printf("¡SDL no se pudo inicializar! Error de SDL: %s\n", SDL_GetError());
success = false; success = false;
@@ -103,7 +103,7 @@ bool init()
else else
{ {
// Crear ventana principal // Crear ventana principal
window = SDL_CreateWindow(WINDOW_CAPTION, SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, SCREEN_WIDTH * WINDOW_SIZE, SCREEN_HEIGHT * WINDOW_SIZE, SDL_WINDOW_SHOWN); window = SDL_CreateWindow(WINDOW_CAPTION, SCREEN_WIDTH * WINDOW_SIZE, SCREEN_HEIGHT * WINDOW_SIZE, SDL_WINDOW_OPENGL);
if (window == nullptr) if (window == nullptr)
{ {
printf("¡No se pudo crear la ventana! Error de SDL: %s\n", SDL_GetError()); printf("¡No se pudo crear la ventana! Error de SDL: %s\n", SDL_GetError());
@@ -112,7 +112,7 @@ bool init()
else else
{ {
// Crear renderizador // Crear renderizador
renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED); renderer = SDL_CreateRenderer(window, nullptr);
if (renderer == nullptr) if (renderer == nullptr)
{ {
printf("¡No se pudo crear el renderizador! Error de SDL: %s\n", SDL_GetError()); printf("¡No se pudo crear el renderizador! Error de SDL: %s\n", SDL_GetError());
@@ -124,7 +124,7 @@ bool init()
SDL_SetRenderDrawColor(renderer, 0xFF, 0xFF, 0xFF, 0xFF); SDL_SetRenderDrawColor(renderer, 0xFF, 0xFF, 0xFF, 0xFF);
// Establecer tamaño lógico para el renderizado // Establecer tamaño lógico para el renderizado
SDL_RenderSetLogicalSize(renderer, SCREEN_WIDTH, SCREEN_HEIGHT); SDL_SetRenderLogicalPresentation(renderer, SCREEN_WIDTH, SCREEN_HEIGHT, SDL_LOGICAL_PRESENTATION_INTEGER_SCALE);
} }
} }
} }
@@ -165,26 +165,26 @@ void checkEvents()
while (SDL_PollEvent(&event) != 0) while (SDL_PollEvent(&event) != 0)
{ {
// Evento de salida // Evento de salida
if (event.type == SDL_QUIT) if (event.type == SDL_EVENT_QUIT)
{ {
shouldExit = true; should_exit = true;
break; break;
} }
// Procesar eventos de teclado // Procesar eventos de teclado
if (event.type == SDL_KEYDOWN && event.key.repeat == 0) if (event.type == SDL_EVENT_KEY_DOWN && event.key.repeat == 0)
{ {
switch (event.key.keysym.sym) switch (event.key.key)
{ {
case SDLK_ESCAPE: case SDLK_ESCAPE:
shouldExit = true; should_exit = true;
break; break;
case SDLK_SPACE: case SDLK_SPACE:
pushUpBalls(); pushUpBalls();
break; break;
case SDLK_g: case SDLK_G:
switchBallsGravity(); switchBallsGravity();
break; break;
@@ -235,7 +235,7 @@ void checkEvents()
// Actualiza la lógica del juego // Actualiza la lógica del juego
void update() void update()
{ {
if (SDL_GetTicks() - ticks > 15) if (SDL_GetTicks() - ticks > DEMO_SPEED)
{ {
ticks = SDL_GetTicks(); ticks = SDL_GetTicks();
@@ -244,13 +244,9 @@ void update()
ball->update(); ball->update();
} }
if (counter > 0) if (show_text)
{ {
counter--; show_text = !(SDL_GetTicks() - text_init_time > TEXT_DURATION);
}
else
{
showText = false;
} }
} }
} }
@@ -266,9 +262,9 @@ void render()
ball->render(); ball->render();
} }
if (showText) if (show_text)
{ {
dbg_print(textPos, 8, text.c_str(), 255, 255, 255); dbg_print(text_pos, 8, text.c_str(), 255, 255, 255);
} }
SDL_RenderPresent(renderer); SDL_RenderPresent(renderer);
@@ -279,7 +275,7 @@ int main(int argc, char *args[])
{ {
init(); init();
while (!shouldExit) while (!should_exit)
{ {
update(); update();
checkEvents(); checkEvents();

35
source/sprite.cpp
View File

@@ -2,51 +2,38 @@
// Constructor // Constructor
Sprite::Sprite(Texture *texture) Sprite::Sprite(Texture *texture)
{ : texture_(texture),
this->texture = texture; pos_{0, 0, 0, 0},
pos = {0, 0, 0, 0}; clip_{0, 0, 0, 0} {}
clip = {0, 0, 0, 0};
}
// Destructor
Sprite::~Sprite()
{
}
// Establece la posición del sprite // Establece la posición del sprite
void Sprite::setPos(SDL_Point pos) void Sprite::setPos(SDL_Point pos)
{ {
this->pos.x = pos.x; pos_.x = pos.x;
this->pos.y = pos.y; pos_.y = pos.y;
} }
// Pinta el sprite // Pinta el sprite
void Sprite::render() void Sprite::render()
{ {
texture->render(&clip, &pos); texture_->render(&clip_, &pos_);
}
// Actualiza la lógica de la clase
void Sprite::update()
{
} }
// Establece el rectangulo de la textura que se va a pintar // Establece el rectangulo de la textura que se va a pintar
void Sprite::setClip(SDL_Rect clip) void Sprite::setClip(SDL_FRect clip)
{ {
this->clip = clip; clip_ = clip;
} }
// Establece el tamaño del sprite // Establece el tamaño del sprite
void Sprite::setSize(int w, int h) void Sprite::setSize(int w, int h)
{ {
this->pos.w = w; pos_.w = w;
this->pos.h = h; pos_.h = h;
} }
// Modulación de color // Modulación de color
void Sprite::setColor(int r, int g, int b) void Sprite::setColor(int r, int g, int b)
{ {
texture->setColor(r, g, b); texture_->setColor(r, g, b);
} }

17
source/sprite.h
View File

@@ -1,21 +1,21 @@
#pragma once #pragma once
#include <SDL2/SDL.h> #include <SDL3/SDL.h>
#include "texture.h" #include "texture.h"
class Sprite class Sprite
{ {
private: private:
Texture *texture; // Textura con los gráficos del sprite Texture *texture_; // Textura con los gráficos del sprite
SDL_Rect pos; // Posición y tamaño del sprite SDL_FRect pos_; // Posición y tamaño del sprite
SDL_Rect clip; // Parte de la textura que se va a dibujar SDL_FRect clip_; // Parte de la textura que se va a dibujar
public: public:
// Constructor // Constructor
Sprite(Texture *texture); explicit Sprite(Texture *texture);
// Destructor // Destructor
~Sprite(); ~Sprite() = default;
// Establece la posición del sprite // Establece la posición del sprite
void setPos(SDL_Point pos); void setPos(SDL_Point pos);
@@ -23,11 +23,8 @@ public:
// Pinta el sprite // Pinta el sprite
void render(); void render();
// Actualiza la lógica de la clase
void update();
// Establece el rectangulo de la textura que se va a pintar // Establece el rectangulo de la textura que se va a pintar
void setClip(SDL_Rect clip); void setClip(SDL_FRect clip);
// Establece el tamaño del sprite // Establece el tamaño del sprite
void setSize(int w, int h); void setSize(int w, int h);

76
source/texture.cpp
View File

@@ -1,24 +1,16 @@
#include <stdio.h>
#include <string>
#define STB_IMAGE_IMPLEMENTATION #define STB_IMAGE_IMPLEMENTATION
#include "stb_image.h" #include "stb_image.h"
#include <stdio.h>
#include <string>
#include "texture.h" #include "texture.h"
Texture::Texture(SDL_Renderer *renderer) Texture::Texture(SDL_Renderer *renderer)
{ : renderer_(renderer), texture_(nullptr), width_(0), height_(0) {}
this->renderer = renderer;
texture = nullptr;
width = 0;
height = 0;
}
Texture::Texture(SDL_Renderer *renderer, std::string filepath) Texture::Texture(SDL_Renderer *renderer, std::string file_path)
: renderer_(renderer), texture_(nullptr), width_(0), height_(0)
{ {
this->renderer = renderer; loadFromFile(file_path);
texture = nullptr;
width = 0;
height = 0;
loadFromFile(filepath);
} }
Texture::~Texture() Texture::~Texture()
@@ -26,12 +18,12 @@ Texture::~Texture()
free(); free();
} }
bool Texture::loadFromFile(std::string path) bool Texture::loadFromFile(std::string file_path)
{ {
const std::string filename = path.substr(path.find_last_of("\\/") + 1); const std::string filename = file_path.substr(file_path.find_last_of("\\/") + 1);
int req_format = STBI_rgb_alpha; int req_format = STBI_rgb_alpha;
int width, height, orig_format; int width, height, orig_format;
unsigned char *data = stbi_load(path.c_str(), &width, &height, &orig_format, req_format); unsigned char *data = stbi_load(file_path.c_str(), &width, &height, &orig_format, req_format);
if (data == nullptr) if (data == nullptr)
{ {
SDL_Log("Loading image failed: %s", stbi_failure_reason()); SDL_Log("Loading image failed: %s", stbi_failure_reason());
@@ -42,17 +34,15 @@ bool Texture::loadFromFile(std::string path)
std::cout << "Image loaded: " << filename.c_str() << std::endl; std::cout << "Image loaded: " << filename.c_str() << std::endl;
} }
int depth, pitch; int pitch;
Uint32 pixel_format; SDL_PixelFormat pixel_format;
if (req_format == STBI_rgb) if (req_format == STBI_rgb)
{ {
depth = 24;
pitch = 3 * width; // 3 bytes por pixel * pixels por linea pitch = 3 * width; // 3 bytes por pixel * pixels por linea
pixel_format = SDL_PIXELFORMAT_RGB24; pixel_format = SDL_PIXELFORMAT_RGB24;
} }
else else
{ // STBI_rgb_alpha (RGBA) { // STBI_rgb_alpha (RGBA)
depth = 32;
pitch = 4 * width; pitch = 4 * width;
pixel_format = SDL_PIXELFORMAT_RGBA32; pixel_format = SDL_PIXELFORMAT_RGBA32;
} }
@@ -61,69 +51,69 @@ bool Texture::loadFromFile(std::string path)
free(); free();
// La textura final // La textura final
SDL_Texture *newTexture = nullptr; SDL_Texture *new_texture = nullptr;
// Carga la imagen desde una ruta específica // Carga la imagen desde una ruta específica
SDL_Surface *loadedSurface = SDL_CreateRGBSurfaceWithFormatFrom((void *)data, width, height, depth, pitch, pixel_format); SDL_Surface *loaded_surface = SDL_CreateSurfaceFrom(width, height, pixel_format, (void *)data, pitch);
if (loadedSurface == nullptr) if (loaded_surface == nullptr)
{ {
std::cout << "Unable to load image " << path.c_str() << std::endl; std::cout << "Unable to load image " << file_path << std::endl;
} }
else else
{ {
// Crea la textura desde los pixels de la surface // Crea la textura desde los pixels de la surface
newTexture = SDL_CreateTextureFromSurface(renderer, loadedSurface); new_texture = SDL_CreateTextureFromSurface(renderer_, loaded_surface);
if (newTexture == nullptr) if (new_texture == nullptr)
{ {
std::cout << "Unable to create texture from " << path.c_str() << "! SDL Error: " << SDL_GetError() << std::endl; std::cout << "Unable to create texture from " << file_path << "! SDL Error: " << SDL_GetError() << std::endl;
} }
else else
{ {
// Obtiene las dimensiones de la imagen // Obtiene las dimensiones de la imagen
this->width = loadedSurface->w; width_ = loaded_surface->w;
this->height = loadedSurface->h; height_ = loaded_surface->h;
} }
// Elimina la textura cargada // Elimina la textura cargada
SDL_FreeSurface(loadedSurface); SDL_DestroySurface(loaded_surface);
} }
// Return success // Return success
stbi_image_free(data); stbi_image_free(data);
texture = newTexture; texture_ = new_texture;
return texture != nullptr; return texture_ != nullptr;
} }
void Texture::free() void Texture::free()
{ {
// Free texture if it exists // Free texture if it exists
if (texture != nullptr) if (texture_ != NULL)
{ {
SDL_DestroyTexture(texture); SDL_DestroyTexture(texture_);
texture = nullptr; texture_ = NULL;
width = 0; width_ = 0;
height = 0; height_ = 0;
} }
} }
void Texture::render(SDL_Rect *src, SDL_Rect *dst) void Texture::render(SDL_FRect *src, SDL_FRect *dst)
{ {
// Render to screen // Render to screen
SDL_RenderCopy(renderer, texture, src, dst); SDL_RenderTexture(renderer_, texture_, src, dst);
} }
int Texture::getWidth() int Texture::getWidth()
{ {
return width; return width_;
} }
int Texture::getHeight() int Texture::getHeight()
{ {
return height; return height_;
} }
// Modulación de color // Modulación de color
void Texture::setColor(int r, int g, int b) void Texture::setColor(int r, int g, int b)
{ {
SDL_SetTextureColorMod(texture, r, g, b); SDL_SetTextureColorMod(texture_, r, g, b);
} }

14
source/texture.h
View File

@@ -1,23 +1,23 @@
#pragma once #pragma once
#include <SDL2/SDL.h> #include <SDL3/SDL.h>
#include <iostream> #include <iostream>
// Texture wrapper class // Texture wrapper class
class Texture class Texture
{ {
private: private:
SDL_Renderer *renderer; SDL_Renderer *renderer_;
SDL_Texture *texture; SDL_Texture *texture_;
// Image dimensions // Image dimensions
int width; int width_;
int height; int height_;
public: public:
// Initializes variables // Initializes variables
Texture(SDL_Renderer *renderer); Texture(SDL_Renderer *renderer);
Texture(SDL_Renderer *renderer, std::string filepath); Texture(SDL_Renderer *renderer, std::string file_path);
// Deallocates memory // Deallocates memory
~Texture(); ~Texture();
@@ -29,7 +29,7 @@ public:
void free(); void free();
// Renders texture at given point // Renders texture at given point
void render(SDL_Rect *src = nullptr, SDL_Rect *dst = nullptr); void render(SDL_FRect *src = nullptr, SDL_FRect *dst = nullptr);
// Gets image dimensions // Gets image dimensions
int getWidth(); int getWidth();