feat(lighting): mode additive amb color per emissor
This commit is contained in:
JailDesigner committed
1 parent
24609d6c5c
commit
771ff1f6cd
10 files changed
+352
-71
No files matched your search
@@ -2,6 +2,7 @@
|
||||
|
||||
#include <SDL3/SDL.h>
|
||||
|
||||
#include <cstdint>
|
||||
#include <memory>
|
||||
#include <optional>
|
||||
#include <string>
|
||||
@@ -266,6 +267,19 @@ class Entity {
|
||||
[[nodiscard]] auto getLightFlicker() const -> bool { return light_flicker_; }
|
||||
void setLightFlicker(bool f) { light_flicker_ = f; }
|
||||
|
||||
// Color emès en mode additive (RGB 0..255 per canal). Default blanc:
|
||||
// en mode subtractive aquest valor s'ignora completament; en mode
|
||||
// additive és el tint que l'emissor afegeix al canvas. La cadena de
|
||||
// resolució (tipus → sala → spawn) el pobla via `setLightColor`.
|
||||
[[nodiscard]] auto getLightColorR() const -> std::uint8_t { return light_color_r_; }
|
||||
[[nodiscard]] auto getLightColorG() const -> std::uint8_t { return light_color_g_; }
|
||||
[[nodiscard]] auto getLightColorB() const -> std::uint8_t { return light_color_b_; }
|
||||
void setLightColor(std::uint8_t r, std::uint8_t g, std::uint8_t b) {
|
||||
light_color_r_ = r;
|
||||
light_color_g_ = g;
|
||||
light_color_b_ = b;
|
||||
}
|
||||
|
||||
// Identificador estable per al flicker. Cada Entity rep un valor
|
||||
// únic a la construcció (contador estàtic) i el conserva fins a la
|
||||
// mort — així el patró del flicker no "deriva" quan l'entitat es
|
||||
@@ -302,6 +316,9 @@ class Entity {
|
||||
static inline int s_next_light_seed{0};
|
||||
int light_seed_{++s_next_light_seed};
|
||||
bool light_flicker_{false};
|
||||
std::uint8_t light_color_r_{255};
|
||||
std::uint8_t light_color_g_{255};
|
||||
std::uint8_t light_color_b_{255};
|
||||
bool dead_{false};
|
||||
SDL_FlipMode flip_{SDL_FLIP_NONE};
|
||||
EventBus* bus_{nullptr};
|
||||
|
||||
@@ -4,6 +4,8 @@
|
||||
// consumidors que només volen la base del manager (p.ex. el smoke test
|
||||
// stand-alone) enllacen `entity_manager.cpp` sense arrossegar aquest fitxer.
|
||||
|
||||
#include <algorithm>
|
||||
#include <cstdint>
|
||||
#include <filesystem>
|
||||
#include <memory>
|
||||
#include <string>
|
||||
@@ -155,22 +157,38 @@ namespace {
|
||||
return c["height"].get_value<int>();
|
||||
}
|
||||
|
||||
// Bloc opcional `light: { radius: N, flicker: bool }` de la plantilla.
|
||||
// Si manca, el radi és 0 i l'entitat no entra a la pasada d'il·luminació.
|
||||
// `flicker` activa la modulació "tipus foc" del radi (només antorxes
|
||||
// l'haurien d'usar). La forma del gradient (3 anells) i els paràmetres
|
||||
// del flicker viuen a data/config/lighting.yaml — no cal declarar-los
|
||||
// per entitat.
|
||||
// Bloc opcional `light: { radius: N, flicker: bool, color: [r,g,b] }`
|
||||
// de la plantilla. Si manca, el radi és 0 i l'entitat no entra a la
|
||||
// pasada d'il·luminació. `flicker` activa la modulació "tipus foc"
|
||||
// del radi (només antorxes l'haurien d'usar). `color` només té
|
||||
// efecte en mode additive — defecte blanc (255,255,255). La forma
|
||||
// del gradient (3 anells) i els paràmetres del flicker viuen a
|
||||
// data/config/lighting.yaml — no cal declarar-los per entitat.
|
||||
struct LightTemplate {
|
||||
int radius{0};
|
||||
bool flicker{false};
|
||||
std::uint8_t color_r{255};
|
||||
std::uint8_t color_g{255};
|
||||
std::uint8_t color_b{255};
|
||||
};
|
||||
|
||||
// Helper compartit entre les tres capes (tipus, sala via Map, spawn)
|
||||
// per llegir `color: [r, g, b]` amb clamp defensiu a 0..255.
|
||||
auto readColorTriplet(const fkyaml::node& seq, std::uint8_t& r, std::uint8_t& g, std::uint8_t& b) -> bool {
|
||||
if (!seq.is_sequence() || seq.size() != 3) { return false; }
|
||||
r = static_cast<std::uint8_t>(std::clamp(seq[0].get_value<int>(), 0, 255));
|
||||
g = static_cast<std::uint8_t>(std::clamp(seq[1].get_value<int>(), 0, 255));
|
||||
b = static_cast<std::uint8_t>(std::clamp(seq[2].get_value<int>(), 0, 255));
|
||||
return true;
|
||||
}
|
||||
|
||||
auto readLight(const fkyaml::node& tmpl) -> LightTemplate {
|
||||
if (!tmpl.contains("light")) { return {}; }
|
||||
const auto& l = tmpl["light"];
|
||||
LightTemplate out;
|
||||
if (l.contains("radius")) { out.radius = l["radius"].get_value<int>(); }
|
||||
if (l.contains("flicker")) { out.flicker = l["flicker"].get_value<bool>(); }
|
||||
if (l.contains("color")) { readColorTriplet(l["color"], out.color_r, out.color_g, out.color_b); }
|
||||
return out;
|
||||
}
|
||||
|
||||
@@ -185,23 +203,26 @@ namespace {
|
||||
auto resolveLightWithRoom(const std::string& type, LightTemplate type_default) -> LightTemplate {
|
||||
const auto* room = Map::getRoomEmitterOverride(type);
|
||||
if (room == nullptr) { return type_default; }
|
||||
if (!room->enabled) { return {.radius = 0, .flicker = false}; }
|
||||
if (!room->enabled) { return {.radius = 0, .flicker = false, .color_r = 255, .color_g = 255, .color_b = 255}; }
|
||||
LightTemplate out = type_default;
|
||||
if (room->radius.has_value()) { out.radius = *room->radius; }
|
||||
if (room->flicker.has_value()) { out.flicker = *room->flicker; }
|
||||
if (room->color.has_value()) {
|
||||
out.color_r = (*room->color)[0];
|
||||
out.color_g = (*room->color)[1];
|
||||
out.color_b = (*room->color)[2];
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
// Aplica l'override per-spawn (si existeix) per damunt del que ja
|
||||
// viu a l'entitat (defaults del tipus + override de sala). Tres formes
|
||||
// a l'entry del YAML de nivell:
|
||||
// `light: false` → apaga aquesta instància
|
||||
// `light: true` → no canvia res; la línia és
|
||||
// informativa (la llum ja la donen
|
||||
// les capes inferiors)
|
||||
// `light: { radius, flicker }` → els camps presents sobreescriuen;
|
||||
// els absents respecten el que ja
|
||||
// duia l'entitat
|
||||
// `light: false` → apaga aquesta instància
|
||||
// `light: true` → informatiu (cau a capes inferiors)
|
||||
// `light: { radius, flicker, color: [r,g,b] }` → camps presents sobreescriuen;
|
||||
// els absents respecten el que
|
||||
// ja duia l'entitat
|
||||
void applySpawnLightOverride(Entity& entity, const fkyaml::node& spawn) {
|
||||
if (!spawn.contains("light")) { return; }
|
||||
const auto& l = spawn["light"];
|
||||
@@ -215,6 +236,12 @@ namespace {
|
||||
if (!l.is_mapping()) { return; }
|
||||
if (l.contains("radius")) { entity.setLightRadius(l["radius"].get_value<int>()); }
|
||||
if (l.contains("flicker")) { entity.setLightFlicker(l["flicker"].get_value<bool>()); }
|
||||
if (l.contains("color")) {
|
||||
std::uint8_t r{};
|
||||
std::uint8_t g{};
|
||||
std::uint8_t b{};
|
||||
if (readColorTriplet(l["color"], r, g, b)) { entity.setLightColor(r, g, b); }
|
||||
}
|
||||
}
|
||||
|
||||
// Bloc `collision: { size: [w, h], base_size: [bw, bh]?, offset: [x, y]? }`
|
||||
@@ -346,6 +373,7 @@ namespace {
|
||||
const auto LIGHT = resolveLightWithRoom(type, readLight(tmpl));
|
||||
entity->setLightRadius(LIGHT.radius);
|
||||
entity->setLightFlicker(LIGHT.flicker);
|
||||
entity->setLightColor(LIGHT.color_r, LIGHT.color_g, LIGHT.color_b);
|
||||
anchor_out = readAnchor(tmpl);
|
||||
return entity;
|
||||
}
|
||||
|
||||
@@ -150,10 +150,23 @@ void Player::loadFrom(const std::string& yaml_path) {
|
||||
void Player::readLightBlock(const fkyaml::node& yaml) {
|
||||
light_radius = 0;
|
||||
light_flicker = false;
|
||||
light_color_r = 255;
|
||||
light_color_g = 255;
|
||||
light_color_b = 255;
|
||||
if (!yaml.contains("light")) { return; }
|
||||
const auto& l = yaml["light"];
|
||||
if (l.contains("radius")) { light_radius = l["radius"].get_value<int>(); }
|
||||
if (l.contains("flicker")) { light_flicker = l["flicker"].get_value<bool>(); }
|
||||
// `color: [r, g, b]` opcional, bytes 0..255. Si manca, blanc (sense
|
||||
// tint) — comportament idèntic al mode subtractive de hui.
|
||||
if (l.contains("color")) {
|
||||
const auto& c = l["color"];
|
||||
if (c.is_sequence() && c.size() == 3) {
|
||||
light_color_r = static_cast<std::uint8_t>(std::clamp(c[0].get_value<int>(), 0, 255));
|
||||
light_color_g = static_cast<std::uint8_t>(std::clamp(c[1].get_value<int>(), 0, 255));
|
||||
light_color_b = static_cast<std::uint8_t>(std::clamp(c[2].get_value<int>(), 0, 255));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void Player::readCollisionBlock(const fkyaml::node& yaml, const std::string& yaml_path) {
|
||||
|
||||
@@ -125,12 +125,17 @@ class Player : public AnimatedSprite {
|
||||
inline static int body_height = 0;
|
||||
|
||||
// Radi de la llum emesa pel jugador (en píxels del canvas), llegit
|
||||
// del bloc opcional `light: { radius: N, flicker: bool }` del YAML.
|
||||
// 0 = no emet. Es declara estàtic com la resta de configs del jugador
|
||||
// (immunity, jump, ...): tots els jugadors del mateix YAML comparteixen
|
||||
// el valor. `light_flicker` activa la modulació "tipus foc" del radi.
|
||||
// del bloc opcional `light: { radius: N, flicker: bool, color: [r,g,b] }`
|
||||
// del YAML. 0 = no emet. Es declara estàtic com la resta de configs
|
||||
// del jugador (immunity, jump, ...): tots els jugadors del mateix YAML
|
||||
// comparteixen el valor. `light_flicker` activa la modulació "tipus
|
||||
// foc" del radi; `light_color_*` són el tint quan la sala usa mode
|
||||
// additive (en subtractive s'ignora).
|
||||
inline static int light_radius = 0;
|
||||
inline static bool light_flicker = false;
|
||||
inline static std::uint8_t light_color_r = 255;
|
||||
inline static std::uint8_t light_color_g = 255;
|
||||
inline static std::uint8_t light_color_b = 255;
|
||||
|
||||
// Ha de cridar-se abans d'instanciar Player; GameScene ho fa al ctor.
|
||||
static void loadFrom(const std::string& yaml_path);
|
||||
@@ -146,6 +151,9 @@ class Player : public AnimatedSprite {
|
||||
// per a que el cercle "salti" amb el jugador, no es quedi al sòl.
|
||||
[[nodiscard]] static auto getLightRadius() -> int { return light_radius; }
|
||||
[[nodiscard]] static auto getLightFlicker() -> bool { return light_flicker; }
|
||||
[[nodiscard]] static auto getLightColorR() -> std::uint8_t { return light_color_r; }
|
||||
[[nodiscard]] static auto getLightColorG() -> std::uint8_t { return light_color_g; }
|
||||
[[nodiscard]] static auto getLightColorB() -> std::uint8_t { return light_color_b; }
|
||||
// Seed estable per al flicker: reusem `id_` (0 o 1 en multijugador
|
||||
// local) amb un offset gran per evitar col·lisions amb el contador
|
||||
// d'Entity (que arrenca des de 1). Així P1 i P2 oscil·len en fases
|
||||
|
||||
+32
-3
@@ -1,5 +1,6 @@
|
||||
#include "game/map/map.hpp"
|
||||
|
||||
#include <algorithm>
|
||||
#include <cmath>
|
||||
#include <stdexcept>
|
||||
#include <unordered_map>
|
||||
@@ -49,18 +50,45 @@ namespace Map {
|
||||
return yaml_key;
|
||||
}
|
||||
|
||||
// Parser comú d'un color YAML 3-tupla a bytes. Retorna nullopt
|
||||
// si el node no és una seqüència de 3 elements. Usat pels
|
||||
// overrides de sala i, en `entity_manager_loadlevel.cpp`, també
|
||||
// pels defaults de tipus i overrides de spawn (passa pel mateix
|
||||
// helper per coherència). `clamp` defensiu per a YAMLs que
|
||||
// entreguen valors fora de 0..255.
|
||||
auto parseColorTriplet(const fkyaml::node& node) -> std::optional<std::array<std::uint8_t, 3>> {
|
||||
if (!node.is_sequence() || node.size() != 3) { return std::nullopt; }
|
||||
auto clamp = [](int v) { return static_cast<std::uint8_t>(std::clamp(v, 0, 255)); };
|
||||
return std::array<std::uint8_t, 3>{
|
||||
clamp(node[0].get_value<int>()),
|
||||
clamp(node[1].get_value<int>()),
|
||||
clamp(node[2].get_value<int>()),
|
||||
};
|
||||
}
|
||||
|
||||
// Llegeix el bloc opcional `lighting:` del YAML d'una sala i
|
||||
// actualitza `light_level` (si declara `level`) i el mapping
|
||||
// `g_room_emitters`. Idempotent: cada `Map::loadFrom` neteja el
|
||||
// mapping abans de poblar-lo, així no s'arrosseguen overrides
|
||||
// actualitza `light_level`, `lighting_mode` i el mapping
|
||||
// `g_room_emitters`. Idempotent: cada `Map::loadFrom` reseteja
|
||||
// tot l'estat abans de poblar-lo, així no s'arrosseguen valors
|
||||
// d'una sala anterior.
|
||||
void loadLightingBlock(const fkyaml::node& yaml) {
|
||||
g_room_emitters.clear();
|
||||
lighting_mode = Lighting::Mode::Subtractive;
|
||||
if (!yaml.contains("lighting")) { return; }
|
||||
const auto& lighting = yaml["lighting"];
|
||||
if (lighting.contains("level")) {
|
||||
light_level = lighting["level"].get_value<float>();
|
||||
}
|
||||
if (lighting.contains("mode")) {
|
||||
const auto MODE_STR = lighting["mode"].get_value<std::string>();
|
||||
if (MODE_STR == "additive") {
|
||||
lighting_mode = Lighting::Mode::Additive;
|
||||
} else if (MODE_STR == "subtractive") {
|
||||
lighting_mode = Lighting::Mode::Subtractive;
|
||||
} else {
|
||||
Log::warn("Map", "lighting.mode '{}' desconegut — s'usa subtractive", MODE_STR);
|
||||
}
|
||||
}
|
||||
if (!lighting.contains("emitters") || !lighting["emitters"].is_mapping()) { return; }
|
||||
const auto& em = lighting["emitters"];
|
||||
for (auto it = em.begin(); it != em.end(); ++it) {
|
||||
@@ -73,6 +101,7 @@ namespace Map {
|
||||
ov.enabled = true;
|
||||
if (val.contains("radius")) { ov.radius = val["radius"].get_value<int>(); }
|
||||
if (val.contains("flicker")) { ov.flicker = val["flicker"].get_value<bool>(); }
|
||||
if (val.contains("color")) { ov.color = parseColorTriplet(val["color"]); }
|
||||
}
|
||||
g_room_emitters[KEY] = ov;
|
||||
}
|
||||
|
||||
@@ -2,11 +2,15 @@
|
||||
|
||||
#include <SDL3/SDL.h>
|
||||
|
||||
#include <array>
|
||||
#include <cstdint>
|
||||
#include <functional>
|
||||
#include <optional>
|
||||
#include <string>
|
||||
#include <utility>
|
||||
|
||||
#include "core/rendering/lighting.hpp"
|
||||
|
||||
// Mapa d'una piràmide: sala rectangular amb marcador superior, muros pels
|
||||
// quatre costats i graella de sarcòfags envoltada per un passadís a cada
|
||||
// cantó. La geometria (graella, pitch, amplada de murs) es carrega des del
|
||||
@@ -60,6 +64,13 @@ namespace Map {
|
||||
// al root es manté per compatibilitat enrere.
|
||||
inline float light_level = 1.0F;
|
||||
|
||||
// Mode de composició de la pasada d'il·luminació (subtractive per
|
||||
// defecte; additive si la sala declara `lighting.mode: additive`).
|
||||
// Veure el comentari de `core/rendering/lighting.hpp` per a la
|
||||
// semàntica de cada mode. En subtractive, els colors dels emissors
|
||||
// s'ignoren — el camí és el de sempre.
|
||||
inline Lighting::Mode lighting_mode = Lighting::Mode::Subtractive;
|
||||
|
||||
// Override d'emissor declarat al bloc opcional `lighting.emitters.<tipus>`
|
||||
// de la sala. Tres formes acceptades al YAML:
|
||||
// <tipus>: false → desactiva la llum per a tot el tipus
|
||||
@@ -80,6 +91,10 @@ namespace Map {
|
||||
bool enabled{true};
|
||||
std::optional<int> radius;
|
||||
std::optional<bool> flicker;
|
||||
// Color emès en mode additive. `nullopt` → conservar el color
|
||||
// del tipus (default blanc 255,255,255 si el tipus no en declara).
|
||||
// La forma YAML és `color: [r, g, b]` (bytes 0..255).
|
||||
std::optional<std::array<std::uint8_t, 3>> color;
|
||||
};
|
||||
|
||||
// Consulta l'override de sala per a un tipus d'entitat (clau singular,
|
||||
|
||||
@@ -250,6 +250,11 @@ namespace {
|
||||
}
|
||||
if (room->radius.has_value()) { Player::light_radius = *room->radius; }
|
||||
if (room->flicker.has_value()) { Player::light_flicker = *room->flicker; }
|
||||
if (room->color.has_value()) {
|
||||
Player::light_color_r = (*room->color)[0];
|
||||
Player::light_color_g = (*room->color)[1];
|
||||
Player::light_color_b = (*room->color)[2];
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace
|
||||
@@ -1040,20 +1045,27 @@ void GameScene::applyLightingPass() {
|
||||
// gating extern aquí (els jugadors són només 1-2 actors i el cost
|
||||
// d'afegir-los al vector és menyspreable).
|
||||
const bool PLAYER_FLICKER = Player::getLightFlicker();
|
||||
const Lighting::Color PLAYER_COLOR{
|
||||
.r = Player::getLightColorR(),
|
||||
.g = Player::getLightColorG(),
|
||||
.b = Player::getLightColorB(),
|
||||
};
|
||||
for (const auto& p : players_) {
|
||||
if (p->isOutOfPlay()) { continue; }
|
||||
const auto C = p->getLightCenter();
|
||||
emitters.push_back({.cx = C.x, .cy = C.y, .radius = PLAYER_R, .seed = p->getLightSeed(), .flicker = PLAYER_FLICKER});
|
||||
emitters.push_back({.cx = C.x, .cy = C.y, .radius = PLAYER_R, .seed = p->getLightSeed(), .flicker = PLAYER_FLICKER, .color = PLAYER_COLOR});
|
||||
}
|
||||
for (const auto* e : entity_manager_.getEntities()) {
|
||||
const int R = e->getLightRadius();
|
||||
if (R <= 0) { continue; }
|
||||
const auto C = e->getLightCenter();
|
||||
emitters.push_back({.cx = C.x, .cy = C.y, .radius = R, .seed = e->getLightSeed(), .flicker = e->getLightFlicker()});
|
||||
const Lighting::Color COL{.r = e->getLightColorR(), .g = e->getLightColorG(), .b = e->getLightColorB()};
|
||||
emitters.push_back({.cx = C.x, .cy = C.y, .radius = R, .seed = e->getLightSeed(), .flicker = e->getLightFlicker(), .color = COL});
|
||||
}
|
||||
Lighting::apply(Screen::get().getCanvasArgb(),
|
||||
Screen::get().getCanvasWidth(),
|
||||
Screen::get().getCanvasHeight(),
|
||||
Map::lighting_mode,
|
||||
Map::light_level,
|
||||
emitters);
|
||||
}
|
||||
|
||||
Reference in new issue
Block a user