/**
* Слой освещения «тьма с прорезями»: карта силы тьмы в RenderTexture,
* источники прорезают её erase-спрайтами, тон (мягкая аддитивная подсветка
* вокруг прорези) рисуется поверх. Плюс импульсы (pulseLight/pulseAmbient),
* виньетка и тёмные пятна. Тонкий Pixi-адаптер над lightSim (чистая математика — там).
*
* Механика: RT хранит не цвет, а силу тьмы (белый fill → erase-спрайты);
* display-спрайт RT рисуется с blendMode 'multiply' и tint = ambient —
* смена ambient-цвета не требует перерисовки RT. Bake (отрисовка в RT)
* делается только при изменении квантованных подписей источников —
* мерцание живёт в квантовании альфы и тоне, обновляемом каждый тик.
*
* Живёт в renderer.lightRoot — экранное пространство между миром и UI.
* Порядок детей: карта тьмы → виньетка → тёмные пятна → тон → ambient-вспышка.
* Важно: bake-контейнер НЕ в дереве сцены — erase-спрайты вне RT стёрли бы мир.
*/
import { Container, Graphics, RenderTexture, Sprite, Texture } from 'pixi.js';
import { FadeState } from '../core/fade';
import type { Renderer } from './Renderer';
import {
GLOW_BASE_PX,
HOLE_PROFILE,
TONE_PROFILE,
lightFrame,
lerpAmbient,
pulseEnvelope,
pulseTotal,
quantizeHoleAlpha,
stepAlphas,
type LightDef,
type LightFrame,
type PulseSpec,
type RingStep
} from './lightSim';
export interface LightingOptions {
/** Виртуальные размеры сцены (480×270). */
width: number;
height: number;
/** Живой рендерер — для генерации текстур и bake; без него Texture.WHITE. */
renderer?: Renderer;
/** Размер пула спрайтов источников (по умолчанию 16). */
maxLights?: number;
/** Размер пула спрайтов тёмных пятен (по умолчанию 16). */
maxDarkSpots?: number;
}
/** Сила аддитивного тона поверх прорези: тон намёк, яркость несёт сама прорезь. */
const TONE_GAIN = 0.3;
/** Масштаб тона относительно радиуса прорези: тон уже, чем дыра. */
const TONE_SCALE = 0.8;
/**
* Ступенчатая круговая текстура из колец (в порядке stepAlphas) — общая
* для прорези, тона и свечения. resolution 1 + nearest — пиксельные ступени.
*/
function makeSteppedTexture(renderer: Renderer, rings: RingStep[], dither: boolean): Texture {
const g = new Graphics();
// Дизер-кольцо: редкие точки по внешнему радиусу — смягчают резкую ступень.
if (dither) {
const outer = rings[0].radius;
for (let i = 0; i < 32; i++) {
const a = ((i * 2) / 64) * Math.PI * 2;
g.rect(Math.cos(a) * outer - 0.5, Math.sin(a) * outer - 0.5, 1, 1).fill({
color: 0xffffff,
alpha: rings[0].paintAlpha
});
}
}
for (const ring of rings) {
g.circle(0, 0, ring.radius).fill({ color: 0xffffff, alpha: ring.paintAlpha });
}
const tex = renderer.app.renderer.generateTexture({
target: g,
resolution: 1,
antialias: false,
textureSourceOptions: { scaleMode: 'nearest' }
});
g.destroy();
return tex;
}
/**
* Ступенчатая пиксельная текстура свечения: концентрические круги с дискретной
* альфой (никаких гладких градиентов) + дизер-кольцо. Используется тёмными
* пятнами. Кэшируется вызывающим (Lighting держит её на инстансе — модульный
* кэш переживал destroy рендерера).
*/
export function makeGlowTexture(renderer: Renderer, steps = 4): Texture {
const profile: number[] = [];
for (let i = 1; i <= steps; i++) profile.push(1 - 1 / (i + 1)); // накопление красок 1/(i+1)
return makeSteppedTexture(renderer, stepAlphas(profile), true);
}
/** Текстура прорези (erase в RT): 7 ступеней из HOLE_PROFILE + дизер-кольцо. */
export function makeHoleTexture(renderer: Renderer): Texture {
return makeSteppedTexture(renderer, stepAlphas(HOLE_PROFILE), true);
}
/** Текстура тона (аддитивный свет вокруг прорези): приглушённое ядро. */
export function makeToneTexture(renderer: Renderer): Texture {
return makeSteppedTexture(renderer, stepAlphas(TONE_PROFILE), false);
}
/**
* Ступенчатая виньетка: белый центр → серые кольца к тёмным углам (multiply).
* Интенсивность задаётся alpha спрайта, текстура постоянна. Кэшируется
* вызывающим (см. makeGlowTexture).
*/
export function makeVignetteTexture(renderer: Renderer, width: number, height: number): Texture {
const g = new Graphics();
const r = Math.hypot(width, height) / 2; // дистанция центра до угла
g.rect(0, 0, width, height).fill({ color: 0x6a6a74 });
g.circle(width / 2, height / 2, r * 0.72).fill({ color: 0xa8a8b0 });
g.circle(width / 2, height / 2, r * 0.42).fill({ color: 0xffffff });
const tex = renderer.app.renderer.generateTexture({
target: g,
resolution: 1,
antialias: false,
textureSourceOptions: { scaleMode: 'nearest' }
});
g.destroy();
return tex;
}
/** Тёмное пятно: локальная аура опасности/тени (multiply). */
export interface DarkSpotDef {
id: string;
/** Позиция центра в экранных px. */
x: number;
y: number;
/** Радиус в px. */
radius: number;
/** Сила затемнения 0..1. */
alpha: number;
}
/** Цвет тени тёмного пятна (умножается на сцену). */
const DARK_SPOT_TINT = 0x3e3e48;
interface LightEntry {
def: LightDef;
/** Спрайт тона (аддитивный, в toneLayer). */
sprite: Sprite;
/** Erase-спрайт в bake — прорезает карту тьмы (есть только с RT). */
hole: Sprite | null;
}
/** Апсейт def по полям (id — ключ карты, не меняется): без пересоздания на тике. */
function copyLightDef(into: LightDef, from: LightDef): void {
into.x = from.x;
into.y = from.y;
into.color = from.color;
into.intensity = from.intensity;
into.radius = from.radius;
into.flicker = from.flicker;
into.flickerPeriod = from.flickerPeriod;
into.seed = from.seed;
into.enabled = from.enabled;
}
interface PulseEntry {
def: LightDef;
/** Базовая интенсивность до огибающей. */
base: number;
spec: PulseSpec;
elapsed: number;
}
interface AmbientPulse {
color: number;
peak: number;
spec: PulseSpec;
elapsed: number;
}
interface DarkEntry {
def: DarkSpotDef;
sprite: Sprite;
}
export class Lighting extends Container {
/** Display-спрайт карты тьмы: multiply, tint = ambient-цвет. */
private readonly darkSprite: Sprite;
private readonly vignette: Sprite;
private readonly darkLayer: Container;
private readonly toneLayer: Container;
private readonly pulseAmb: Sprite;
private readonly toneFree: Sprite[] = [];
private readonly holeFree: Sprite[] = [];
private readonly darkFree: Sprite[] = [];
private readonly lights = new Map<string, LightEntry>();
private readonly darks = new Map<string, DarkEntry>();
private readonly pulses = new Map<string, PulseEntry>();
private readonly renderer: Renderer | null;
/** Карта силы тьмы (resolution 1); null — fallback без RT (Vitest, node). */
private readonly rt: RenderTexture | null;
/** Bake-контейнер: fill + erase-спрайты. НЕ в дереве сцены! */
private readonly bake: Container;
private readonly bakeFill: Sprite;
private readonly glow: Texture;
private readonly hole: Texture;
private readonly tone: Texture;
/** Сгенерированные (не WHITE) текстуры — уничтожаются в destroy(). */
private readonly generated: Texture[] = [];
private readonly maxLights: number;
private readonly maxDarkSpots: number;
private pulseSeq = 0;
/** Подпись набора квантованных прорезей; null — bake ещё не делался. */
private bakeSig: string | null = null;
/** Тьма была активна на прошлом тике (для форс-bake на включении). */
private darkOn = false;
/** Переиспользуемый кадр applyFrame — без аллокации на источник/тик. */
private readonly frame: LightFrame = { id: '', x: 0, y: 0, tint: 0xffffff, alpha: 0, scale: 1 };
private time = 0;
private ambientFade: FadeState<number>;
private vignetteFade: FadeState<number>;
private ambPulse: AmbientPulse | null = null;
constructor(options: LightingOptions) {
super();
this.maxLights = options.maxLights ?? 16;
this.maxDarkSpots = options.maxDarkSpots ?? 16;
this.renderer = options.renderer ?? null;
// Карта тьмы: Texture.WHITE без рендерера (multiply белого = не трогает).
this.darkSprite = new Sprite(Texture.WHITE);
this.darkSprite.width = options.width;
this.darkSprite.height = options.height;
this.darkSprite.blendMode = 'multiply';
this.darkSprite.tint = 0xffffff;
this.ambientFade = new FadeState(lerpAmbient, 0xffffff);
this.addChild(this.darkSprite);
// Виньетка: Texture.WHITE без рендерера (multiply белого = не трогает).
const vignetteTex = this.renderer
? makeVignetteTexture(this.renderer, options.width, options.height)
: Texture.WHITE;
if (this.renderer) this.generated.push(vignetteTex);
this.vignette = new Sprite(vignetteTex);
this.vignette.width = options.width;
this.vignette.height = options.height;
this.vignette.blendMode = 'multiply';
this.vignette.alpha = 0;
this.vignetteFade = new FadeState((a, b, k) => a + (b - a) * k, 0);
this.addChild(this.vignette);
// Тёмные пятна — под тоном: свет пробивает локальную тень.
this.darkLayer = new Container();
this.addChild(this.darkLayer);
// Тон источников — аддитивный слой над тьмой (не в RT: цвет каждый тик).
this.toneLayer = new Container();
this.addChild(this.toneLayer);
// Ambient-вспышка: Texture.WHITE, аддитивная, alpha по огибающей.
this.pulseAmb = new Sprite(Texture.WHITE);
this.pulseAmb.width = options.width;
this.pulseAmb.height = options.height;
this.pulseAmb.blendMode = 'add';
this.pulseAmb.alpha = 0;
this.addChild(this.pulseAmb);
// RT карты тьмы + bake-контейнер (вне сцены): fill → erase-прорези.
this.rt = this.renderer
? RenderTexture.create({
width: options.width,
height: options.height,
resolution: 1,
scaleMode: 'nearest',
antialias: false
})
: null;
this.bake = new Container();
this.bakeFill = new Sprite(Texture.WHITE);
this.bakeFill.width = options.width;
this.bakeFill.height = options.height;
this.bake.addChild(this.bakeFill);
this.glow = this.renderer ? makeGlowTexture(this.renderer) : Texture.WHITE;
this.hole = this.renderer ? makeHoleTexture(this.renderer) : Texture.WHITE;
this.tone = this.renderer ? makeToneTexture(this.renderer) : Texture.WHITE;
for (const tex of [this.glow, this.hole, this.tone]) {
if (tex !== Texture.WHITE) this.generated.push(tex);
}
for (let i = 0; i < this.maxLights; i++) this.toneFree.push(this.makeToneSprite());
for (let i = 0; i < this.maxLights; i++) this.holeFree.push(this.makeHoleSprite());
for (let i = 0; i < this.maxDarkSpots; i++) this.darkFree.push(this.makeDarkSprite());
}
private makeToneSprite(): Sprite {
const s = new Sprite(this.tone);
s.anchor.set(0.5);
s.blendMode = 'add';
s.visible = false;
this.toneLayer.addChild(s);
return s;
}
private makeHoleSprite(): Sprite {
const s = new Sprite(this.hole);
s.anchor.set(0.5);
s.blendMode = 'erase';
s.visible = false;
this.bake.addChild(s);
return s;
}
private makeDarkSprite(): Sprite {
const s = new Sprite(this.glow);
s.anchor.set(0.5);
s.blendMode = 'multiply';
s.tint = DARK_SPOT_TINT;
s.visible = false;
this.darkLayer.addChild(s);
return s;
}
// --- ambient (фундамент смены времени дня) ---
/** Задать ambient-цвет; fadeSec > 0 — плавный лерп (день/ночь, закат). */
setAmbient(color: number, fadeSec = 0): void {
this.ambientFade.to(color, Math.max(0, fadeSec));
this.applyAmbient();
}
/** Целевой (заданный) ambient-цвет. */
get ambientColor(): number {
return this.ambientFade.target;
}
/** ambient на display-спрайт карты тьмы; белый — день, слой выключен. */
private applyAmbient(): void {
this.darkSprite.tint = this.ambientFade.value;
this.darkSprite.visible = this.ambientFade.value !== 0xffffff;
}
// --- виньетка (край экрана темнеет: низкий hp, опасная зона) ---
/** Виньетка 0..1 (0 — не трогает); fadeSec > 0 — плавный лерп. */
setVignette(intensity: number, fadeSec = 0): void {
this.vignetteFade.to(Math.max(0, Math.min(1, intensity)), Math.max(0, fadeSec));
this.vignette.alpha = this.vignetteFade.value;
}
/** Целевая интенсивность виньетки. */
get vignetteLevel(): number {
return this.vignetteFade.target;
}
// --- источники: runtime add/remove/move/color/enable ---
/** Добавить источник или обновить его параметры целиком. */
upsertLight(def: LightDef): void {
let entry = this.lights.get(def.id);
if (!entry) {
const sprite = this.toneFree.pop();
if (!sprite) return; // пул исчерпан — лишние источники игнорируются
entry = { def: { ...def }, sprite, hole: this.takeHole() };
this.lights.set(def.id, entry);
sprite.visible = true;
}
copyLightDef(entry.def, def); // апсейт по полям — без пересоздания на тике
}
/** Erase-слот из пула (или null без RT — прорезать нечего). */
private takeHole(): Sprite | null {
if (!this.rt) return null;
const hole = this.holeFree.pop();
if (hole) hole.visible = true;
return hole ?? null;
}
removeLight(id: string): void {
const entry = this.lights.get(id);
if (!entry) return;
entry.sprite.visible = false;
entry.sprite.alpha = 0;
this.toneFree.push(entry.sprite);
if (entry.hole) {
entry.hole.visible = false;
entry.hole.alpha = 0;
this.holeFree.push(entry.hole);
}
this.lights.delete(id);
}
hasLight(id: string): boolean {
return this.lights.has(id);
}
setLightPos(id: string, x: number, y: number): void {
const entry = this.lights.get(id);
if (entry) {
entry.def.x = x;
entry.def.y = y;
}
}
setLightColor(id: string, color: number): void {
const entry = this.lights.get(id);
if (entry) entry.def.color = color;
}
setLightEnabled(id: string, enabled: boolean): void {
const entry = this.lights.get(id);
if (entry) entry.def.enabled = enabled;
}
// --- импульсы: короткие вспышки в пуле источников и на весь экран ---
/**
* Импульс света в точке: занимает спрайт общего пула, снимается по концу
* огибающей. Возвращает id (или пустую строку, если пул исчерпан).
*/
pulseLight(args: {
x: number;
y: number;
color: number;
intensity?: number;
radius?: number;
spec: PulseSpec;
}): string {
const id = `pulse#${this.pulseSeq++}`;
const sprite = this.toneFree.pop();
if (!sprite) return '';
const base = args.intensity ?? 1;
const def: LightDef = {
id,
x: args.x,
y: args.y,
color: args.color,
intensity: base * pulseEnvelope(0, args.spec),
radius: args.radius,
flicker: 0,
seed: 0
};
this.lights.set(id, { def, sprite, hole: this.takeHole() });
sprite.visible = true;
this.pulses.set(id, { def, base, spec: args.spec, elapsed: 0 });
return id;
}
/** Вспышка на весь экран (аддитивная); один слот — новая побеждает старую. */
pulseAmbient(args: { color: number; peak: number; spec: PulseSpec }): void {
this.pulseAmb.tint = args.color;
this.ambPulse = { ...args, elapsed: 0 };
this.pulseAmb.alpha = 0;
this.pulseAmb.visible = true; // оживёт в ближайшем update
}
/** Текущая альфа ambient-вспышки (0..1) — для тестов и снапшота. */
get pulseAmbientAlpha(): number {
return this.pulseAmb.alpha;
}
// --- тёмные пятна: локальные ауры опасности (multiply) ---
/** Добавить тёмное пятно или обновить его параметры. */
upsertDarkSpot(def: DarkSpotDef): void {
let entry = this.darks.get(def.id);
if (!entry) {
const sprite = this.darkFree.pop();
if (!sprite) return; // пул исчерпан — лишние пятна игнорируются
entry = { def: { ...def }, sprite };
this.darks.set(def.id, entry);
sprite.visible = true;
}
const d = entry.def;
d.x = def.x;
d.y = def.y;
d.radius = def.radius;
d.alpha = def.alpha;
const s = entry.sprite;
s.position.set(def.x, def.y);
s.alpha = Math.max(0, Math.min(1, def.alpha));
s.scale.set(def.radius / GLOW_BASE_PX);
}
removeDarkSpot(id: string): void {
const entry = this.darks.get(id);
if (!entry) return;
entry.sprite.visible = false;
entry.sprite.alpha = 0;
this.darkFree.push(entry.sprite);
this.darks.delete(id);
}
hasDarkSpot(id: string): boolean {
return this.darks.has(id);
}
// --- тик ---
/** Тик: время, лерп ambient/виньетки, огибающие импульсов, кадры источников. */
update(dt: number): void {
this.time += dt;
this.ambientFade.update(dt);
this.applyAmbient();
// Тьма включилась на этом тике — форс-bake, даже если подпись та же.
const on = this.ambientFade.value !== 0xffffff;
if (on && !this.darkOn) this.bakeSig = null;
this.darkOn = on;
this.vignetteFade.update(dt);
this.vignette.alpha = this.vignetteFade.value;
this.vignette.visible = this.vignetteFade.value > 0;
for (const [id, p] of this.pulses) {
p.elapsed += dt;
if (p.elapsed >= pulseTotal(p.spec)) {
this.removeLight(id);
this.pulses.delete(id); // удаление во время итерации Map — безопасно
continue;
}
p.def.intensity = p.base * pulseEnvelope(p.elapsed, p.spec);
}
this.applyLights();
if (this.ambPulse) {
this.ambPulse.elapsed += dt;
if (this.ambPulse.elapsed >= pulseTotal(this.ambPulse.spec)) {
this.ambPulse = null;
this.pulseAmb.alpha = 0;
this.pulseAmb.visible = false;
} else {
const e = pulseEnvelope(this.ambPulse.elapsed, this.ambPulse.spec);
this.pulseAmb.alpha = Math.min(1, this.ambPulse.peak * e);
this.pulseAmb.visible = this.pulseAmb.alpha > 0;
}
}
}
/** Кадры источников: тон каждый тик, прорези — по квантованной подписи. */
private applyLights(): void {
let sig = '';
let idx = 0;
for (const entry of this.lights.values()) {
const f = lightFrame(entry.def, this.time, this.frame);
// Тон: полный precision, обновляется каждый тик (живость мерцания).
const s = entry.sprite;
s.position.set(f.x, f.y);
s.tint = f.tint;
s.alpha = Math.min(1, f.alpha) * TONE_GAIN;
s.scale.set(f.scale * TONE_SCALE);
s.visible = s.alpha > 0.01;
// Прорезь: квантованные значения — сигнатура = содержимое RT.
if (entry.hole) {
const qx = Math.round(f.x);
const qy = Math.round(f.y);
const qs = Math.round(f.scale * 8) / 8;
const qa = quantizeHoleAlpha(f.alpha);
entry.hole.position.set(qx, qy);
entry.hole.scale.set(qs);
entry.hole.alpha = qa;
entry.hole.visible = qa > 0;
sig += `${idx}:${qx},${qy},${qs},${qa};`;
}
idx++;
}
if (sig !== this.bakeSig) {
this.bakeSig = sig;
this.bakeNow();
}
}
/** Перерисовать карту тьмы в RT; день (белый ambient) — не нужно. */
private bakeNow(): void {
if (!this.rt || !this.renderer || !this.darkSprite.visible) return;
this.renderer.app.renderer.render({ container: this.bake, target: this.rt, clear: true });
}
/** Видимые кадры источников (пост-мерцание, включая импульсы) — для снапшота. */
frames(): readonly LightFrame[] {
const out: LightFrame[] = [];
for (const { def } of this.lights.values()) out.push(lightFrame(def, this.time));
return out;
}
override destroy(options?: Parameters<Container['destroy']>[0]): void {
this.pulses.clear();
for (const id of [...this.lights.keys()]) this.removeLight(id);
for (const id of [...this.darks.keys()]) this.removeDarkSpot(id);
for (const s of this.toneFree) s.destroy();
this.toneFree.length = 0;
for (const s of this.holeFree) s.destroy();
this.holeFree.length = 0;
this.bakeFill.destroy();
this.bake.destroy({ children: false });
this.rt?.destroy(true);
this.darks.clear();
// Тёмные спрайты — дети darkLayer: destroy явно и один раз, слой без children.
for (const s of this.darkFree) s.destroy();
this.darkFree.length = 0;
this.darkLayer.destroy({ children: false });
this.darkSprite.destroy();
this.vignette.destroy();
this.pulseAmb.destroy();
for (const tex of this.generated) {
if (tex !== Texture.WHITE) tex.destroy(true); // стаб-рендерер отдаёт WHITE
}
this.generated.length = 0;
super.destroy(options);
}
}
