102 lines
3.4 KiB
C++
102 lines
3.4 KiB
C++
// line_renderer.cpp - Implementació de renderitzat de línies
|
|
// © 1999 Visente i Sergi (versió Pascal)
|
|
// © 2025 Port a C++20 amb SDL3
|
|
|
|
#include "core/rendering/line_renderer.hpp"
|
|
|
|
#include <cmath>
|
|
|
|
#include "core/rendering/coordinate_transform.hpp"
|
|
|
|
namespace Rendering {
|
|
|
|
// [NUEVO] Color global compartit (actualitzat per ColorOscillator via
|
|
// SDLManager)
|
|
SDL_Color g_current_line_color = {255, 255, 255, 255}; // Blanc inicial
|
|
|
|
bool linea(SDL_Renderer* renderer, int x1, int y1, int x2, int y2, bool dibuixar, float brightness) {
|
|
// Algorisme de Bresenham per dibuixar línies
|
|
// Basat en el codi Pascal original
|
|
|
|
// Helper function: retorna el signe d'un nombre
|
|
auto sign = [](int x) -> int {
|
|
if (x < 0)
|
|
return -1;
|
|
if (x > 0)
|
|
return 1;
|
|
return 0;
|
|
};
|
|
|
|
// Variables per a l'algorisme (no utilitzades fins Fase 10 - detecció de
|
|
// col·lisions) int x = x1, y = y1; int xs = x2 - x1; int ys = y2 - y1; int
|
|
// xm = sign(xs); int ym = sign(ys); xs = std::abs(xs); ys = std::abs(ys);
|
|
|
|
// Suprimir warning de variable no usada
|
|
(void)sign;
|
|
|
|
// Detecció de col·lisió (TODO per Fase 10)
|
|
// El codi Pascal original llegia pixels del framebuffer bit-packed
|
|
// i comptava col·lisions. Per ara, usem SDL_RenderDrawLine i retornem false.
|
|
bool colisio = false;
|
|
|
|
// Dibuixar amb SDL3 (més eficient que Bresenham píxel a píxel)
|
|
if (dibuixar && renderer) {
|
|
// Transformar coordenades lògiques (640x480) a físiques (resolució real)
|
|
float scale = g_current_scale_factor;
|
|
int px1 = transform_x(x1, scale);
|
|
int py1 = transform_y(y1, scale);
|
|
int px2 = transform_x(x2, scale);
|
|
int py2 = transform_y(y2, scale);
|
|
|
|
// Aplicar brightness al color oscil·lat global
|
|
SDL_Color color_final;
|
|
color_final.r = static_cast<uint8_t>(g_current_line_color.r * brightness);
|
|
color_final.g = static_cast<uint8_t>(g_current_line_color.g * brightness);
|
|
color_final.b = static_cast<uint8_t>(g_current_line_color.b * brightness);
|
|
color_final.a = 255;
|
|
|
|
SDL_SetRenderDrawColor(renderer, color_final.r, color_final.g, color_final.b, 255);
|
|
|
|
// Renderitzar amb coordenades físiques
|
|
SDL_RenderLine(renderer, static_cast<float>(px1), static_cast<float>(py1),
|
|
static_cast<float>(px2), static_cast<float>(py2));
|
|
}
|
|
|
|
// Algorisme de Bresenham original (conservat per a futura detecció de
|
|
// col·lisió)
|
|
/*
|
|
if (xs > ys) {
|
|
// Línia plana (<45 graus)
|
|
int count = -(xs / 2);
|
|
while (x != x2) {
|
|
count = count + ys;
|
|
x = x + xm;
|
|
if (count > 0) {
|
|
y = y + ym;
|
|
count = count - xs;
|
|
}
|
|
// Aquí aniria la detecció de col·lisió píxel a píxel
|
|
}
|
|
} else {
|
|
// Línia pronunciada (>=45 graus)
|
|
int count = -(ys / 2);
|
|
while (y != y2) {
|
|
count = count + xs;
|
|
y = y + ym;
|
|
if (count > 0) {
|
|
x = x + xm;
|
|
count = count - ys;
|
|
}
|
|
// Aquí aniria la detecció de col·lisió píxel a píxel
|
|
}
|
|
}
|
|
*/
|
|
|
|
return colisio;
|
|
}
|
|
|
|
// [NUEVO] Establir el color global de les línies
|
|
void setLineColor(SDL_Color color) { g_current_line_color = color; }
|
|
|
|
} // namespace Rendering
|