Drive PBR normals with cached local light directions in beta.141

Document verified beta.140 publication and Prism synchronization
Add colored dynamic lights and smooth hue-preserving fades for beta.140
2026-09-18 04:11:03 +02:00 · 2026-09-18 03:15:07 +02:00 · 2026-09-18 03:13:43 +02:00 · 2026-09-18 02:27:19 +02:00 · 2026-09-18 02:25:48 +02:00
31 changed files with 1253 additions and 42 deletions
@@ -20,13 +20,11 @@ La [vision complète](docs/vision.md) conserve les intentions ; le
 L’économie, les claims et les dimensions décrits dans la vision restent
 à implémenter.

-La version **beta.138** adapte l’épaisseur des **rayons solaires à la météo** :
-plus denses et diffus dans le brouillard, renforcés sous les précipitations,
-avec moins de lumière pendant l’orage. Le curseur reste inchangé.
-Le [ticket](docs/shader-beta138.md) détaille le rendu et ses vérifications.
-La [vérification Vulkan](docs/shader-vulkan-beta138.md) précise les backends testés
-et les limites de la validation par pilote.
-Release publiée et même instance Prism synchronisée ; sauvegardes et réglages conservés.
+La version **beta.141** donne une direction approximative aux lumières locales
+pour orienter les normales et les reflets PBR. Les blocs posés utilisent une
+estimation en cache ; les objets portés réutilisent leur position. Les sources
+opposées adoucissent le relief, avec les fondus existants et sans nouveau bouton.
+Le [ticket](docs/directional-lights-beta141.md) décrit le rendu et les vérifications.
 La [livraison précédente](docs/clay-workshop-integration-beta110.md) réunit déjà
 l’atelier, les œufs et la neige saisonnière dans l’instance **Sanctuary Beta**.
 Les [synchronisations antérieures](docs/git-sync-beta092.md) restent documentées.
@@ -37,6 +35,31 @@ La [carte native beta.005](docs/atlas-beta005.md) prend le relais après
 l’étude de Xaero et des alternatives libres.


+## beta.141 — Direction locale et normales PBR
+
+Relief et reflets orientés par les lumières locales. Cache compact, confiance
+réduite pour les sources opposées, objets portés et fondus. Activer PBR et
+Lumières colorées ; portée PBR 32 blocs.
+[Contrat et vérifications](docs/directional-lights-beta141.md) ·
+[Pack normal](https://git.botsu.net/koka/sanctuary-beta/releases/download/beta.141/Sanctuary-beta.141.mrpack) ·
+[Pack de test](https://git.botsu.net/koka/sanctuary-beta/releases/download/beta.141/Sanctuary-Test-beta.141.mrpack).
+
+## beta.140 — Lumières portées et fondus
+
+Mains et tête, distances 8/16/32/64, fondus, cuivre vert, redstone rouge et
+option pour la chaleur des torches. Lumières colorées activées à 30 % par défaut.
+[Contrat et vérifications](docs/colored-dynamic-beta140.md) ·
+[Pack normal](https://git.botsu.net/koka/sanctuary-beta/releases/download/beta.140/Sanctuary-beta.140.mrpack) ·
+[Pack de test](https://git.botsu.net/koka/sanctuary-beta/releases/download/beta.140/Sanctuary-Test-beta.140.mrpack).
+
+## beta.139 — Lumières colorées
+
+Teintes chaudes, sources des âmes bleues, redstone rouge, froglights et matériaux lumineux.
+Option désactivée initialement, intensité 35 % ; propagation locale avec obstacles.
+[Contrat et vérifications](docs/colored-lights-beta139.md) ·
+[Pack normal](https://git.botsu.net/koka/sanctuary-beta/releases/download/beta.139/Sanctuary-beta.139.mrpack) ·
+[Pack de test](https://git.botsu.net/koka/sanctuary-beta/releases/download/beta.139/Sanctuary-Test-beta.139.mrpack).
+
 ## beta.138 — Rayons et brouillard

 Densité automatique des rayons selon le brouillard et les précipitations.
@@ -0,0 +1,112 @@
+# LIGHT-140 — Lumières colorées portées et distance
+
+Socle beta.139 `c05c338`, branche `codex/colored-dynamic-beta140`.
+Minecraft 26.3 / Java 25. Livraison beta.140.
+
+## Contrat
+
+Relier les couleurs aux vraies sources de lumière dynamique : mains, tête,
+cosmétiques, objets au sol et feu, selon le système existant. Renforcer la
+teinte et activer les lumières colorées par défaut à 30 %. Ajouter une distance
+d'affichage de 8, 16, 32 ou 64 blocs (16 par défaut), indépendante de la portée
+native de chaque source. Augmenter la distance coûte davantage en mémoire et
+calcul ; aucun chargement forcé de chunk. Les choix sauvegardés sont conservés.
+
+Sources portées actualisées avec le système dynamique, sans reconstruire tout
+le champ statique à chaque mouvement. Aucun changement de monde ou de règle
+serveur. Vérifications natives OpenGL et Vulkan, puis construction et archives.
+
+## Couleurs et fondus
+
+Torches ordinaires : température native par défaut ; option « Torches chaudes »
+pour retrouver l'orangé. Glowstone jaune, lave jaune-rouge, redstone rouge saturé,
+cuivre vert (posé, en main ou sur la tête). Le cuivre est reconnu avant les
+familles génériques de torches et lanternes. Les palettes explicites restent
+indépendantes des packs ; le repli des autres matériaux suit leurs textures.
+
+Le rendu s'atténue sur le dernier quart de la distance choisie. Le champ précédent
+reste disponible pendant un fondu de 300 ms vers le nouveau champ ; l'activation
+et les sources dynamiques ont aussi un fondu. Le changement de distance est
+interpolé. Les sources mobiles utilisent la même sélection bornée et les mêmes
+intensités que la lumière dynamique existante, avec interpolation visuelle des
+positions et couleurs. Elles héritent de sa propagation radiale, y compris de
+ses limites d'occultation ; les blocs posés conservent leur propagation avec murs.
+
+Le volume varie réellement selon la distance (56, 72, 104 ou 168 blocs de côté,
+avec marge de propagation). Les grandes distances augmentent la mémoire et le
+délai de reconstruction ; la construction reste répartie entre les images.
+Deux champs coexistent brièvement pour le fondu. Seuls les chunks déjà chargés
+sont lus. La portée lumineuse native des torches n'est pas allongée.
+
+## Frontières de saturation
+
+Le stockage beta.139 tronquait les canaux faibles séparément en fin de portée :
+un bleu pouvait perdre son rouge avant son vert, puis devenir plus saturé sur
+une frontière visible. Le stockage logarithmique conserve maintenant une marge
+sous le niveau lumineux natif zéro. Le shader applique la coupure à l'énergie
+globale en conservant les rapports RGB. La réponse devient linéaire près du noir,
+sans amplification par racine quatrième des très faibles contributions.
+
+La transition des champs interpole le résultat colorimétrique rendu, pas une
+énergie ensuite amplifiée. Les sources mobiles ont une atténuation de fondu
+compensée pour la même réponse. Le test contrôle les rapports rouge/bleu et
+vert/bleu d'une torche des âmes de 1 à 9 blocs, jusqu'au bord de sa portée.
+
+## Vérifications natives
+
+Minecraft 26.3 / Java 25 sur Apple M1, mondes de test neufs de graine 122 :
+
+- OpenGL 4.1 Metal : **2 min 40 s**, `build/colored140-opengl.log`.
+- Vulkan / MoltenVK 1.4.2, profondeur 0–1 et transparence améliorée :
+  **2 min 26 s**, `build/colored140-vulkan.log`.
+
+Les deux exécutions passent `COLORED139_PASS` et `COLORED140_PASS` :
+propagation avec murs, sources hors champ, lampes allumées/éteintes, retrait,
+rechargement des ressources, cache, déplacement/retour de caméra, OFF/zéro,
+préférences et traductions FR/EN. Les nouveaux contrôles couvrent la teinte
+bleue jusqu'à neuf blocs, la torche native inchangée, l'option chaude, le cuivre
+vert et le rouge saturé, les deux mains et le cosmétique de tête, la position
+en troisième personne, les quatre distances et un fondu sans dépassement.
+
+Dans la même scène contrôlée, la somme d'écarts OFF/torche chaude à 30 % vaut
+3 926 093 / 3 926 092 sur OpenGL/Vulkan, contre 2 025 577 en beta.139 à 35 %.
+Cette mesure vérifie l'accentuation demandée, pas la performance. Le test fige
+uniquement le scintillement de la lightmap native ; cette sonde et les tests
+client ne sont pas distribués. Les captures finales sont conservées sous
+`build/colored140-opengl-screenshots/` et `build/colored140-vulkan-screenshots/`.
+Comparatif autonome : `build/Shader-beta.140-comparaison.html`.
+
+Pas de validation des pilotes Windows de l'utilisateur revendiquée. Les
+limites de beta.139 pour le rendu sous l'eau/lave et les panoramas restent
+ouvertes. Les sources dynamiques gardent l'occultation du système existant.
+Aucun monde personnel ouvert ni modifié.
+
+## Construction et archives
+
+`./gradlew check build assemblePack assembleTestPack -x :sanctuary:runGameTest`
+réussit en **2 min 22 s**, 126 tâches. Le GameTest serveur dédié reste exclu
+conformément au refus EULA antérieur ; les tests clients ci-dessus sont exécutés
+séparément. Log : `build/shader140-build.log`.
+
+La comparaison avec beta.139 trouve **18 entrées de production modifiées**,
+limitées aux lumières dynamiques/colorées, options et aides FR/EN. Les sources
+des JAR correspondent aux fichiers du dépôt. Les archives normale/Test contiennent
+le même JAR Sanctuary ; la version, les dépendances exactes, les textures de
+gemmes et de la clé de Steve, l'absence de classes de test et le template complet
+sont vérifiés. Reçu : `build/shader140-artifact.json`.
+
+SHA-256 du JAR : `853284c1a61c7fce12edd2f7763717321eef56977290eb0e7c5db5e30bff442f`.
+
+- Sanctuary-beta.140.mrpack : `1b366746e4d6bebfbe0115c849524bdeb81c14eee89a2510f9dbe18808974d6a`.
+- Sanctuary-Test-beta.140.mrpack : `50c3cdf759117bb5286d41b4535fde15d9d84deaac833b7f8f61c4a0d29b72e7`.
+
+## Livraison
+
+[Release beta.140](https://git.botsu.net/koka/sanctuary-beta/releases/tag/beta.140)
+publiée sur le commit source `6e1b3b71088437fe57cf2b9b979b6d62711628d3` ; canal stable
+`2c360a0759d4a164f82c89ac2bef04ff69d50875` vérifié après publication.
+Deux synchronisations isolées puis deux dans la même instance Sanctuary Beta
+réussissent. Les **923 fichiers personnels** suivis gardent leurs hashes.
+Sauvegarde préalable : `sanctuary-backups/before-beta.140/`. Aucun monde personnel
+ouvert. Reçus : `build/shader140-isolated.json` et `build/shader140-prism.json`.
+Archives normale/Test/template et comparaison copiées dans `sanctuary-beta/build/`.
@@ -0,0 +1,107 @@
+# LIGHT-139 — Lumières colorées
+
+Socle beta.138 + vérification Vulkan `9d84a02`, Minecraft 26.3 / Java 25.
+Branche `codex/colored-lights-beta139`, livraison beta.139.
+
+## Contrat
+
+Option locale « Lumières colorées » avec intensité. Les vrais blocs émetteurs
+teintent discrètement leurs environs, y compris hors champ. Torches/lanternes,
+lave et feu chauds ; sources des âmes bleues ; redstone active rouge ;
+froglights par variante ; sources Sanctuary selon leur texture/matière.
+Les blocs éteints n'émettent pas. Le bloom et les inclusions émissives des
+minerais restent indépendants ; aucune lumière de gameplay n'est ajoutée.
+
+Propagation RGB dans un volume local de blocs chargés, obstacles et formes
+natives, construction répartie entre les images, cache des couleurs de
+matériaux. Aucun chargement forcé de chunk, accès aux mondes personnels,
+changement de sauvegarde, réseau ou règles serveur.
+
+## Réalisation
+
+Dans les options du shader : « Lumières colorées », désactivées initialement,
+et une intensité de 0 à 100 %, réglée à 35 %. Zéro ou OFF libère les ressources.
+Les préférences existantes sont conservées. Libellés et aides FR/EN.
+
+Les familles vanilla demandées ont une palette dédiée. Les autres émetteurs,
+y compris ceux de Sanctuary, utilisent la couleur des pixels lumineux de leurs
+textures de modèle, calculée puis mise en cache. Ce repli suit les packs de
+ressources ; les palettes dédiées vanilla restent constantes. Une texture
+illisible ou sans pixels exploitables utilise du blanc. Les blocs purement
+émissifs du bloom, sans émission lumineuse native, ne deviennent pas des lampes.
+
+Le champ couvre un cube de 64 blocs de côté autour de la caméra. Une marge de
+14 blocs réserve la propagation aux sources présentes dans le volume ; le rendu
+s'atténue progressivement sur 4 blocs à sa périphérie. C'est donc un effet de
+proximité, pas une illumination de tous les chunks visibles. Les formes et
+l'opacité natives règlent le passage de la lumière. Les canaux utilisent des
+maxima indépendants, sans addition illimitée des sources superposées.
+
+Le calcul CPU est réparti avec un budget visé de 2 ms par image, plus les
+allocations et chargements ponctuels de matériaux ; aucun chiffre de FPS n'est
+garanti. Un monde immobile réutilise son champ. Les changements rapides et les
+déplacements peuvent présenter un bref retard, le temps de publier un champ
+complet. Aucun chargement forcé de chunk. Une texture 512 × 512 contient le champ.
+La passe GPU teinte les surfaces visibles, atténue l'effet au soleil et dans le
+brouillard, puis laisse agir le SSGI et le bloom. Les sources tenues, entités,
+particules et le rendu sous l'eau/lave ne sont pas couverts par cette option.
+
+## Vérifications
+
+Essais client natifs réussis dans des mondes neufs (graine 122) sur Apple M1 :
+
+- OpenGL 4.1 Metal : **1 min 46 s**, `build/colored139-opengl.log`.
+- Vulkan / MoltenVK 1.4.2, profondeur 0–1 et transparence améliorée :
+  **1 min 30 s**, `build/colored139-vulkan.log`.
+
+Les deux journaux contiennent `COLORED139_PASS` et le backend réellement actif.
+Torche et torche des âmes hors champ, trois froglights, pierre lumineuse dont
+la couleur vient de sa texture, intensité 35/100, cache statique, déplacement
+et retour de caméra, mur fermé puis ouvert, lampe redstone allumée puis éteinte,
+retrait de source, rechargement des ressources et OFF/zéro vérifiés.
+Les préférences persistantes et les libellés FR/EN sont contrôlés ; une dernière
+capture active conjointement PBR, SSGI, bloom, ombres, highlights et rayons.
+
+Les sommes d'écart entre OFF et 35 % sont presque identiques entre backends :
+torche 2 025 577 / 2 025 576 ; âmes 964 200 / 964 201. Il s'agit de mesures
+sur les pixels de cette scène, pas d'un indice de performance.
+Comparatif autonome : `build/Shader-beta.139-comparaison.html`.
+Pas de validation du pilote Vulkan Windows de l'utilisateur revendiquée.
+Le test fige uniquement le scintillement vanilla des torches afin de comparer
+les images ; cette sonde est exclue du JAR distribué. Aucun monde personnel ouvert.
+
+## Diagnostic des essais
+
+La première comparaison de stabilité détectait le scintillement natif de la
+lightmap des torches, même avec un champ coloré inchangé. La sonde de test
+stabilise ce seul facteur ; aucune désactivation de scintillement en production.
+La pièce d'essai est désormais construite après le chargement de ses chunks,
+et l'absence de lumière du ciel est vérifiée avant les captures.
+
+## Construction et archives
+
+`./gradlew check build assemblePack assembleTestPack -x :sanctuary:runGameTest`
+réussit en **2 min 22 s**, 126 tâches. Le serveur GameTest dédié reste exclu
+conformément au refus EULA antérieur. Log : `build/shader139-build.log`.
+La comparaison à beta.138 trouve **13 entrées de production** modifiées,
+limitées au shader, à son menu et aux aides FR/EN. Les sondes de test sont
+absentes du JAR distribué. Sources, archives normale/Test et template complets
+vérifiés ; textures des gemmes et clé de Steve conservées à l'identique.
+Reçu local : `build/shader139-artifact.json`.
+
+JAR SHA-256 : `7b958f6576adbabb2b1af589b866cb52b1a65600ea2fa505b05dd283f8d595df`.
+
+- `Sanctuary-beta.139.mrpack` : 10450317 octets ; SHA-256 `13f3a283c260876d28ce0c6504615b4a8f4d575906badfbb2b39558f312e9fbb`.
+- `Sanctuary-Test-beta.139.mrpack` : 10469244 octets ; SHA-256 `c1e0b684dc2650950a0925c4625ef5eb4b78fb5f1c5680f5e302550424fa6d81`.
+
+## Publication et instance
+
+[Release beta.139](https://git.botsu.net/koka/sanctuary-beta/releases/tag/beta.139)
+publiée depuis `dc33ffa54697f61cd8f579235e7cebdbf0765f7c`, tag exact `beta.139`.
+Canal packwiz : `9f10167b6acfece9c045573580e186aa72bc91dc`.
+Deux synchronisations isolées puis deux synchronisations de la même instance
+Prism réussissent. Un seul JAR Sanctuary beta.139 actif, empreinte identique
+à l'archive vérifiée ; les **923 fichiers personnels suivis** conservent leurs
+empreintes. Sauvegarde des fichiers gérés dans
+`sanctuary-backups/before-beta.139/`. Aucun monde personnel ouvert.
+Reçus : `build/shader139-isolated.json`, `build/shader139-prism.json`.
@@ -0,0 +1,116 @@
+# LIGHT-141 — Direction locale pour les normales PBR
+
+Socle beta.140 `c9f5c56`, branche `codex/directional-lights-beta141`.
+Minecraft 26.3 / Java 25. Livraison beta.141.
+
+## Contrat
+
+Estimer une direction d'arrivée depuis les six voisins du champ lumineux,
+avec intensité et confiance. Conserver cette estimation dans une texture
+compacte reconstruite avec le champ, uniquement quand le PBR est actif.
+Les sources portées utilisent leurs positions déjà disponibles. Brancher ces
+directions sur les normales et reflets PBR existants, sans nouveau bouton.
+Les sources opposées doivent réduire la directionnalité, sans bascule brutale.
+Les champs précédent/courant gardent leur fondu et les obstacles restent pris
+en compte pour les blocs posés. Aucun changement de lumière de gameplay,
+de sauvegarde ou de génération ; aucune promesse de lancer de rayons exact.
+
+## Programme de vérification
+
+Contrôles natifs OpenGL/Vulkan : direction, sources opposées, murs, rendu de
+relief en intérieur, déplacement des sources, transitions et PBR OFF.
+Régression des lumières beta.139/140 puis check/build et assemblage. GameTest
+serveur dédié exclu selon le refus EULA antérieur. Aucun monde personnel ouvert.
+
+## Réalisation
+
+Le champ RGB conserve une texture directionnelle RGBA8 supplémentaire :
+les trois composantes codent la direction pondérée, l'alpha sa réponse lumineuse.
+Les voisins plus lumineux et accessibles contribuent à l'estimation ; les
+arrivées opposées s'annulent dans le vecteur, sans supprimer l'éclairage natif.
+Le shader interpole les moments pondérés avant normalisation, y compris entre
+les champs précédent et courant. La confiance réduit le relief quand aucune
+direction ne domine.
+
+Cette texture est préparée dans le budget de reconstruction existant, avec
+un maximum de six voisins par cellule éclairée et une table d'énergie réutilisée.
+Aucune recherche de sources ni rayons par pixel pour les blocs posés. La
+lecture GPU interpole huit cellules par champ ; les deux champs sont utilisés
+pendant le fondu. Les sources mobiles réutilisent les positions, intensités et
+transitions déjà collectées, dans la limite existante de 128 sources.
+
+Une texture directionnelle occupe environ 1,5 Mo à 16 blocs de distance et
+19 Mo à 64 blocs, par copie CPU/GPU ; deux champs coexistent lors des transitions.
+Le champ directionnel n'est construit que si PBR est actif avec une intensité
+non nulle. Sa désactivation libère les directions après la transition.
+Le coût est borné par ces réglages, sans garantie de FPS.
+
+La passe PBR applique la différence entre normale de base et normale perturbée,
+puis un reflet GGX local. Elle garde sa portée de 32 blocs et les réglages PBR
+existants ; Lumières colorées doit être actif. Le soleil et la lune continuent
+à fonctionner lorsque les lumières colorées sont coupées. Les aides FR/EN
+expliquent cette dépendance.
+
+C'est une direction dominante approximative : deux lumières colorées opposées
+ne produisent pas deux reflets indépendants. Les sources mobiles gardent la
+propagation radiale et les limites d'occultation existantes. Les normales PBR
+concernent les surfaces de blocs prises en charge, pas tous les modèles de mobs.
+Les exclusions existantes des panoramas et de l'immersion restent inchangées.
+
+## Premier essai ciblé
+
+L'essai natif OpenGL ciblé réussit en **1 min 12 s** : direction gauche/droite,
+annulation des sources opposées avec énergie conservée, occultation par un mur,
+relief sur la pierre en intérieur et avec une torche en main, stabilité au repos,
+libération des directions avec PBR OFF et maintien du chemin solaire avec
+Lumières colorées OFF. La somme d'écarts PBR OFF/ON sur la pierre vaut 878 114
+au réglage PBR 100 % ; c'est une comparaison de pixels, pas une mesure de FPS.
+Log : `build/directional141-focused.log`.
+
+Les essais de préparation ont révélé un conflit de nom de matrice GLSL, corrigé,
+puis des erreurs de fixture (angle 180° normalisé par Minecraft, suppression
+d'entités alors que la sélection était vide, commande d'heure déjà à minuit),
+corrigées sans changer le rendu.
+
+## Validation complète OpenGL
+
+La chaîne complète réussit en **3 min 1 s** sur OpenGL / Apple M1 :
+`COLORED139_PASS`, `COLORED140_PASS` et `DIRECTIONAL141_PASS`.
+Elle réunit les contrôles de couleurs, objets portés, caméra, occultation,
+rechargement des ressources, préférences, distances/fondus et directions PBR.
+Le test ciblé est reproductible avec `-PsanctuaryDirectional141Only=true` ;
+la chaîne complète utilise `-PsanctuaryDirectional141ClientTests=true` avec
+les deux suites de lumières existantes.
+Log : `build/directional141-opengl.log`. Captures natives conservées dans
+`build/directional141-opengl-screenshots/`. Comparaison autonome sans retraitement :
+`build/Shader-beta.141-comparaison.html`.
+
+## Validation complète Vulkan
+
+La même chaîne réussit en **2 min 56 s** sur Vulkan / Apple M1, MoltenVK 1.4.2,
+profondeur 0–1 et transparence améliorée. Les trois marqueurs de réussite sont
+présents dans `build/directional141-vulkan.log`. L'écart PBR local OFF/ON vaut
+878 107, contre 878 114 sous OpenGL dans cette scène. Les captures natives sont
+conservées dans `build/directional141-vulkan-screenshots/`.
+Les deux moteurs vérifient la compilation, les chemins actifs et désactivés,
+le cache, les murs, les sources opposées et portées, ainsi que les régressions
+beta.139/140. Pas de validation des pilotes Windows de l'utilisateur revendiquée.
+
+## Construction et archives
+
+`./gradlew check build assemblePack assembleTestPack -x :sanctuary:runGameTest`
+réussit en **2 min 35 s**, 126 tâches. Le GameTest serveur dédié reste exclu
+selon le refus EULA antérieur. Les suites clientes ci-dessus ont été exécutées
+séparément. Log : `build/shader141-build.log`.
+
+Comparaison à beta.140 : **8 entrées de production modifiées**, limitées au
+champ lumineux, à sa préparation avant le PBR, au shader PBR et aux aides FR/EN.
+Les archives normale/Test contiennent le même JAR Sanctuary, sans classes
+de test. Version, dépendances exactes, sources des JAR, textures de gemmes et
+de la clé de Steve, et template complet sont vérifiés.
+Reçu : `build/shader141-artifact.json`.
+
+SHA-256 du JAR : `660f29c3fa77fee4de6a8db5673c61619985804494f70e961998da36f396d0f1`.
+
+- Sanctuary-beta.141.mrpack : `08df23dac9e98fbfa2935f747345c38244bddc3a3d9371c6416f251e85a7eb19`.
+- Sanctuary-Test-beta.141.mrpack : `a300ef5bfff7b6990c9f5c2760e9c3a23d7a27aeb10b8f04d29db9a7409fa0e1`.
@@ -14,6 +14,17 @@ JAR Sanctuary sont des pièces jointes de releases Gitea. Aucun JAR de mod ou
 dépendance téléchargée n'entre dans l'historique Git. Le canal Beta est distinct
 de l'ancien pack 26.2.

+## beta.140 — Lumières portées et fondus
+
+Couleurs des objets en main et sur la tête, distances 8/16/32/64 et fondus
+préservant la teinte. Torches natives par défaut, option chaude, cuivre vert
+et redstone rouge. [Contrat et vérifications](colored-dynamic-beta140.md).
+[Release beta.140](https://git.botsu.net/koka/sanctuary-beta/releases/tag/beta.140)
+publiée ; canal `2c360a0759d4a164f82c89ac2bef04ff69d50875`. Deux synchronisations isolées
+puis deux dans l'instance Sanctuary Beta réussies. Les 923 fichiers personnels
+suivis gardent leurs hashes. Aucun monde personnel ouvert ; sauvegarde préalable
+`sanctuary-backups/before-beta.140/`. Archives vérifiées dans `sanctuary-beta/build/`.
+
 ## beta.138 — Densité des rayons selon la météo

 Brouillard plus dense et diffus, précipitations et atténuation de l'orage.
@@ -9,8 +9,8 @@ loom_version=1.17.20
 fabric_api_version=0.160.5+26.3

 # Release counter: beta.001, .002, .003, ... (see docs/versioning.md).
-mod_version=beta.138
-pack_version=beta.138
+mod_version=beta.141
+pack_version=beta.141
 resource_pack_version=beta.121
 maven_group=fr.koka.sanctuary
 jei_version=30.32.0-sanctuary.3
@@ -34,6 +34,9 @@ if (clientRenderTests) {
        if (improvedTransparency.isPresent()) {
            systemProperty('sanctuary.test.improvedTransparency', improvedTransparency.get())
        }
+        systemProperty('sanctuary.test.directional141Only', providers.gradleProperty('sanctuaryDirectional141Only').getOrElse('false'))
+        systemProperty('sanctuary.test.directional141', providers.gradleProperty('sanctuaryDirectional141ClientTests').getOrElse('false'))
+        systemProperty('sanctuary.test.colored140', providers.gradleProperty('sanctuaryColored140ClientTests').getOrElse('false'))
        systemProperty('sanctuary.test.noVsync', providers.gradleProperty('sanctuaryClientNoVsync').getOrElse('false'))
        systemProperty('sanctuary.test.quick', providers.gradleProperty('sanctuaryQuickTests').getOrElse('false'))
        systemProperty('sanctuary.test.introVisualOnly', providers.gradleProperty('sanctuaryIntroVisualOnly').getOrElse('false'))
@@ -102,6 +105,10 @@ tasks.named('runGameTest') {
 }

 tasks.named('processGametestResources') {
+    def colored139Client = providers.gradleProperty('sanctuaryColored139ClientTests').map { it.toBoolean() }.getOrElse(false)
+    inputs.property('sanctuaryColored139ClientTests', colored139Client)
+    if (colored139Client) filter { line -> line.replace('fr.koka.sanctuary.gametest.SanctuaryClientRenderTests', 'fr.koka.sanctuary.client.shader.ColoredLights139ClientChecks') }
+
    def pbr134Client = providers.gradleProperty('sanctuaryPbr134ClientTests').map { it.toBoolean() }.getOrElse(false)
    inputs.property('sanctuaryPbr134ClientTests', pbr134Client)
    if (pbr134Client) filter { line -> line.replace('fr.koka.sanctuary.gametest.SanctuaryClientRenderTests', 'fr.koka.sanctuary.client.shader.Pbr134ClientChecks') }
@@ -0,0 +1,86 @@
+package fr.koka.sanctuary.client.shader;
+
+import static fr.koka.sanctuary.client.shader.PixelShadows122ClientChecks.*;
+import java.nio.file.Files;
+import net.fabricmc.fabric.api.client.gametest.v1.FabricClientGameTest;
+import net.fabricmc.fabric.api.client.gametest.v1.context.ClientGameTestContext;
+import net.fabricmc.fabric.api.client.gametest.v1.context.TestServerContext;
+import net.fabricmc.loader.api.FabricLoader;
+import net.minecraft.core.BlockPos;
+import net.minecraft.world.level.block.Blocks;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.network.chat.Component;
+
+/** Fresh native world: offscreen sources, true voxel occlusion and real GPU tint. */
+public final class ColoredLights139ClientChecks implements FabricClientGameTest {
+    private static final BlockPos SOURCE=new BlockPos(98,101,102),PROBE=new BlockPos(99,101,106);
+    public void runTest(ClientGameTestContext c){
+        System.setProperty("sanctuary.test.freezeBlockFlicker","true");
+        try{new PixelShadows122ClientChecks(false,false,false,false,false,true).runTest(c);}
+        finally{System.clearProperty("sanctuary.test.freezeBlockFlicker");}
+    }
+    static void run(ClientGameTestContext c,TestServerContext server){
+        c.runOnClient(m->{preferences();VanillaLight.setWarmTorches(true);m.options.particles().set(net.minecraft.server.level.ParticleStatus.MINIMAL);VanillaLight.setEnabled(true);VanillaLight.setSaturation(100);VanillaLight.setPbr(false);VanillaLight.setSsgi(false);VanillaLight.setBloom(false);VanillaLight.setOreEmission(false);VanillaLight.setLensFlare(false);VanillaLight.setEdgeHighlights(false);VanillaLight.setPixelShadows(false);VanillaLight.setSunshafts(false);VanillaLight.setColoredLights(false);VanillaLight.setColoredLightIntensity(35);});
+        camera(c,server,100.5,101,104.5,70);c.waitTicks(30);
+        server.runOnServer(s->{command(s,"time set 18000");
+            for(int x=88;x<=112;x++)for(int z=92;z<=116;z++)for(int y=100;y<=109;y++)
+                s.overworld().setBlockAndUpdate(new BlockPos(x,y,z),(y==100||y==109||x==88||x==112||z==92||z==116)?Blocks.CONCRETE.white().defaultBlockState():Blocks.AIR.defaultBlockState());
+        });
+        look(c,server,0,35);c.waitTicks(30);
+        c.waitFor(m->m.level.getBrightness(net.minecraft.world.level.LightLayer.SKY,PROBE)==0,1200);
+        long warm=0;
+        for(var block:new Block[]{Blocks.TORCH,Blocks.SOUL_TORCH,Blocks.PEARLESCENT_FROGLIGHT,Blocks.VERDANT_FROGLIGHT,Blocks.OCHRE_FROGLIGHT,Blocks.GLOWSTONE}){
+            source(c,server,block);enable(c,false);var off=capture(c,"colored-"+name(block)+"-off");enable(c,true);var on=capture(c,"colored-"+name(block)+"-35");
+            int color=c.computeOnClient(m->ColoredLights.sample(PROBE));long delta=difference(off,on);
+            check(delta>250,"Offscreen source visibly tints native surfaces: "+name(block)+" "+delta);
+            int r=color>>16&255,g=color>>8&255,b=color&255;
+            if(block==Blocks.TORCH){check(r>g&&g>b,"Torch is warm");warm=delta;}
+            if(block==Blocks.SOUL_TORCH)check(b>g&&g>r,"Soul source is blue");
+            if(block==Blocks.SOUL_TORCH)for(int step=1;step<=9;step++){
+                final int distance=step;int sample=c.computeOnClient(m->ColoredLights.sample(SOURCE.offset(distance,0,0)));
+                int sr=sample>>16&255,sg=sample>>8&255,sb=sample&255;
+                double rr=sr==0?0:Math.pow(.8,(sb-sr)/8.0),gg=sg==0?0:Math.pow(.8,(sb-sg)/8.0);
+                check(Math.abs(rr-85/255.)<.02&&Math.abs(gg-189/255.)<.02,"Blue hue remains consistent at native distance "+step+" "+rr+" / "+gg);
+            }
+            if(block==Blocks.VERDANT_FROGLIGHT)check(g>r&&g>b,"Verdant froglight is green");
+            if(block==Blocks.PEARLESCENT_FROGLIGHT)check(r>g&&b>g,"Pearlescent froglight is pink");
+            if(block==Blocks.OCHRE_FROGLIGHT)check(r>g&&g>b,"Ochre froglight is warm");
+            if(block==Blocks.GLOWSTONE)check(r>b,"Other emitters derive their colour from the native texture");
+            System.out.println("COLORED139_SOURCE "+name(block)+" sample="+Integer.toHexString(color)+" delta="+delta);
+        }
+        source(c,server,Blocks.TORCH);enable(c,false);var base=capture(c,null);enable(c,true);var low=capture(c,null);
+        c.runOnClient(m->VanillaLight.setColoredLightIntensity(100));settle(c);var strong=capture(c,"colored-torch-100");check(difference(base,strong)>difference(base,low)*1.5,"Intensity increases colour, without changing native light");
+        int builds=c.computeOnClient(m->ColoredLights.builds());c.waitTicks(25);check(c.computeOnClient(m->ColoredLights.builds())==builds,"Stationary volume is cached");unchanged(strong,capture(c,null),"Static light is stable");
+        camera(c,server,104.5,101,104.5,70);look(c,server,0,35);settle(c);capture(c,"colored-moved");
+        camera(c,server,100.5,101,104.5,70);look(c,server,0,35);settle(c);unchanged(strong,capture(c,"colored-returned"),"Moving and returning preserves world-anchored light");
+        // A complete divider closes the room; light may not take a path around its edges.
+        server.runOnServer(s->{for(int y=101;y<109;y++)for(int z=93;z<116;z++)s.overworld().setBlockAndUpdate(new BlockPos(99,y,z),Blocks.STONE.defaultBlockState());});c.waitTicks(35);settle(c);
+        check((c.computeOnClient(m->ColoredLights.sample(new BlockPos(100,101,106)))&0xffffff)==0,"Opaque wall blocks colour propagation");
+        enable(c,false);var sealedOff=capture(c,null);enable(c,true);unchanged(sealedOff,capture(c,"colored-sealed"),"No coloured light crosses a sealed wall");
+        server.runOnServer(s->{for(int y=101;y<109;y++)for(int z=93;z<116;z++)s.overworld().setBlockAndUpdate(new BlockPos(99,y,z),Blocks.AIR.defaultBlockState());});c.waitTicks(35);settle(c);
+        check((c.computeOnClient(m->ColoredLights.sample(PROBE))&0xffffff)!=0,"Opening the wall restores light");
+        server.runOnServer(s->{s.overworld().setBlockAndUpdate(SOURCE,Blocks.REDSTONE_LAMP.defaultBlockState());s.overworld().setBlockAndUpdate(SOURCE.below(),Blocks.REDSTONE_BLOCK.defaultBlockState());});c.waitTicks(35);settle(c);
+        int red=c.computeOnClient(m->ColoredLights.sample(PROBE));check((red>>16&255)>(red>>8&255)&& (red>>16&255)>(red&255),"Powered redstone source is red");capture(c,"colored-redstone-on");
+        server.runOnServer(s->s.overworld().setBlockAndUpdate(SOURCE.below(),Blocks.CONCRETE.white().defaultBlockState()));c.waitTicks(35);settle(c);
+        check((c.computeOnClient(m->ColoredLights.sample(PROBE))&0xffffff)==0,"Unpowered lamp removes cached coloured light");
+        source(c,server,Blocks.SOUL_TORCH);var beforeReload=capture(c,null);
+        var reload=c.computeOnClient(net.minecraft.client.Minecraft::reloadResourcePacks);c.waitFor(m->reload.isDone()&&m.gui.overlay()==null,1200);reload.join();settle(c);unchanged(beforeReload,capture(c,"colored-reloaded"),"Resource reload rebuilds materials and light field");
+        source(c,server,Blocks.AIR);check((c.computeOnClient(m->ColoredLights.sample(PROBE))&0xffffff)==0,"Removing the source clears its light");
+        source(c,server,Blocks.SOUL_TORCH);enable(c,false);var off=capture(c,null);c.runOnClient(m->{VanillaLight.setColoredLights(true);VanillaLight.setColoredLightIntensity(0);});c.waitTicks(10);
+        c.runOnClient(m->check(!ColoredLights.allocated(),"Zero releases volume and GPU resources"));unchanged(off,capture(c,null),"Zero is identical to OFF");
+        c.runOnClient(m->{for(String locale:new String[]{"fr_fr","en_us"}){m.getLanguageManager().setSelected(locale);m.getLanguageManager().onResourceManagerReload(m.getResourceManager());for(String key:new String[]{"colored_lights","colored_lights_help","colored_light_intensity","colored_light_intensity_help"}){String full="sanctuary.shaders."+key;check(!Component.translatable(full).getString().equals(full),"Translated "+locale+" "+full);}}});
+        c.runOnClient(m->{VanillaLight.setColoredLightIntensity(35);VanillaLight.setPbr(true);VanillaLight.setSsgi(true);VanillaLight.setBloom(true);VanillaLight.setBloomIntensity(20);VanillaLight.setEdgeHighlights(true);VanillaLight.setPixelShadows(true);VanillaLight.setSunshafts(true);VanillaLight.setLensFlare(true);VanillaLight.setOreEmission(true);});
+        settle(c);c.waitFor(m->ProceduralPbr.applied()&&Bloom.applied(),1200);c.waitTicks(30);capture(c,"colored-with-shader-effects");
+        System.out.println("COLORED139_PASS warm="+warm+" offscreen sources, hues, native textured materials, intensity, cache, camera, walls, lamp updates, removal, reload, zero/OFF and FR/EN");
+    }
+    private static String name(Block b){return net.minecraft.core.registries.BuiltInRegistries.BLOCK.getKey(b).getPath();}
+    private static void source(ClientGameTestContext c,TestServerContext s,Block b){s.runOnServer(server->server.overworld().setBlockAndUpdate(SOURCE,b.defaultBlockState()));c.waitTicks(35);if(c.computeOnClient(m->VanillaLight.coloredLights()))settle(c);}
+    private static void enable(ClientGameTestContext c,boolean value){c.runOnClient(m->VanillaLight.setColoredLights(value));if(value)settle(c);else c.waitTicks(8);}
+    private static void settle(ClientGameTestContext c){int before=c.computeOnClient(m->ColoredLights.renderedFrames());c.waitFor(m->ColoredLights.applied()&&ColoredLights.settled()&&ColoredLights.renderedFrames()>before+8,1600);c.waitTicks(8);}
+    private static long difference(Frame a,Frame b){long sum=0;for(int i=0;i<a.pixels().length;i++)sum+=channelDifference(a.pixels()[i],b.pixels()[i]);return sum;}
+    private static void preferences(){try{
+        var path=FabricLoader.getInstance().getConfigDir().resolve("sanctuary-shaders.json");Files.deleteIfExists(path);forgetPreferences();check(VanillaLight.coloredLights()&&VanillaLight.coloredLightIntensity()==30,"New defaults are enabled at 30 percent");
+        Files.writeString(path,"{\"bloomIntensity\":20,\"ssgi\":false}");forgetPreferences();check(VanillaLight.coloredLights()&&VanillaLight.coloredLightIntensity()==30&&!VanillaLight.ssgi()&&VanillaLight.bloomIntensity()==20,"Old preferences keep their choices");
+        for(int n:new int[]{-1,0,35,100,400}){VanillaLight.setColoredLights(true);VanillaLight.setColoredLightIntensity(n);forgetPreferences();check(VanillaLight.coloredLights()&&VanillaLight.coloredLightIntensity()==Math.clamp(n,0,100),"Bounded persistent controls");}
+    }catch(java.io.IOException e){throw new AssertionError(e);}}
+}
@@ -0,0 +1,59 @@
+package fr.koka.sanctuary.client.shader;
+
+import static fr.koka.sanctuary.client.shader.PixelShadows122ClientChecks.*;
+import fr.koka.sanctuary.client.DynamicLightClient;
+import fr.koka.sanctuary.inventory.*;
+import fr.koka.sanctuary.cosmetics.AccessoryService;
+import net.fabricmc.fabric.api.client.gametest.v1.context.*;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.registries.BuiltInRegistries;
+import net.minecraft.resources.Identifier;
+import net.minecraft.world.entity.EquipmentSlot;
+import net.minecraft.world.item.*;
+import net.minecraft.world.level.block.*;
+import net.minecraft.network.chat.Component;
+
+final class ColoredLights140ClientChecks {
+    private static final BlockPos SOURCE=new BlockPos(98,101,102),PROBE=new BlockPos(99,101,106);
+    static void run(ClientGameTestContext c,TestServerContext server){
+        c.runOnClient(m->{VanillaLight.setPbr(false);VanillaLight.setSsgi(false);VanillaLight.setBloom(false);VanillaLight.setOreEmission(false);VanillaLight.setLensFlare(false);VanillaLight.setEdgeHighlights(false);VanillaLight.setPixelShadows(false);VanillaLight.setSunshafts(false);VanillaLight.setColoredLightIntensity(30);VanillaLight.setWarmTorches(false);VanillaLight.setColoredLightDistance(16);});
+        source(c,server,Blocks.TORCH);enable(c,false);var nativeTorch=capture(c,"torch-native-off");enable(c,true);unchanged(nativeTorch,capture(c,"torch-native-on"),"Normal torch preserves vanilla colour");
+        c.runOnClient(m->VanillaLight.setWarmTorches(true));settle(c);var warm=capture(c,"torch-warm-30");long accent=difference(nativeTorch,warm);check(accent>2_025_577,"30 percent exceeds beta139 warm tint at 35 percent: "+accent);
+        c.runOnClient(m->VanillaLight.setWarmTorches(false));settle(c);unchanged(nativeTorch,capture(c,null),"Warm torch option can restore native tint");
+        for(String name:new String[]{"copper_torch","copper_lantern"}){
+            var copper=BuiltInRegistries.BLOCK.getValue(Identifier.parse("minecraft:"+name));check(copper!=Blocks.AIR&&copper.defaultBlockState().getLightEmission()>0,"Native copper source exists "+name);
+            source(c,server,copper);int value=c.computeOnClient(m->ColoredLights.sample(PROBE));check((value>>8&255)>(value>>16&255)&&(value>>8&255)>(value&255),"Copper emits green");capture(c,name+"-green");
+        }
+        server.runOnServer(s->{s.overworld().setBlockAndUpdate(SOURCE,Blocks.REDSTONE_LAMP.defaultBlockState());s.overworld().setBlockAndUpdate(SOURCE.below(),Blocks.REDSTONE_BLOCK.defaultBlockState());});c.waitTicks(40);settle(c);
+        int red=c.computeOnClient(m->ColoredLights.sample(PROBE));check(Math.pow(.8,((red>>16&255)-(red>>8&255))/8.)<.04,"Redstone uses saturated red");capture(c,"redstone-red-30");
+        source(c,server,Blocks.AIR);server.runOnServer(s->s.overworld().setBlockAndUpdate(SOURCE.below(),Blocks.CONCRETE.white().defaultBlockState()));
+        // Actual carried sources, synchronized through native equipment and accessory packets.
+        server.runOnServer(s->{command(s,"gamemode creative @a");var p=s.getPlayerList().getPlayers().getFirst();p.setItemSlot(EquipmentSlot.MAINHAND,new ItemStack(Items.SOUL_TORCH));});
+        c.waitFor(m->DynamicLightClient.snapshot(m.level).size()==1,200);c.waitTicks(45);enable(c,false);var carriedOff=capture(c,"held-soul-off");enable(c,true);c.waitTicks(25);var carriedOn=capture(c,"held-soul-blue");check(difference(carriedOff,carriedOn)>1000&&c.computeOnClient(m->ColoredLights.dynamicCount())==1,"Held soul torch is visibly blue");
+        c.runOnClient(m->{var l=DynamicLightClient.snapshot(m.level).sources().iterator().next();check((l.color()&255)>(l.color()>>16&255),"Dynamic source has actual blue colour");});
+        c.runOnClient(m->m.options.setCameraType(net.minecraft.client.CameraType.THIRD_PERSON_BACK));c.waitTicks(25);
+        c.runOnClient(m->{var pos=ColoredLights.dynamicPosition(m.player.getId());check(pos!=null&&pos.distanceToSqr(m.player.getEyePosition())<1,"Third-person light follows player, not camera");});capture(c,"held-third-person");
+        c.runOnClient(m->m.options.setCameraType(net.minecraft.client.CameraType.FIRST_PERSON));c.waitTicks(20);settle(c);
+        int builds=c.computeOnClient(m->ColoredLights.builds());
+        server.runOnServer(s->{var p=s.getPlayerList().getPlayers().getFirst();p.setItemSlot(EquipmentSlot.MAINHAND,ItemStack.EMPTY);p.setItemSlot(EquipmentSlot.OFFHAND,new ItemStack(Items.SOUL_TORCH));});c.waitTicks(35);settle(c);check(c.computeOnClient(m->ColoredLights.builds())==builds,"Moving a light between hands does not rebuild static volume");capture(c,"offhand-soul-blue");
+        var copperItem=BuiltInRegistries.ITEM.getValue(Identifier.parse("minecraft:copper_torch"));
+        server.runOnServer(s->{var p=s.getPlayerList().getPlayers().getFirst();p.setItemSlot(EquipmentSlot.OFFHAND,ItemStack.EMPTY);AccessoryAccess.of(p).setItem(AccessoryContainer.HEAD,new ItemStack(copperItem));AccessoryService.publish(p);});c.waitTicks(45);settle(c);
+        c.runOnClient(m->{var l=DynamicLightClient.snapshot(m.level).sources().iterator().next();check((l.color()>>8&255)>(l.color()>>16&255)&&(l.color()>>8&255)>(l.color()&255),"Head cosmetic carries copper green");});capture(c,"head-copper-green");check(c.computeOnClient(m->ColoredLights.builds())==builds,"Dynamic colour updates preserve static cache");
+        server.runOnServer(s->{var p=s.getPlayerList().getPlayers().getFirst();AccessoryAccess.of(p).setItem(AccessoryContainer.HEAD,ItemStack.EMPTY);AccessoryService.publish(p);});c.waitFor(m->DynamicLightClient.snapshot(m.level).size()==0&&ColoredLights.dynamicCount()==0,200);c.waitTicks(25);
+        server.runOnServer(s->command(s,"gamemode spectator @a"));
+        camera(c,server,100.5,108,104.5,70);look(c,server,0,18);c.waitTicks(25);
+        server.runOnServer(s->{for(int x=88;x<=112;x++)for(int z=117;z<=155;z++)s.overworld().setBlockAndUpdate(new BlockPos(x,100,z),Blocks.CONCRETE.white().defaultBlockState());
+            for(int x=88;x<=112;x++)for(int y=101;y<=109;y++)s.overworld().setBlockAndUpdate(new BlockPos(x,y,116),Blocks.AIR.defaultBlockState());
+            s.overworld().setBlockAndUpdate(new BlockPos(100,101,140),Blocks.VERDANT_FROGLIGHT.defaultBlockState());});c.waitTicks(50);
+        c.runOnClient(m->VanillaLight.setColoredLightDistance(8));settle(c);var shortRange=capture(c,"distance-8");int small=c.computeOnClient(m->ColoredLights.volumeSide());check(c.computeOnClient(m->ColoredLights.sample(new BlockPos(100,101,141)))==0,"Far field omitted at short distance");
+        int before=c.computeOnClient(m->ColoredLights.builds());c.runOnClient(m->VanillaLight.setColoredLightDistance(64));c.waitFor(m->ColoredLights.builds()>before&&ColoredLights.blend()>0&&ColoredLights.blend()<1,1600);var transition=capture(c,"distance-fade");settle(c);var longRange=capture(c,"distance-64");
+        check(c.computeOnClient(m->ColoredLights.volumeSide())>small,"Distance changes actual field allocation");check((c.computeOnClient(m->ColoredLights.sample(new BlockPos(100,101,141)))&0xffffff)!=0,"Far light retained at long distance");check(difference(shortRange,longRange)>1000,"Far light is visibly rendered");check(difference(transition,longRange)>100&&difference(shortRange,transition)<difference(shortRange,longRange),"Transition is an intermediate rendered frame without overshoot");
+        for(int distance:new int[]{8,16,32,64}){c.runOnClient(m->{VanillaLight.setColoredLightDistance(distance);forgetPreferences();check(VanillaLight.coloredLightDistance()==distance,"Persisted distance "+distance);});settle(c);}
+        c.runOnClient(m->{for(String locale:new String[]{"fr_fr","en_us"}){m.getLanguageManager().setSelected(locale);m.getLanguageManager().onResourceManagerReload(m.getResourceManager());for(String key:new String[]{"warm_torches","warm_torches_help","colored_light_distance","colored_light_distance_help","colored_light_distance_value"}){String full="sanctuary.shaders."+key;check(!Component.translatable(full,16).getString().equals(full),"Translated "+locale+" "+key);}}});
+        System.out.println("COLORED140_PASS accent="+accent+" native/warm torches, copper green, saturated red, main/offhand/head, dynamic cache, 8/16/32/64 distance, fade and FR/EN");
+    }
+    private static void source(ClientGameTestContext c,TestServerContext s,Block b){s.runOnServer(server->server.overworld().setBlockAndUpdate(SOURCE,b.defaultBlockState()));c.waitTicks(35);settle(c);}
+    private static void enable(ClientGameTestContext c,boolean value){c.runOnClient(m->VanillaLight.setColoredLights(value));if(value)settle(c);else c.waitTicks(10);}
+    private static void settle(ClientGameTestContext c){c.waitFor(m->ColoredLights.applied()&&ColoredLights.settled(),2000);c.waitTicks(12);}
+    private static long difference(Frame a,Frame b){long total=0;for(int i=0;i<a.pixels().length;i++)total+=channelDifference(a.pixels()[i],b.pixels()[i]);return total;}
+}
@@ -0,0 +1,48 @@
+package fr.koka.sanctuary.client.shader;
+
+import static fr.koka.sanctuary.client.shader.PixelShadows122ClientChecks.*;
+import net.fabricmc.fabric.api.client.gametest.v1.context.*;
+import net.minecraft.core.BlockPos;
+import net.minecraft.world.level.block.Blocks;
+
+/** Real enclosed stone surfaces: local normal response without sunlight. */
+final class DirectionalLights141ClientChecks {
+    private static final BlockPos LEFT=new BlockPos(96,101,102),RIGHT=new BlockPos(104,101,102),PROBE=new BlockPos(100,101,102);
+    static void run(ClientGameTestContext c,TestServerContext server){
+        c.runOnClient(m->{VanillaLight.setEnabled(true);VanillaLight.setSaturation(100);VanillaLight.setSsgi(false);VanillaLight.setBloom(false);VanillaLight.setOreEmission(false);VanillaLight.setLensFlare(false);VanillaLight.setEdgeHighlights(false);VanillaLight.setPixelShadows(false);VanillaLight.setSunshafts(false);m.options.particles().set(net.minecraft.server.level.ParticleStatus.MINIMAL);VanillaLight.setColoredLights(true);VanillaLight.setColoredLightIntensity(30);VanillaLight.setColoredLightDistance(16);VanillaLight.setWarmTorches(false);VanillaLight.setPbr(false);VanillaLight.setPbrIntensity(100);});
+        camera(c,server,100.5,101,98.5,70);look(c,server,0,35);c.waitTicks(30);
+        server.runOnServer(s->{if(s.clockManager().getInstance(s.overworld().dimensionType().defaultClock().orElseThrow()).totalTicks()!=18000)command(s,"time set 18000");
+            for(int x=88;x<=112;x++)for(int z=92;z<=116;z++)for(int y=100;y<=109;y++)
+                s.overworld().setBlockAndUpdate(new BlockPos(x,y,z),(y==100)?Blocks.STONE.defaultBlockState():(y==109||x==88||x==112||z==92||z==116)?Blocks.CONCRETE.white().defaultBlockState():Blocks.AIR.defaultBlockState());
+            s.overworld().setBlockAndUpdate(LEFT,Blocks.TORCH.defaultBlockState());
+        });c.waitTicks(40);settle(c);var flat=capture(c,"direction-left-pbr-off");
+        c.runOnClient(m->VanillaLight.setPbr(true));c.waitFor(m->ColoredLights.directionSample(PROBE)!=0&&ProceduralPbr.ready(),2000);settle(c);
+        int left=c.computeOnClient(m->ColoredLights.directionSample(PROBE));check(dx(left)<-.9&&Math.abs(dy(left))<.02&&Math.abs(dz(left))<.02,"Cached arrival points toward the left source");
+        var relief=capture(c,"direction-left-pbr-on");long delta=difference(flat,relief);check(delta>1000,"Local light visibly affects stone normals without skylight: "+delta);
+        int builds=c.computeOnClient(m->ColoredLights.builds());c.waitTicks(25);check(c.computeOnClient(m->ColoredLights.builds())==builds,"Static directions reuse the cache");unchanged(relief,capture(c,null),"Static local PBR is stable");
+        server.runOnServer(s->{s.overworld().setBlockAndUpdate(LEFT,Blocks.AIR.defaultBlockState());s.overworld().setBlockAndUpdate(RIGHT,Blocks.TORCH.defaultBlockState());});c.waitTicks(40);settle(c);
+        int right=c.computeOnClient(m->ColoredLights.directionSample(PROBE));check(dx(right)>.9,"Moving the source reverses arrival direction");capture(c,"direction-right-pbr-on");
+        server.runOnServer(s->s.overworld().setBlockAndUpdate(LEFT,Blocks.TORCH.defaultBlockState()));c.waitTicks(40);settle(c);
+        int opposed=c.computeOnClient(m->ColoredLights.directionSample(PROBE));check(Math.abs(dx(opposed))<.02&&Math.abs(dy(opposed))<.02&&Math.abs(dz(opposed))<.02&&(opposed>>>24)>0,"Equal opposing lights cancel direction, retain illumination");capture(c,"direction-opposed");
+        // A sealed barrier must prevent both intensity and direction reaching the probe.
+        server.runOnServer(s->{s.overworld().setBlockAndUpdate(RIGHT,Blocks.AIR.defaultBlockState());for(int y=101;y<109;y++)for(int z=93;z<116;z++)s.overworld().setBlockAndUpdate(new BlockPos(99,y,z),Blocks.STONE.defaultBlockState());});c.waitTicks(40);settle(c);
+        check(c.computeOnClient(m->ColoredLights.directionSample(PROBE))==0,"Closed wall blocks local direction and energy");capture(c,"direction-blocked");
+        server.runOnServer(s->{s.overworld().setBlockAndUpdate(LEFT,Blocks.AIR.defaultBlockState());
+            for(int y=101;y<109;y++)for(int z=93;z<116;z++)s.overworld().setBlockAndUpdate(new BlockPos(99,y,z),Blocks.AIR.defaultBlockState());
+            command(s,"gamemode creative @a");s.getPlayerList().getPlayers().getFirst().setItemSlot(net.minecraft.world.entity.EquipmentSlot.MAINHAND,new net.minecraft.world.item.ItemStack(net.minecraft.world.item.Items.TORCH));});
+        c.waitTicks(45);settle(c);capture(c,"direction-held-pbr-on");
+        c.runOnClient(m->VanillaLight.setPbr(false));c.waitTicks(35);settle(c);var heldFlat=capture(c,"direction-held-pbr-off");
+        c.runOnClient(m->VanillaLight.setPbr(true));c.waitTicks(35);settle(c);var heldRelief=capture(c,"direction-held-pbr-on-final");
+        long heldDelta=difference(heldFlat,heldRelief);check(heldDelta>1000&&c.computeOnClient(m->ColoredLights.dynamicCount())==1,"Carried light drives local PBR: "+heldDelta);
+        server.runOnServer(s->s.getPlayerList().getPlayers().getFirst().setItemSlot(net.minecraft.world.entity.EquipmentSlot.MAINHAND,net.minecraft.world.item.ItemStack.EMPTY));c.waitTicks(35);
+        c.runOnClient(m->VanillaLight.setPbr(false));c.waitTicks(35);settle(c);check(c.computeOnClient(m->ColoredLights.directionSample(LEFT))==0,"PBR OFF releases directional field");
+        c.runOnClient(m->{VanillaLight.setColoredLights(false);VanillaLight.setPbr(true);});c.waitTicks(25);capture(c,"direction-colored-off");
+        check(!c.computeOnClient(m->ColoredLights.allocated()),"Color OFF releases local field while PBR keeps its solar path");
+        System.out.println("DIRECTIONAL141_PASS localPbrDelta="+delta+" native normals, left/right, opposing sources, wall, held light, stable cache, OFF");
+    }
+    private static double dx(int c){return ((c>>16&255)-128)/127.;}
+    private static double dy(int c){return ((c>>8&255)-128)/127.;}
+    private static double dz(int c){return ((c&255)-128)/127.;}
+    private static void settle(ClientGameTestContext c){c.waitFor(m->ColoredLights.applied()&&ColoredLights.settled(),2400);c.waitTicks(14);}
+    private static long difference(Frame a,Frame b){long n=0;for(int i=0;i<a.pixels().length;i++)n+=channelDifference(a.pixels()[i],b.pixels()[i]);return n;}
+}
@@ -36,13 +36,14 @@ import net.minecraft.world.phys.Vec3;

 /** Real terrain/depth-map checks on a new flat seed 122 world; GPU readback is test-only. */
 public final class PixelShadows122ClientChecks implements FabricClientGameTest {
-    private final boolean bloomOnly,ssgiOnly,pbrOnly,closeupOnly,sunshaftOnly;
+    private final boolean bloomOnly,ssgiOnly,pbrOnly,closeupOnly,sunshaftOnly,coloredOnly;
    public PixelShadows122ClientChecks(){this(false);}
    PixelShadows122ClientChecks(boolean bloomOnly){this(bloomOnly,false);}
    PixelShadows122ClientChecks(boolean bloomOnly,boolean ssgiOnly){this(bloomOnly,ssgiOnly,false);}
    PixelShadows122ClientChecks(boolean bloomOnly,boolean ssgiOnly,boolean pbrOnly){this(bloomOnly,ssgiOnly,pbrOnly,false);}
    PixelShadows122ClientChecks(boolean bloomOnly,boolean ssgiOnly,boolean pbrOnly,boolean closeupOnly){this(bloomOnly,ssgiOnly,pbrOnly,closeupOnly,false);}
-    PixelShadows122ClientChecks(boolean bloomOnly,boolean ssgiOnly,boolean pbrOnly,boolean closeupOnly,boolean sunshaftOnly){this.sunshaftOnly=sunshaftOnly;this.bloomOnly=bloomOnly;this.ssgiOnly=ssgiOnly;this.pbrOnly=pbrOnly;this.closeupOnly=closeupOnly;}
+    PixelShadows122ClientChecks(boolean bloomOnly,boolean ssgiOnly,boolean pbrOnly,boolean closeupOnly,boolean sunshaftOnly){this(bloomOnly,ssgiOnly,pbrOnly,closeupOnly,sunshaftOnly,false);}
+    PixelShadows122ClientChecks(boolean bloomOnly,boolean ssgiOnly,boolean pbrOnly,boolean closeupOnly,boolean sunshaftOnly,boolean coloredOnly){this.coloredOnly=coloredOnly;this.sunshaftOnly=sunshaftOnly;this.bloomOnly=bloomOnly;this.ssgiOnly=ssgiOnly;this.pbrOnly=pbrOnly;this.closeupOnly=closeupOnly;}
    private static final int FLOOR = 64;
    private static final AABB PILLAR = new AABB(0, FLOOR + 1, 0, 2, FLOOR + 9, 2);
    private static final BlockPos SLAB = new BlockPos(5, FLOOR + 3, -5);
@@ -148,6 +149,7 @@ public final class PixelShadows122ClientChecks implements FabricClientGameTest {
                c.runOnClient(m -> check(VanillaLight.active(), "Native Sanctuary shader is active without an external engine"));
                float morning = c.computeOnClient(m -> m.gameRenderer.gameRenderState().levelRenderState.skyRenderState.sunAngle);

+                if(coloredOnly){if(Boolean.getBoolean("sanctuary.test.directional141Only")){DirectionalLights141ClientChecks.run(c,server);return;}ColoredLights139ClientChecks.run(c,server);if(Boolean.getBoolean("sanctuary.test.colored140"))ColoredLights140ClientChecks.run(c,server);if(Boolean.getBoolean("sanctuary.test.directional141"))DirectionalLights141ClientChecks.run(c,server);return;}
                if(sunshaftOnly){Sunshafts137ClientChecks.run(c,server);return;}
                if(closeupOnly){SsgiCloseup135ClientChecks.run(c,server);Pbr134ClientChecks.run(c,server);return;}
                if(pbrOnly){Pbr134ClientChecks.run(c,server);return;}
@@ -279,7 +281,7 @@ public final class PixelShadows122ClientChecks implements FabricClientGameTest {
                                });
                    });
                    c.waitTicks(3);
-                    c.takeScreenshot("sanctuary-beta138-shader-options-" + locale);
+                    c.takeScreenshot("sanctuary-beta141-shader-options-" + locale);
                }
                c.runOnClient(m -> m.gui.setScreen(null));
            }
@@ -563,7 +565,7 @@ public final class PixelShadows122ClientChecks implements FabricClientGameTest {
    }

    static Frame capture(ClientGameTestContext c, String name) {
-        if (name != null) c.takeScreenshot("sanctuary-beta138-shader-" + name);
+        if (name != null) c.takeScreenshot("sanctuary-beta141-shader-" + name);
        var result = new CompletableFuture<Frame>();
        c.runOnClient(m -> Screenshot.takeScreenshot(m.gameRenderer.mainRenderTarget(), image -> {
            try (image) {
@@ -0,0 +1,17 @@
+package fr.koka.sanctuary.gametest.mixin;
+
+import net.minecraft.client.renderer.Lightmap;
+import net.minecraft.client.renderer.state.LightmapRenderState;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+/** Freeze only vanilla torch flicker for image comparisons; never packaged in the mod. */
+@Mixin(Lightmap.class)
+public abstract class Colored139LightmapProbeMixin {
+    @Inject(method="render",at=@At("HEAD"))
+    private void stableBlockLight(LightmapRenderState state,CallbackInfo ci){
+        if(Boolean.getBoolean("sanctuary.test.freezeBlockFlicker")){state.blockFactor=1;state.needsUpdate=true;}
+    }
+}
@@ -10,6 +10,7 @@
    "defaultRequire": 1
  },
  "client": [
+    "Colored139LightmapProbeMixin",
    "Fourneau094ParticleProbeMixin",
    "Tooltip093FontProbeMixin",
    "ClientVsync046Mixin",
@@ -27,6 +27,15 @@ public final class DynamicLightClient {
    private static DynamicLightConfig config;
    private static final Map<Item,Integer> overrides=new IdentityHashMap<>();
    private static int ticks;
+    private static boolean invalidatingSections;
+    private static final fr.koka.sanctuary.client.shader.ColoredLightMaterials colors=new fr.koka.sanctuary.client.shader.ColoredLightMaterials();
+    private static Object models;
+    public static boolean invalidatingSections(){return invalidatingSections;}
+    private static final class ColorMix {
+        double r,g,b;
+        void add(int light,int color){if(light<=0)return;double energy=Math.pow(.8,15-light);r=Math.max(r,(color>>16&255)*energy);g=Math.max(g,(color>>8&255)*energy);b=Math.max(b,(color&255)*energy);}
+        int result(){double m=Math.max(1e-8,Math.max(r,Math.max(g,b)));return (int)Math.round(r/m*255)<<16|(int)Math.round(g/m*255)<<8|(int)Math.round(b/m*255);}
+    }
    private DynamicLightClient() {}
    public static void register(KeyMapping.Category category) {
        config=DynamicLightConfig.load();
@@ -50,7 +59,7 @@ public final class DynamicLightClient {
    }
    public static int pendingSections() {return field.pendingCount();}
    private static void reset(ClientLevel level) {
-        field=new DynamicLightField();view=new View(level,field.snapshot());ticks=0;
+        field=new DynamicLightField();view=new View(level,field.snapshot());ticks=0;colors.clear();models=null;
    }
    private static int emission(ItemStack stack) {return overrides.getOrDefault(stack.getItem(),-1)>=0?overrides.get(stack.getItem()):ItemLightEmission.of(stack);}
    private static void tick(Minecraft m) {
@@ -59,6 +68,8 @@ public final class DynamicLightClient {
        if(ticks++%config.updateIntervalTicks==0) {
            List<DynamicLightField.Source> sources=List.of();
            if(config.enabled) {
+                var currentModels=m.getModelManager().getBlockStateModelSet();if(models!=currentModels){colors.clear();models=currentModels;}
+                boolean tinted=fr.koka.sanctuary.client.shader.VanillaLight.coloredLights();
                var eye=m.getCameraEntity().getEyePosition();
                var collect=new DynamicLightField.Collector(config.dropClusterSize);
                double distance=config.range*config.range;
@@ -66,23 +77,26 @@ public final class DynamicLightClient {
                    if(entity.isRemoved() || entity.distanceToSqr(eye)>distance)continue;
                    boolean drop=entity instanceof ItemEntity;
                    int light=entity.isOnFire()?15:0;
+                    var mix=new ColorMix();if(light>0)mix.add(light,0xFFAB55);
                    double y=entity.getY()+entity.getBbHeight()*.5;
-                    if(entity instanceof ItemEntity item)light=Math.max(light,emission(item.getItem()));
+                    if(entity instanceof ItemEntity item){int emitted=emission(item.getItem());light=Math.max(light,emitted);if(emitted>0&&tinted)mix.add(emitted,colors.color(item.getItem()));}
                    else if(entity instanceof LivingEntity living) {
                        if(living instanceof Player p && p.isSpectator())continue;
-                        light=Math.max(light,Math.max(emission(living.getMainHandItem()),emission(living.getOffhandItem())));
-                        light=Math.max(light,emission(living.getItemBySlot(EquipmentSlot.HEAD)));
-                        light=Math.max(light,emission(HeadCosmeticService.appearance(living)));
+                        for(var stack:new ItemStack[]{living.getMainHandItem(),living.getOffhandItem(),living.getItemBySlot(EquipmentSlot.HEAD),HeadCosmeticService.appearance(living)}){
+                            int emitted=emission(stack);light=Math.max(light,emitted);if(emitted>0&&tinted)mix.add(emitted,colors.color(stack));
+                        }
                        y=entity.getEyeY();
                    }
-                    if(light>0)collect.add(entity.getId(),drop,entity.getX(),y,entity.getZ(),light);
+                    if(light>0)collect.add(entity.getId(),drop,entity.getX(),y,entity.getZ(),light,tinted?mix.result():0xFFFFFF);
                }
                sources=collect.finish(config.maxSources,eye.x,eye.y,eye.z,m.player==null?-1:m.player.getId());
            }
            if(field.update(sources))view=new View(m.level,field.snapshot());
        }
        // Native renderer marks only resident sections; it neither loads chunks nor rebuilds the whole world.
-        field.drain(config.sectionUpdatesPerTick,key->m.levelExtractor.setSectionDirty(
-                DynamicLightField.sectionX(key),DynamicLightField.sectionY(key),DynamicLightField.sectionZ(key)));
+        invalidatingSections=true;
+        try{field.drain(config.sectionUpdatesPerTick,key->m.levelExtractor.setSectionDirty(
+                DynamicLightField.sectionX(key),DynamicLightField.sectionY(key),DynamicLightField.sectionZ(key)));}
+        finally{invalidatingSections=false;}
    }
 }
@@ -0,0 +1,37 @@
+package fr.koka.sanctuary.client.shader;
+
+import fr.koka.sanctuary.client.DynamicLightClient;
+import fr.koka.sanctuary.lighting.DynamicLightField;
+import java.util.*;
+import net.minecraft.client.Minecraft;
+import net.minecraft.world.phys.Vec3;
+
+/** Same bounded sources as native dynamic lighting, with visual interpolation only. */
+final class ColoredDynamicLights {
+    static final int LIMIT=128;
+    static final class Light {
+        double x,y,z,r,g,b,visibility;int level;boolean seen;
+        Light(DynamicLightField.Source s){x=s.x();y=s.y();z=s.z();level=s.light();r=(s.color()>>16&255)/255.;g=(s.color()>>8&255)/255.;b=(s.color()&255)/255.;}
+    }
+    private final Map<DynamicLightField.Id,Light> lights=new HashMap<>();
+    private long last;
+    List<Light> update(Vec3 camera){
+        long now=System.nanoTime();double dt=last==0?0:Math.min(.1,(now-last)/1e9);last=now;
+        double ease=1-Math.exp(-dt*14),fade=dt/.3;
+        lights.values().forEach(l->l.seen=false);
+        var mc=Minecraft.getInstance();
+        for(var s:DynamicLightClient.snapshot(mc.level).sources()){
+            Light l=lights.computeIfAbsent(s.id(),id->new Light(s));l.seen=true;l.level=s.light();
+            boolean own=!s.id().drop()&&mc.player!=null&&s.id().value()==mc.player.getId()
+                    &&mc.getCameraEntity()==mc.player&&mc.options.getCameraType().isFirstPerson();
+            double x=own?camera.x:s.x(),y=own?camera.y:s.y(),z=own?camera.z:s.z();
+            double step=own?1:ease;l.x+=(x-l.x)*step;l.y+=(y-l.y)*step;l.z+=(z-l.z)*step;
+            l.r+=((s.color()>>16&255)/255.-l.r)*ease;l.g+=((s.color()>>8&255)/255.-l.g)*ease;l.b+=((s.color()&255)/255.-l.b)*ease;
+        }
+        for(var it=lights.values().iterator();it.hasNext();){var l=it.next();l.visibility=Math.clamp(l.visibility+(l.seen?fade:-fade),0,1);if(!l.seen&&l.visibility<=0)it.remove();}
+        return lights.values().stream().filter(l->camera.distanceToSqr(l.x,l.y,l.z)<Math.pow(VanillaLight.coloredLightDistance()+l.level,2))
+                .sorted(Comparator.comparingDouble(l->camera.distanceToSqr(l.x,l.y,l.z))).limit(LIMIT).toList();
+    }
+    Vec3 position(long entity){var l=lights.get(new DynamicLightField.Id(false,entity));return l==null?null:new Vec3(l.x,l.y,l.z);}
+    void clear(){lights.clear();last=0;}
+}
@@ -0,0 +1,73 @@
+package fr.koka.sanctuary.client.shader;
+
+import java.util.*;
+import net.minecraft.client.Minecraft;
+import net.minecraft.core.Direction;
+import net.minecraft.core.registries.BuiltInRegistries;
+import net.minecraft.resources.Identifier;
+import net.minecraft.util.RandomSource;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.client.renderer.block.dispatch.BlockStateModelPart;
+
+/** Colours are analysed once per state/resource reload, never from rendered GPU pixels. */
+public final class ColoredLightMaterials {
+    private final Map<BlockState,Integer> colors=new IdentityHashMap<>();
+    private final Map<Identifier,Integer> sprites=new HashMap<>();
+    private boolean warm;
+    public int color(BlockState state){if(warm!=VanillaLight.warmTorches()){warm=VanillaLight.warmTorches();clear();}return colors.computeIfAbsent(state,this::analyse);}
+    public int color(net.minecraft.world.item.ItemStack stack){
+        var state=fr.koka.sanctuary.cosmetics.HeadCosmeticData.state(stack);
+        if(state!=null)return color(state);
+        var item=stack.getItem();
+        if(item==net.minecraft.world.item.Items.LAVA_BUCKET)return 0xFF6020;
+        if(item==net.minecraft.world.item.Items.BLAZE_ROD||item==net.minecraft.world.item.Items.BLAZE_POWDER)return 0xFFAB55;
+        if(item==net.minecraft.world.item.Items.GLOWSTONE_DUST)return color(net.minecraft.world.level.block.Blocks.GLOWSTONE.defaultBlockState());
+        if(item==net.minecraft.world.item.Items.GLOW_BERRIES)return 0xFFBD52;
+        if(item==net.minecraft.world.item.Items.GLOW_INK_SAC||item==net.minecraft.world.item.Items.GLOW_ITEM_FRAME)return 0x66EADD;
+        return 0xFFFFFF;
+    }
+    private int analyse(BlockState state){
+        var id=BuiltInRegistries.BLOCK.getKey(state.getBlock());String name=id.getPath();
+        if(id.getNamespace().equals("minecraft")){
+            if(name.contains("copper"))return 0x62FFA0;
+            if(name.startsWith("soul_"))return 0x55BDFF;
+            if(name.contains("redstone"))return 0xFF0602;
+            if(name.equals("torch")||name.equals("wall_torch"))return VanillaLight.warmTorches()?0xFFAB55:0xFFFFFF;
+            if(name.equals("lava"))return 0xFF6020;
+            if(name.equals("pearlescent_froglight"))return 0xFFC0EC;
+            if(name.equals("verdant_froglight"))return 0xB4FF82;
+            if(name.equals("ochre_froglight"))return 0xFFCD72;
+            if(name.contains("torch")||name.equals("lantern")||name.equals("fire")||name.equals("campfire")||name.equals("lava"))return 0xFFAB55;
+        }
+        var parts=new ArrayList<BlockStateModelPart>();
+        Minecraft.getInstance().getModelManager().getBlockStateModelSet().get(state).collectParts(RandomSource.create(0),parts);
+        var used=new HashSet<Identifier>();long r=0,g=0,b=0;int count=0;
+        for(var part:parts)for(int f=0;f<7;f++)for(var quad:part.getQuads(f==6?null:Direction.values()[f])){
+            var sprite=quad.materialInfo().sprite().contents().name();if(!used.add(sprite))continue;
+            int color=sprites.computeIfAbsent(sprite,this::sample);if(color<0)continue;
+            r+=color>>16&255;g+=color>>8&255;b+=color&255;count++;
+        }
+        if(count==0)return 0xFFFFFF;
+        return normalize((float)r/count,(float)g/count,(float)b/count);
+    }
+    private int sample(Identifier id){
+        try(var image=BloomMaterials.read(id)){
+            double r=0,g=0,b=0,weight=0;
+            // First animation frame; bounded sampling also covers high-resolution packs.
+            int w=image.getWidth(),h=Math.min(w,image.getHeight()),step=Math.max(1,Math.max(w,h)/32);
+            for(int y=0;y<h;y+=step)for(int x=0;x<w;x+=step){
+                int c=image.getPixel(x,y);if((c>>>24)<128)continue;
+                int cr=c>>16&255,cg=c>>8&255,cb=c&255,max=Math.max(cr,Math.max(cg,cb)),min=Math.min(cr,Math.min(cg,cb));
+                double k=Math.max(0,(max-96)/159.0);k*=k*(.2+(max-min)/255.0);
+                r+=cr*k;g+=cg*k;b+=cb*k;weight+=k;
+            }
+            return weight<.001?-1:normalize((float)(r/weight),(float)(g/weight),(float)(b/weight));
+        }catch(java.io.IOException e){return -1;}
+    }
+    private static int normalize(float r,float g,float b){
+        float max=Math.max(1,Math.max(r,Math.max(g,b)));
+        return Math.round(r/max*255)<<16|Math.round(g/max*255)<<8|Math.round(b/max*255);
+    }
+    public void clear(){colors.clear();sprites.clear();}
+    int cachedStates(){return colors.size();}
+}
@@ -0,0 +1,161 @@
+package fr.koka.sanctuary.client.shader;
+
+import com.mojang.blaze3d.platform.NativeImage;
+import it.unimi.dsi.fastutil.ints.IntArrayFIFOQueue;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.multiplayer.ClientLevel;
+import net.minecraft.client.renderer.texture.DynamicTexture;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
+import net.minecraft.world.level.LightLayer;
+import net.minecraft.world.level.block.Blocks;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.chunk.LevelChunk;
+import net.minecraft.world.level.chunk.status.ChunkStatus;
+
+/** Client-only RGB propagation. Snapshot, flood and packing share a bounded per-frame work budget. */
+final class ColoredLightVolume implements AutoCloseable {
+    static int sideFor(int distance){return (distance+20)*2;}
+    static int columns(int side){return (int)Math.ceil(Math.sqrt(side));}
+    private static final Direction[] DIRECTIONS=Direction.values();
+    private final ColoredLightMaterials materials=new ColoredLightMaterials();
+    private ClientLevel level;
+    private Object models;
+    private Build build;
+    private DynamicTexture texture,previous,direction,previousDirection;
+    private boolean directional;
+    DynamicTexture direction(){return direction;}
+    DynamicTexture previousDirection(){return previousDirection;}
+    private BlockPos previousOrigin;
+    private int side,previousSide;
+    private long transitionStarted;
+    float blend(){return Math.clamp((System.nanoTime()-transitionStarted)/300_000_000f,0,1);}
+    DynamicTexture previous(){return previous;}
+    BlockPos previousOrigin(){return previousOrigin;}
+    int previousSide(){return previousSide;}
+    int side(){return side;}
+    private BlockPos origin;
+    private long revision,published=-1,lastStart;
+    private int completed;
+    private boolean warm;
+    void update(){
+        var mc=Minecraft.getInstance();var modelSet=mc.getModelManager().getBlockStateModelSet();
+        if(level!=mc.level||models!=modelSet){close();level=mc.level;models=modelSet;}
+        if(warm!=VanillaLight.warmTorches()){warm=VanillaLight.warmTorches();materials.clear();revision++;if(build!=null){build.close();build=null;}}
+        var p=mc.gameRenderer.gameRenderState().levelRenderState.cameraRenderState.pos;
+        boolean wantedDirection=VanillaLight.pbr()&&VanillaLight.pbrIntensity()>0;
+        int wantedSide=sideFor(VanillaLight.coloredLightDistance());
+        var wanted=new BlockPos(anchor(p.x,wantedSide),anchor(p.y,wantedSide),anchor(p.z,wantedSide));
+        long now=System.nanoTime();
+        if(previous!=null&&blend()>=1){previous.close();previous=null;previousOrigin=null;if(previousDirection!=null){previousDirection.close();previousDirection=null;}}
+        // Complete a snapshot even if the world keeps changing, then catch up; moving
+        // beyond it cancels immediately. Static worlds do no further scanning or flooding.
+        if(build!=null&&(build.directional!=wantedDirection||build.side!=wantedSide||!inside(build.origin,BlockPos.containing(p),build.side))){build.close();build=null;}
+        if(build==null&&previous==null&&(texture==null||directional!=wantedDirection||side!=wantedSide||!wanted.equals(origin)||published!=revision)&&now-lastStart>=100_000_000L){
+            build=new Build(level,wanted,wantedSide,revision,materials,wantedDirection);lastStart=now;
+        }
+        if(build!=null&&build.advance(now+2_000_000L)){
+            previous=texture;previousOrigin=origin;previousSide=side;previousDirection=direction;
+            direction=build.directionImage==null?null:new DynamicTexture(()->"Sanctuary light direction",build.takeDirectionImage());directional=build.directional;
+            texture=new DynamicTexture(()->"Sanctuary coloured light volume",build.takeImage());
+            side=build.side;transitionStarted=System.nanoTime();
+            origin=build.origin;published=build.revision;build.close();build=null;completed++;
+        }
+    }
+    private static int anchor(double p,int side){return Math.floorDiv((int)Math.floor(p),4)*4-side/2;}
+    private static boolean inside(BlockPos base,BlockPos p,int side){return p.getX()>=base.getX()&&p.getX()<base.getX()+side&&p.getY()>=base.getY()&&p.getY()<base.getY()+side&&p.getZ()>=base.getZ()&&p.getZ()<base.getZ()+side;}
+    void dirty(BlockPos p){if(origin!=null&&inside(origin,p,side)||build!=null&&inside(build.origin,p,build.side))revision++;}
+    void dirtyChunk(int x,int z){if(overlaps(origin,x,z,side)||build!=null&&overlaps(build.origin,x,z,build.side))revision++;}
+    void dirtySection(int x,int y,int z){if(overlapsSection(origin,x,y,z,side)||build!=null&&overlapsSection(build.origin,x,y,z,build.side))revision++;}
+    private static boolean overlapsSection(BlockPos o,int x,int y,int z,int side){return overlaps(o,x,z,side)&&y>=(o.getY()>>4)&&y<=((o.getY()+side-1)>>4);}
+    private static boolean overlaps(BlockPos o,int x,int z,int side){return o!=null&&x>=(o.getX()>>4)&&x<=((o.getX()+side-1)>>4)&&z>=(o.getZ()>>4)&&z<=((o.getZ()+side-1)>>4);}
+    DynamicTexture texture(){return texture;}
+    BlockPos origin(){return origin;}
+    boolean settled(){return texture!=null&&build==null&&revision==published&&blend()>=1;}
+    int completed(){return completed;}
+    int directionSample(BlockPos p){if(direction==null||!inside(origin,p,side))return 0;int x=p.getX()-origin.getX(),y=p.getY()-origin.getY(),z=p.getZ()-origin.getZ(),cols=columns(side);return direction.getPixels().getPixel(x+(y%cols)*side,z+(y/cols)*side);}
+    int cachedStates(){return materials.cachedStates();}
+    int sample(BlockPos p){if(texture==null||!inside(origin,p,side))return 0;int x=p.getX()-origin.getX(),y=p.getY()-origin.getY(),z=p.getZ()-origin.getZ(),cols=columns(side);return texture.getPixels().getPixel(x+(y%cols)*side,z+(y/cols)*side);}
+    public void close(){if(build!=null){build.close();build=null;}if(texture!=null){texture.close();texture=null;}if(previous!=null){previous.close();previous=null;}if(direction!=null){direction.close();direction=null;}if(previousDirection!=null){previousDirection.close();previousDirection=null;}materials.clear();level=null;models=null;origin=null;previousOrigin=null;side=previousSide=0;published=-1;revision=0;lastStart=0;}
+
+    private static final class Build implements AutoCloseable {
+        final int side,count,cols,chunkSide;
+        final ClientLevel level;final BlockPos origin;final long revision;final ColoredLightMaterials materials;
+        final BlockState[] states;
+        final byte[] red,green,blue,sky;
+        final boolean[] queued;final IntArrayFIFOQueue queue=new IntArrayFIFOQueue();
+        final LevelChunk[] chunks;final int cx,cz;
+        final BlockPos.MutableBlockPos pos=new BlockPos.MutableBlockPos();
+        NativeImage image,directionImage;final boolean directional;int scan,packed;
+        private static final double[] ENERGY=new double[256];
+        static{for(int i=129;i<256;i++)ENERGY[i]=Math.max(0,(Math.pow(.8,31-i/8.)-Math.pow(.8,15))/(1-Math.pow(.8,15)));}
+        Build(ClientLevel level,BlockPos origin,int side,long revision,ColoredLightMaterials materials,boolean directional){
+            this.directional=directional;this.side=side;count=side*side*side;cols=columns(side);chunkSide=(side+15)/16+1;
+            states=new BlockState[count];red=new byte[count];green=new byte[count];blue=new byte[count];sky=new byte[count];queued=new boolean[count];chunks=new LevelChunk[chunkSide*chunkSide];
+            image=new NativeImage(cols*side,((side+cols-1)/cols)*side,false);
+            if(directional)directionImage=new NativeImage(image.getWidth(),image.getHeight(),false);
+            this.level=level;this.origin=origin;this.revision=revision;this.materials=materials;
+            cx=origin.getX()>>4;cz=origin.getZ()>>4;
+            for(int z=0;z<chunkSide;z++)for(int x=0;x<chunkSide;x++)chunks[x+z*chunkSide]=level.getChunkSource().getChunk(cx+x,cz+z,ChunkStatus.FULL,false);
+        }
+        boolean advance(long deadline){
+            while(scan<count){scan(scan++);if((scan&127)==0&&System.nanoTime()>=deadline)return false;}
+            int work=0;
+            while(!queue.isEmpty()){
+                int i=queue.dequeueInt();queued[i]=false;spread(i);
+                if((++work&127)==0&&System.nanoTime()>=deadline)return false;
+            }
+            while(packed<count){
+                int i=packed++,x=i%side,z=i/side%side,y=i/(side*side);
+                image.setPixel(x+(y%cols)*side,z+(y/cols)*side,(sky[i]&255)<<24|(red[i]&255)<<16|(green[i]&255)<<8|(blue[i]&255));
+                if(directional)directionImage.setPixel(x+(y%cols)*side,z+(y/cols)*side,directionAt(i,x,y,z));
+                if((packed&511)==0&&System.nanoTime()>=deadline)return false;
+            }
+            return true;
+        }
+        void scan(int i){
+            int x=origin.getX()+(i%side),z=origin.getZ()+(i/side%side),y=origin.getY()+(i/(side*side));pos.set(x,y,z);
+            var chunk=chunks[((x>>4)-cx)+((z>>4)-cz)*chunkSide];
+            var state=chunk==null||level.isOutsideBuildHeight(y)?Blocks.BEDROCK.defaultBlockState():chunk.getBlockState(pos);states[i]=state;
+            if(chunk!=null&&!level.isOutsideBuildHeight(y))sky[i]=(byte)(level.getBrightness(LightLayer.SKY,pos)*17);
+            int emission=state.getLightEmission();if(emission<=0)return;
+            int c=materials.color(state);red[i]=(byte)encode(emission,c>>16&255);green[i]=(byte)encode(emission,c>>8&255);blue[i]=(byte)encode(emission,c&255);enqueue(i);
+        }
+        void spread(int i){
+            int r=red[i]&255,g=green[i]&255,b=blue[i]&255;if(Math.max(r,Math.max(g,b))<=136)return;
+            int x=i%side,z=i/side%side,y=i/(side*side);
+            for(var d:DIRECTIONS){
+                int nx=x+d.getStepX(),ny=y+d.getStepY(),nz=z+d.getStepZ();if(nx<0||nx>=side||ny<0||ny>=side||nz<0||nz>=side)continue;
+                int n=nx+nz*side+ny*side*side;
+                if(r-8<=(red[n]&255)&&g-8<=(green[n]&255)&&b-8<=(blue[n]&255))continue;
+                int loss=net.minecraft.world.level.lighting.LightEngine.getLightDampeningInto(states[i],states[n],d,Math.max(1,states[n].getLightDampening()))*8;
+                int nr=Math.max(0,r-loss),ng=Math.max(0,g-loss),nb=Math.max(0,b-loss);if(Math.max(nr,Math.max(ng,nb))<=128)continue;boolean changed=false;
+                if(nr>(red[n]&255)){red[n]=(byte)nr;changed=true;}if(ng>(green[n]&255)){green[n]=(byte)ng;changed=true;}if(nb>(blue[n]&255)){blue[n]=(byte)nb;changed=true;}
+                if(changed)enqueue(n);
+            }
+        }
+        double energy(int i){return ENERGY[Math.max(red[i]&255,Math.max(green[i]&255,blue[i]&255))];}
+        int directionAt(int i,int x,int y,int z){
+            double energy=energy(i);if(energy<=0)return 0;
+            double vx=0,vy=0,vz=0,total=0;
+            for(var d:DIRECTIONS){
+                int nx=x+d.getStepX(),ny=y+d.getStepY(),nz=z+d.getStepZ();
+                if(nx<0||nx>=side||ny<0||ny>=side||nz<0||nz>=side)continue;
+                int n=nx+nz*side+ny*side*side;double w=Math.max(0,energy(n)-energy);
+                if(w<=0||net.minecraft.world.level.lighting.LightEngine.getLightDampeningInto(states[n],states[i],d.getOpposite(),Math.max(1,states[i].getLightDampening()))>=15)continue;
+                vx+=d.getStepX()*w;vy+=d.getStepY()*w;vz+=d.getStepZ()*w;total+=w;
+            }
+            // The vector length is confidence: opposing arrivals cancel instead of flipping.
+            double scale=total>1e-12?127/total:0;
+            int a=(int)Math.round(255*energy/(energy+.08));
+            return a<<24|(int)Math.round(128+vx*scale)<<16|(int)Math.round(128+vy*scale)<<8|(int)Math.round(128+vz*scale);
+        }
+        NativeImage takeDirectionImage(){var result=directionImage;directionImage=null;return result;}
+        void enqueue(int i){if(!queued[i]){queued[i]=true;queue.enqueue(i);}}
+        NativeImage takeImage(){var result=image;image=null;return result;}
+        public void close(){if(image!=null){image.close();image=null;}if(directionImage!=null){directionImage.close();directionImage=null;}}
+    }
+    // An offset preserves dim colour channels below native level zero. The shader
+    // applies the native cutoff to overall energy, never to each channel separately.
+    static int encode(int emission,int channel){return channel==0?0:Math.clamp((int)Math.round((emission+16+Math.log(channel/255.0)/Math.log(1.25))*8),0,248);}
+}
@@ -0,0 +1,117 @@
+package fr.koka.sanctuary.client.shader;
+
+import com.mojang.blaze3d.buffers.Std140Builder;
+import com.mojang.blaze3d.pipeline.TextureTarget;
+import com.mojang.blaze3d.systems.RenderSystem;
+import com.mojang.renderpearl.api.GpuFormat;
+import com.mojang.renderpearl.api.buffers.GpuBuffer;
+import com.mojang.renderpearl.api.pipeline.*;
+import com.mojang.renderpearl.api.textures.FilterMode;
+import fr.koka.sanctuary.client.panorama.PanoramaCapture;
+import java.util.Optional;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.renderer.MappableRingBuffer;
+import net.minecraft.client.renderer.RenderPipelines;
+import net.minecraft.core.BlockPos;
+import net.minecraft.resources.Identifier;
+import net.minecraft.world.level.material.FogType;
+import org.joml.Matrix4f;
+
+/** Visual local colour only: native block/sky light and gameplay remain unchanged. */
+public final class ColoredLights {
+    private static final RenderPipeline APPLY=RenderPipelines.register(RenderPipeline.builder()
+            .withLocation(Identifier.parse("sanctuary:pipeline/colored_lights"))
+            .withVertexShader("core/screenquad").withFragmentShader(Identifier.parse("sanctuary:core/colored_lights"))
+            .withBindGroupLayout(BindGroupLayout.builder().withUniform("ColoredLightScene",UniformType.UNIFORM_BUFFER)
+                    .withUniform("WorldDepth",UniformType.COMBINED_IMAGE_SAMPLER)
+                    .withUniform("SceneColor",UniformType.COMBINED_IMAGE_SAMPLER)
+                    .withUniform("LightVolume",UniformType.COMBINED_IMAGE_SAMPLER)
+                    .withUniform("PreviousVolume",UniformType.COMBINED_IMAGE_SAMPLER).build())
+            .withPrimitiveTopology(PrimitiveTopology.TRIANGLES).withCull(false)
+            .withColorTargetState(new ColorTargetState(Optional.of(new BlendFunction(BlendFactor.ONE,BlendFactor.ZERO,BlendFactor.ZERO,BlendFactor.ONE)),GpuFormat.RGBA8_UNORM,ColorTargetState.WRITE_COLOR))
+            .withDepthStencilState(Optional.empty()).build());
+    private static final ColoredLightVolume VOLUME=new ColoredLightVolume();
+    private static final Matrix4f projection=new Matrix4f();
+    private static TextureTarget source;
+    private static net.minecraft.client.renderer.texture.DynamicTexture black;
+    private static final ColoredDynamicLights DYNAMIC=new ColoredDynamicLights();
+    private static long activated,lastRender;
+    private static float displayedDistance;
+    private static int dynamicCount;
+    private static MappableRingBuffer uniforms;
+    private static boolean applied,prepared;
+    private static int frames;
+    private ColoredLights(){}
+    public static void captureProjection(Matrix4f matrix){projection.set(matrix);}
+    public static void dirtyBlock(BlockPos pos){VOLUME.dirty(pos);}
+    public static void dirtyChunk(int x,int z){VOLUME.dirtyChunk(x,z);}
+    public static void dirtySection(int x,int y,int z){if(!fr.koka.sanctuary.client.DynamicLightClient.invalidatingSections())VOLUME.dirtySection(x,y,z);}
+    public static void prepare(){
+        applied=false;prepared=false;var mc=Minecraft.getInstance();
+        if(!VanillaLight.active()||!VanillaLight.coloredLights()||VanillaLight.coloredLightIntensity()==0||mc.level==null){release();return;}
+        if(PanoramaCapture.rendering())return;
+        var camera=mc.gameRenderer.gameRenderState().levelRenderState.cameraRenderState;
+        if(camera.fogType!=FogType.NONE)return;
+        long now=System.nanoTime();if(activated==0){activated=now;displayedDistance=VanillaLight.coloredLightDistance();}
+        double elapsed=lastRender==0?0:Math.min(.1,(now-lastRender)/1e9);lastRender=now;
+        displayedDistance+=(VanillaLight.coloredLightDistance()-displayedDistance)*(float)(1-Math.exp(-elapsed*10));
+        VOLUME.update();
+        if(black==null){var image=new com.mojang.blaze3d.platform.NativeImage(1,1,false);image.setPixel(0,0,0);black=new net.minecraft.client.renderer.texture.DynamicTexture(()->"Empty coloured light",image);}
+        var lights=DYNAMIC.update(camera.pos);dynamicCount=lights.size();
+        var current=VOLUME.texture()==null?black:VOLUME.texture();
+        var previous=VOLUME.previous()==null?black:VOLUME.previous();
+        var main=mc.gameRenderer.mainRenderTarget();
+        if(source==null||source.width!=main.width||source.height!=main.height){if(source!=null)source.destroyBuffers();source=new TextureTarget("Sanctuary coloured light source",main.width,main.height,GpuFormat.RGBA8_UNORM,null);}
+        if(uniforms==null)uniforms=new MappableRingBuffer(()->"Sanctuary coloured light scene",GpuBuffer.USAGE_UNIFORM|GpuBuffer.USAGE_MAP_WRITE,176+ColoredDynamicLights.LIMIT*32);
+        var base=VOLUME.origin()==null?BlockPos.containing(camera.pos):VOLUME.origin();var fog=camera.fogData;
+        var old=VOLUME.previousOrigin()==null?base:VOLUME.previousOrigin();
+        int side=VOLUME.texture()==null?1:VOLUME.side(),oldSide=VOLUME.previous()==null?1:VOLUME.previousSide();
+        uniforms.rotate();try(var mapped=uniforms.currentBuffer().map(false,true)){
+            var data=Std140Builder.intoBuffer(mapped.data()).putMat4f(new Matrix4f(projection).mul(camera.viewRotationMatrix).invert())
+                    .putVec4((float)(camera.pos.x-base.getX()),(float)(camera.pos.y-base.getY()),(float)(camera.pos.z-base.getZ()),VanillaLight.coloredLightIntensity()/100f)
+                    .putVec4(RenderSystem.getDevice().getDeviceInfo().isZZeroToOne()?1:0,Math.clamp((15-mc.level.getSkyDarken())/15f,0,1),fog.color.w,0)
+                    .putVec4(fog.renderDistanceStart,fog.renderDistanceEnd,fog.environmentalStart,fog.environmentalEnd)
+                    .putVec4(displayedDistance,VOLUME.texture()==null?0:VOLUME.blend(),Math.clamp((now-activated)/300_000_000f,0,1),lights.size())
+                    .putVec4(side,ColoredLightVolume.columns(side),current.getPixels().getWidth(),current.getPixels().getHeight())
+                    .putVec4((float)(camera.pos.x-old.getX()),(float)(camera.pos.y-old.getY()),(float)(camera.pos.z-old.getZ()),VOLUME.previous()==null?0:1)
+                    .putVec4(oldSide,ColoredLightVolume.columns(oldSide),previous.getPixels().getWidth(),previous.getPixels().getHeight());
+            for(int i=0;i<ColoredDynamicLights.LIMIT;i++){if(i<lights.size()){var l=lights.get(i);data.putVec4((float)(l.x-camera.pos.x),(float)(l.y-camera.pos.y),(float)(l.z-camera.pos.z),l.level);}else data.putVec4(0,0,0,0);}
+            for(int i=0;i<ColoredDynamicLights.LIMIT;i++){if(i<lights.size()){var l=lights.get(i);data.putVec4((float)l.r,(float)l.g,(float)l.b,(float)l.visibility);}else data.putVec4(0,0,0,0);}
+        }
+        prepared=true;
+    }
+    static void bindDirections(com.mojang.renderpearl.api.commands.RenderPass pass){
+        var nearest=RenderSystem.getSamplerCache().getClampToEdge(FilterMode.NEAREST);
+        pass.setUniform("ColoredLightScene",uniforms.currentBuffer());
+        pass.setUniform("LightDirection",(VOLUME.direction()==null?black:VOLUME.direction()).getTextureView(),nearest);
+        pass.setUniform("PreviousDirection",(VOLUME.previousDirection()==null?black:VOLUME.previousDirection()).getTextureView(),nearest);
+    }
+    static boolean directionalReady(){return prepared&&VanillaLight.pbr();}
+    public static void render(){
+        if(!prepared)return;
+        var main=Minecraft.getInstance().gameRenderer.mainRenderTarget();
+        var current=VOLUME.texture()==null?black:VOLUME.texture();
+        var previous=VOLUME.previous()==null?black:VOLUME.previous();
+        var encoder=RenderSystem.getDevice().createCommandEncoder();
+        encoder.copyTextureToTexture(main.getColorTexture(),source.getColorTexture(),0,0,0,0,0,main.width,main.height);
+        var nearest=RenderSystem.getSamplerCache().getClampToEdge(FilterMode.NEAREST);
+        try(var pass=encoder.createRenderPass(()->"Sanctuary coloured light",main.getColorTextureView(),Optional.empty())){
+            pass.setPipeline(RenderSystem.getCompiledPipeline(APPLY));pass.setUniform("ColoredLightScene",uniforms.currentBuffer());
+            pass.setUniform("WorldDepth",main.getDepthTextureView(),nearest);pass.setUniform("SceneColor",source.getColorTextureView(),nearest);pass.setUniform("LightVolume",current.getTextureView(),nearest);pass.setUniform("PreviousVolume",previous.getTextureView(),nearest);pass.draw(3,1,0,0);
+        }
+        applied=true;frames++;
+    }
+    public static void release(){prepared=false;VOLUME.close();DYNAMIC.clear();activated=lastRender=0;dynamicCount=0;if(black!=null){black.close();black=null;}if(source!=null){source.destroyBuffers();source=null;}if(uniforms!=null){uniforms.close();uniforms=null;}applied=false;}
+    static boolean applied(){return applied;}
+    static boolean allocated(){return source!=null||VOLUME.texture()!=null;}
+    static boolean settled(){return VOLUME.settled();}
+    static int renderedFrames(){return frames;}
+    static int builds(){return VOLUME.completed();}
+    static int sample(BlockPos pos){return VOLUME.sample(pos);}
+    static net.minecraft.world.phys.Vec3 dynamicPosition(long entity){return DYNAMIC.position(entity);}
+    static int dynamicCount(){return dynamicCount;}
+    static float blend(){return VOLUME.blend();}
+    static int volumeSide(){return VOLUME.side();}
+    static int directionSample(BlockPos pos){return VOLUME.directionSample(pos);}
+    static int materials(){return VOLUME.cachedStates();}
+}
@@ -28,6 +28,7 @@ public final class ProceduralPbr {
    private static final BindGroupLayout SCENE=BindGroupLayout.builder().withUniform("PbrScene",UniformType.UNIFORM_BUFFER)
            .withUniform("PixelShadows",UniformType.UNIFORM_BUFFER).withUniform("SunDepth",UniformType.COMBINED_IMAGE_SAMPLER)
            .withUniform("WorldDepth",UniformType.COMBINED_IMAGE_SAMPLER).withUniform("SceneColor",UniformType.COMBINED_IMAGE_SAMPLER)
+            .withUniform("ColoredLightScene",UniformType.UNIFORM_BUFFER).withUniform("LightDirection",UniformType.COMBINED_IMAGE_SAMPLER).withUniform("PreviousDirection",UniformType.COMBINED_IMAGE_SAMPLER)
            .withUniform("BlockAtlas",UniformType.COMBINED_IMAGE_SAMPLER).withUniform("MaterialAtlas",UniformType.COMBINED_IMAGE_SAMPLER).build();
    private static final RenderPipeline PIPELINE=RenderPipelines.register(RenderPipeline.builder()
            .withLocation(Identifier.parse("sanctuary:pipeline/pbr")).withVertexShader(Identifier.parse("sanctuary:core/pbr"))
@@ -52,8 +53,8 @@ public final class ProceduralPbr {
        if(PanoramaCapture.rendering()||camera.fogType!=FogType.NONE||sky.skybox!=DimensionType.Skybox.OVERWORLD)return;
        var main=mc.gameRenderer.mainRenderTarget();
        if(source==null||source.width!=main.width||source.height!=main.height){if(source!=null)source.destroyBuffers();source=new TextureTarget("Sanctuary PBR source",main.width,main.height,GpuFormat.RGBA8_UNORM,null);}
-        // The extra padding also supplies a valid inactive PixelShadows binding (192 bytes).
-        if(scene==null)scene=new MappableRingBuffer(()->"Sanctuary PBR scene",GpuBuffer.USAGE_UNIFORM|GpuBuffer.USAGE_MAP_WRITE,192);
+        // Padding supplies valid inactive PixelShadows and local-light uniform bindings.
+        if(scene==null)scene=new MappableRingBuffer(()->"Sanctuary PBR scene",GpuBuffer.USAGE_UNIFORM|GpuBuffer.USAGE_MAP_WRITE,176+ColoredDynamicLights.LIMIT*32);
        var entries=TERRAIN.update();var atlas=TERRAIN.materials.atlas();
        var vp=new Matrix4f(projection).mul(camera.viewRotationMatrix);var fog=camera.fogData;
        var sun=PixelShadows.sunDirection(sky.sunAngle);boolean lunar=sun.y<=.08f;
@@ -65,7 +66,7 @@ public final class ProceduralPbr {
            Std140Builder.intoBuffer(mapped.data()).putMat4f(new Matrix4f(vp).invert())
                    .putVec4(sun.x,sun.y,sun.z,strength)
                    .putVec4(VanillaLight.pbrIntensity()/100f,RenderSystem.getDevice().getDeviceInfo().isZZeroToOne()?1:0,shadow?1:0,32)
-                    .putVec4(fog.renderDistanceStart,fog.renderDistanceEnd,fog.environmentalStart,fog.environmentalEnd).putVec4(fog.color.w,0,0,0)
+                    .putVec4(fog.renderDistanceStart,fog.renderDistanceEnd,fog.environmentalStart,fog.environmentalEnd).putVec4(fog.color.w,ColoredLights.directionalReady()?1:0,0,0)
                    .putVec4(0,0,0,0).putVec4(0,0,0,0).putVec4(0,0,0,0).putVec4(0,0,0,0);
        }
        var transforms=new ArrayList<GpuBufferSlice>(entries.size());int max=0;
@@ -81,7 +82,10 @@ public final class ProceduralPbr {
            pass.setUniform("SunDepth",shadow?PixelShadows.materialDepth():main.getDepthTextureView(),nearest);
            pass.setUniform("WorldDepth",main.getDepthTextureView(),nearest);pass.setUniform("SceneColor",source.getColorTextureView(),nearest);
            pass.setUniform("BlockAtlas",mc.getTextureManager().getTexture(TextureAtlas.LOCATION_BLOCKS).getTextureView(),nearest);
-            pass.setUniform("MaterialAtlas",atlas.getTextureView(),nearest);pass.setIndexBuffer(indices.getBuffer(),indices.type());
+            pass.setUniform("MaterialAtlas",atlas.getTextureView(),nearest);
+            if(ColoredLights.directionalReady())ColoredLights.bindDirections(pass);
+            else{pass.setUniform("ColoredLightScene",scene.currentBuffer());pass.setUniform("LightDirection",source.getColorTextureView(),nearest);pass.setUniform("PreviousDirection",source.getColorTextureView(),nearest);}
+            pass.setIndexBuffer(indices.getBuffer(),indices.type());
            for(int i=0;i<entries.size();i++){var entry=entries.get(i);pass.setUniform("DynamicTransforms",transforms.get(i));pass.setVertexBuffer(0,entry.vertices().slice());pass.drawIndexed(entry.indices(),1,0,0,0);}
        }
        applied=true;frames++;
@@ -23,6 +23,14 @@ public final class ShaderOptionsScreen extends OptionsSubScreen {
        list.addBig(OptionInstance.createBoolean("sanctuary.shaders.pbr",OptionInstance.cachedConstantTooltip(
                Component.translatable("sanctuary.shaders.pbr_help")),VanillaLight.pbr(),VanillaLight::setPbr));
        slider("pbr_intensity",VanillaLight.pbrIntensity(),VanillaLight::setPbrIntensity);
+        list.addBig(OptionInstance.createBoolean("sanctuary.shaders.colored_lights",OptionInstance.cachedConstantTooltip(
+                Component.translatable("sanctuary.shaders.colored_lights_help")),VanillaLight.coloredLights(),VanillaLight::setColoredLights));
+        list.addBig(OptionInstance.createBoolean("sanctuary.shaders.warm_torches",OptionInstance.cachedConstantTooltip(
+                Component.translatable("sanctuary.shaders.warm_torches_help")),VanillaLight.warmTorches(),VanillaLight::setWarmTorches));
+        slider("colored_light_intensity",VanillaLight.coloredLightIntensity(),VanillaLight::setColoredLightIntensity);
+        list.addBig(new OptionInstance<Integer>("sanctuary.shaders.colored_light_distance",OptionInstance.cachedConstantTooltip(
+                Component.translatable("sanctuary.shaders.colored_light_distance_help")),(caption,value)->Component.translatable("sanctuary.shaders.colored_light_distance_value",value),
+                new OptionInstance.Enum<>(List.of(8,16,32,64),Codec.INT),VanillaLight.coloredLightDistance(),VanillaLight::setColoredLightDistance));
        list.addBig(OptionInstance.createBoolean("sanctuary.shaders.ssgi",OptionInstance.cachedConstantTooltip(
                Component.translatable("sanctuary.shaders.ssgi_help")),VanillaLight.ssgi(),VanillaLight::setSsgi));
        slider("ssgi_intensity",VanillaLight.ssgiIntensity(),VanillaLight::setSsgiIntensity);
@@ -26,6 +26,10 @@ public final class VanillaLight {
        boolean pbr=true;
        int pbrIntensity=50;
        boolean ssgi=true;
+        boolean coloredLights=true;
+        boolean warmTorches=false;
+        int coloredLightIntensity=30;
+        int coloredLightDistance=16;
        int ssgiIntensity=35;
        int bloomIntensity=20;
        int bloomRadius=50;
@@ -46,6 +50,8 @@ public final class VanillaLight {
            preferences.sunshaftIntensity=Math.clamp(preferences.sunshaftIntensity,0,100);
            preferences.lensFlareIntensity=Math.clamp(preferences.lensFlareIntensity,0,100);
            preferences.pbrIntensity=Math.clamp(preferences.pbrIntensity,0,100);
+            preferences.coloredLightIntensity=Math.clamp(preferences.coloredLightIntensity,0,100);
+            preferences.coloredLightDistance=normalizeColoredLightDistance(preferences.coloredLightDistance);
            preferences.ssgiIntensity=Math.clamp(preferences.ssgiIntensity,0,100);
            preferences.bloomIntensity=Math.clamp(preferences.bloomIntensity,0,100);
            preferences.bloomRadius=Math.clamp(preferences.bloomRadius,0,100);
@@ -79,6 +85,15 @@ public final class VanillaLight {
    public static int pbrIntensity(){enabled();return preferences.pbrIntensity;}
    public static void setPbr(boolean value){enabled();preferences.pbr=value;save();}
    public static void setPbrIntensity(int value){enabled();preferences.pbrIntensity=Math.clamp(value,0,100);save();}
+    public static boolean warmTorches(){enabled();return preferences.warmTorches;}
+    public static void setWarmTorches(boolean value){enabled();preferences.warmTorches=value;save();}
+    public static boolean coloredLights(){enabled();return preferences.coloredLights;}
+    public static int coloredLightIntensity(){enabled();return preferences.coloredLightIntensity;}
+    public static void setColoredLights(boolean value){enabled();preferences.coloredLights=value;save();}
+    public static void setColoredLightIntensity(int value){enabled();preferences.coloredLightIntensity=Math.clamp(value,0,100);save();}
+    public static int coloredLightDistance(){enabled();return preferences.coloredLightDistance;}
+    public static void setColoredLightDistance(int value){enabled();preferences.coloredLightDistance=normalizeColoredLightDistance(value);save();}
+    static int normalizeColoredLightDistance(int value){return value<12?8:value<24?16:value<48?32:64;}
    public static boolean ssgi(){enabled();return preferences.ssgi;}
    public static int ssgiIntensity(){enabled();return preferences.ssgiIntensity;}
    public static void setSsgi(boolean value){enabled();preferences.ssgi=value;save();}
@@ -7,7 +7,8 @@ import java.util.function.LongConsumer;
 /** Immutable render snapshots; entity collection and the dirty queue belong to the client tick. */
 public final class DynamicLightField {
    public record Id(boolean drop, long value) {}
-    public record Source(Id id, double x, double y, double z, int light) {
+    public record Source(Id id, double x, double y, double z, int light, int color) {
+        public Source(Id id,double x,double y,double z,int light){this(id,x,y,z,light,0xFFFFFF);}
        public Source {
            if (!Double.isFinite(x+y+z) || light<1 || light>15) throw new IllegalArgumentException("light source");
        }
@@ -20,9 +21,12 @@ public final class DynamicLightField {
        private final int cellSize;
        public Collector(int cellSize) {this.cellSize=Math.max(1,cellSize);}
        public void add(long entity,boolean drop,double x,double y,double z,int light) {
+            add(entity,drop,x,y,z,light,0xFFFFFF);
+        }
+        public void add(long entity,boolean drop,double x,double y,double z,int light,int color) {
            if(light<=0)return;
            Id id=new Id(drop,drop ? sectionKey(floor(x/cellSize),floor(y/cellSize),floor(z/cellSize)) : entity);
-            Source candidate=new Source(id,snap(x),snap(y),snap(z),Math.min(15,light));
+            Source candidate=new Source(id,snap(x),snap(y),snap(z),Math.min(15,light),color);
            sources.merge(id,candidate,(a,b)->compareRepresentative(a,b)<=0?a:b);
        }
        public List<Source> finish(int limit,double x,double y,double z,long priorityEntity) {
@@ -53,6 +57,7 @@ public final class DynamicLightField {
            lists.long2ObjectEntrySet().forEach(e->bins.put(e.getLongKey(),e.getValue().toArray(Source[]::new)));
        }
        public int size() {return sources.size();}
+        public Collection<Source> sources(){return sources.values();}
        public int sectionCount() {return bins.size();}
        public int sampleCount(double x,double y,double z) {
            Source[] near=bins.get(sectionKey(floor(x)>>4,floor(y)>>4,floor(z)>>4));return near==null?0:near.length;
@@ -1,6 +1,7 @@
 package fr.koka.sanctuary.mixin.client;

 import fr.koka.sanctuary.client.shader.PixelShadows;
+import fr.koka.sanctuary.client.shader.ColoredLights;
 import fr.koka.sanctuary.client.shader.ProceduralPbr;
 import fr.koka.sanctuary.client.shader.Bloom;
 import fr.koka.sanctuary.client.shader.ScreenSpaceGI;
@@ -16,10 +17,10 @@ import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 abstract class PixelShadowDirtyMixin {
    @Inject(method="blockChanged", at=@At("HEAD"))
    private void sanctuary$dirty(BlockPos pos, int flags, CallbackInfo ci) {
-        PixelShadows.dirtyBlock(pos); ProceduralPbr.dirtyBlock(pos); Bloom.dirtyBlock(pos);
+        PixelShadows.dirtyBlock(pos); ProceduralPbr.dirtyBlock(pos); Bloom.dirtyBlock(pos); ColoredLights.dirtyBlock(pos);
    }
    @Inject(method="allChanged", at=@At("HEAD"))
-    private void sanctuary$reload(CallbackInfo ci) { PixelShadows.release(); ProceduralPbr.release(); Bloom.release(); ScreenSpaceGI.release(); }
+    private void sanctuary$reload(CallbackInfo ci) { PixelShadows.release(); ProceduralPbr.release(); Bloom.release(); ColoredLights.release(); ScreenSpaceGI.release(); }
    @Inject(method="setSectionDirty", at=@At("HEAD"))
-    private void sanctuary$pbrLight(int x,int y,int z,CallbackInfo ci){ProceduralPbr.dirtySection(x,y,z);}
+    private void sanctuary$pbrLight(int x,int y,int z,CallbackInfo ci){ProceduralPbr.dirtySection(x,y,z); ColoredLights.dirtySection(x,y,z);}
 }
@@ -1,6 +1,7 @@
 package fr.koka.sanctuary.mixin.client;

 import fr.koka.sanctuary.client.shader.PixelShadows;
+import fr.koka.sanctuary.client.shader.ColoredLights;
 import fr.koka.sanctuary.client.shader.ProceduralPbr;
 import fr.koka.sanctuary.client.shader.Bloom;
 import net.minecraft.client.multiplayer.ClientLevel;
@@ -17,11 +18,11 @@ import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 abstract class PixelShadowLevelMixin {
    @Inject(method="setBlocksDirty", at=@At("HEAD"))
    private void sanctuary$block(BlockPos pos, BlockState before, BlockState after, CallbackInfo ci) {
-        if (before != after) {PixelShadows.dirtyBlock(pos); ProceduralPbr.dirtyBlock(pos);Bloom.dirtyBlock(pos);}
+        if (before != after) {PixelShadows.dirtyBlock(pos); ProceduralPbr.dirtyBlock(pos);Bloom.dirtyBlock(pos); ColoredLights.dirtyBlock(pos);}
    }

    @Inject(method="onChunkLoaded", at=@At("TAIL"))
-    private void sanctuary$loaded(ChunkPos pos, CallbackInfo ci) { PixelShadows.dirtyChunk(pos.x(), pos.z()); ProceduralPbr.dirtyChunk(pos.x(), pos.z()); Bloom.dirtyChunk(pos.x(), pos.z()); }
+    private void sanctuary$loaded(ChunkPos pos, CallbackInfo ci) { PixelShadows.dirtyChunk(pos.x(), pos.z()); ProceduralPbr.dirtyChunk(pos.x(), pos.z()); Bloom.dirtyChunk(pos.x(), pos.z()); ColoredLights.dirtyChunk(pos.x(),pos.z()); }
    @Inject(method="unload", at=@At("HEAD"))
-    private void sanctuary$unload(LevelChunk chunk, CallbackInfo ci) { PixelShadows.dirtyChunk(chunk.getPos().x(), chunk.getPos().z()); ProceduralPbr.dirtyChunk(chunk.getPos().x(), chunk.getPos().z()); Bloom.dirtyChunk(chunk.getPos().x(), chunk.getPos().z()); }
+    private void sanctuary$unload(LevelChunk chunk, CallbackInfo ci) { PixelShadows.dirtyChunk(chunk.getPos().x(), chunk.getPos().z()); ProceduralPbr.dirtyChunk(chunk.getPos().x(), chunk.getPos().z()); Bloom.dirtyChunk(chunk.getPos().x(), chunk.getPos().z()); ColoredLights.dirtyChunk(chunk.getPos().x(),chunk.getPos().z()); }
 }
@@ -4,6 +4,7 @@ import com.llamalad7.mixinextras.injector.wrapoperation.Operation;
 import com.llamalad7.mixinextras.injector.wrapoperation.WrapOperation;
 import com.mojang.renderpearl.api.buffers.GpuBufferSlice;
 import fr.koka.sanctuary.client.shader.PixelShadows;
+import fr.koka.sanctuary.client.shader.ColoredLights;
 import fr.koka.sanctuary.client.shader.ProceduralPbr;
 import fr.koka.sanctuary.client.shader.EdgeHighlights;
 import fr.koka.sanctuary.client.shader.Bloom;
@@ -25,11 +26,12 @@ abstract class PixelShadowRendererMixin {
        ProceduralPbr.captureProjection(matrix);
        EdgeHighlights.captureProjection(matrix);
        Bloom.captureProjection(matrix);
+        ColoredLights.captureProjection(matrix);
        ScreenSpaceGI.captureProjection(matrix);
        return original.call(buffer, matrix);
    }
    @Inject(method="renderLevel", at=@At(value="INVOKE", target="Lnet/minecraft/client/renderer/GameRenderer;render3dHud(Lnet/minecraft/client/renderer/state/level/CameraRenderState;Lnet/minecraft/client/renderer/state/level/PlayerRenderState;Lnet/minecraft/client/renderer/state/OptionsRenderState;Z)V"))
-    private void sanctuary$shadows(CallbackInfo ci) { PixelShadows.render(); ProceduralPbr.render(); ScreenSpaceGI.render(); EdgeHighlights.render(); Bloom.render(); Sunshafts.render(); }
+    private void sanctuary$shadows(CallbackInfo ci) { ColoredLights.prepare(); PixelShadows.render(); ProceduralPbr.render(); ColoredLights.render(); ScreenSpaceGI.render(); EdgeHighlights.render(); Bloom.render(); Sunshafts.render(); }
    @Inject(method={"close", "setLevel"}, at=@At("HEAD"))
-    private void sanctuary$close(CallbackInfo ci) { PixelShadows.release(); ProceduralPbr.release(); EdgeHighlights.release(); Bloom.release(); ScreenSpaceGI.release(); Sunshafts.release(); }
+    private void sanctuary$close(CallbackInfo ci) { PixelShadows.release(); ProceduralPbr.release(); EdgeHighlights.release(); Bloom.release(); ColoredLights.release(); ScreenSpaceGI.release(); Sunshafts.release(); }
 }
@@ -2295,7 +2295,7 @@
  "sanctuary.shaders.ssgi_intensity_help": "Strength of diffuse color bounce. Zero stops rendering and frees its resources. Does not change world light.",
  "sanctuary.shaders.ssgi_intensity_value": "SSGI: %s%%",
  "sanctuary.shaders.pbr": "PBR · material relief",
-  "sanctuary.shaders.pbr_help": "Experimental: procedural block normals and roughness, sun and moon highlights. Range 32 blocks. ON by default.",
+  "sanctuary.shaders.pbr_help": "Experimental: procedural block normals and roughness, sun, moon and local light highlights. Enable Colored lights for local direction. Range 32 blocks. ON by default.",
  "sanctuary.shaders.pbr_intensity": "PBR strength",
  "sanctuary.shaders.pbr_intensity_help": "Material relief and highlights. Zero stops rendering and frees the cache. Original textures remain unchanged.",
  "sanctuary.shaders.pbr_intensity_value": "PBR: %s%%",
@@ -2308,5 +2308,15 @@
  "sanctuary.shaders.sunshafts_help": "Light beams through openings in the scenery. Independent of bloom; range follows shadows (up to 64 blocks).",
  "sanctuary.shaders.sunshaft_intensity": "Sunshaft intensity",
  "sanctuary.shaders.sunshaft_intensity_help": "Strength of light scattered in the air. Beams automatically thicken with fog and precipitation. Zero disables the effect.",
-  "sanctuary.shaders.sunshaft_intensity_value": "Sunshafts: %s %%"
+  "sanctuary.shaders.sunshaft_intensity_value": "Sunshafts: %s %%",
+  "sanctuary.shaders.colored_lights": "Colored lights",
+  "sanctuary.shaders.colored_lights_help": "Light-emitting blocks and carried items tint their surroundings, even off screen. Smooth appearance without changing gameplay light levels.",
+  "sanctuary.shaders.colored_light_intensity": "Colored light intensity",
+  "sanctuary.shaders.colored_light_intensity_value": "Colored lights: %s %%",
+  "sanctuary.shaders.colored_light_intensity_help": "Enabled at 30% by default. Zero disables computation. Changes fade in smoothly.",
+  "sanctuary.shaders.colored_light_distance": "Colored light distance",
+  "sanctuary.shaders.colored_light_distance_value": "Colored lights: %s blocks",
+  "sanctuary.shaders.colored_light_distance_help": "View distance: 8 to 64 blocks. Longer distances use more memory and computation. Smooth range fade; each source keeps its native reach.",
+  "sanctuary.shaders.warm_torches": "Warm torches",
+  "sanctuary.shaders.warm_torches_help": "Off: ordinary torches keep the native color temperature. On: orange tint. Other sources retain their own colors."
 }
@@ -2295,7 +2295,7 @@
  "sanctuary.shaders.ssgi_intensity_help": "Force de la teinte diffusée. Zéro coupe le calcul et libère ses ressources. Aucun changement de lumière du monde.",
  "sanctuary.shaders.ssgi_intensity_value": "SSGI : %s %%",
  "sanctuary.shaders.pbr": "PBR · relief des matériaux",
-  "sanctuary.shaders.pbr_help": "Expérimental : normales procédurales et rugosité des blocs, reflets du soleil et de la lune. Portée 32 blocs. Activé par défaut.",
+  "sanctuary.shaders.pbr_help": "Expérimental : normales procédurales et rugosité des blocs, reflets du soleil, de la lune et des lumières locales. Activer Lumières colorées pour la direction locale. Portée 32 blocs. Activé par défaut.",
  "sanctuary.shaders.pbr_intensity": "Intensité du PBR",
  "sanctuary.shaders.pbr_intensity_help": "Relief et reflets des matériaux. Zéro coupe le calcul et libère le cache. Ne modifie pas les textures originales.",
  "sanctuary.shaders.pbr_intensity_value": "PBR : %s %%",
@@ -2308,5 +2308,15 @@
  "sanctuary.shaders.sunshafts_help": "Faisceaux de lumière dans les ouvertures du décor. Indépendants du bloom, portée liée aux ombres (64 blocs maximum).",
  "sanctuary.shaders.sunshaft_intensity": "Intensité des rayons",
  "sanctuary.shaders.sunshaft_intensity_help": "Force de la lumière dans l’air. Les rayons s’épaississent automatiquement avec le brouillard et les précipitations. Zéro désactive le calcul.",
-  "sanctuary.shaders.sunshaft_intensity_value": "Rayons : %s %%"
+  "sanctuary.shaders.sunshaft_intensity_value": "Rayons : %s %%",
+  "sanctuary.shaders.colored_lights": "Lumières colorées",
+  "sanctuary.shaders.colored_lights_help": "Les blocs lumineux et les objets portés teintent leurs environs, même hors écran. Apparition progressive, sans changer les règles de lumière du jeu.",
+  "sanctuary.shaders.colored_light_intensity": "Intensité des lumières colorées",
+  "sanctuary.shaders.colored_light_intensity_value": "Lumières colorées : %s %%",
+  "sanctuary.shaders.colored_light_intensity_help": "Activé par défaut à 30 %. Zéro désactive le calcul. Les changements apparaissent progressivement.",
+  "sanctuary.shaders.colored_light_distance": "Distance des lumières colorées",
+  "sanctuary.shaders.colored_light_distance_value": "Lumières colorées : %s blocs",
+  "sanctuary.shaders.colored_light_distance_help": "Distance d'affichage : 8 à 64 blocs. Les grandes distances utilisent plus de mémoire et de calcul. Fondu aux limites ; la portée de chaque source reste native.",
+  "sanctuary.shaders.warm_torches": "Torches chaudes",
+  "sanctuary.shaders.warm_torches_help": "Désactivé : les torches ordinaires conservent la température de couleur native. Activé : teinte orangée. Les autres sources gardent leurs propres couleurs."
 }
@@ -0,0 +1,91 @@
+#version 330
+#extension GL_ARB_separate_shader_objects : require
+uniform sampler2D WorldDepth;
+uniform sampler2D SceneColor;
+uniform sampler2D LightVolume;
+uniform sampler2D PreviousVolume;
+layout(std140) uniform ColoredLightScene {
+    mat4 InverseViewProjection;
+    vec4 CameraStrength;
+    vec4 ClipSkyFog;
+    vec4 FogDistance;
+    vec4 VolumeSize;
+    vec4 Atlas;
+    vec4 PreviousCamera;
+    vec4 PreviousAtlas;
+    vec4 DynamicPosition[128];
+    vec4 DynamicColor[128];
+};
+layout(location=0) in vec2 texCoord;
+layout(location=0) out vec4 fragColor;
+vec3 positionAt(vec2 uv,float depth){
+    vec4 p=InverseViewProjection*vec4(uv*2.0-1.0,ClipSkyFog.x>.5?depth:depth*2.0-1.0,1);
+    return p.xyz/p.w;
+}
+vec3 neighbor(vec2 uv,vec3 center){float d=texture(WorldDepth,uv).r;return d>0.0?positionAt(uv,d):center;}
+vec3 normalAt(vec3 p){
+    vec2 pixel=1.0/vec2(textureSize(WorldDepth,0));
+    vec3 l=p-neighbor(texCoord-vec2(pixel.x,0),p),r=neighbor(texCoord+vec2(pixel.x,0),p)-p;
+    vec3 d=p-neighbor(texCoord-vec2(0,pixel.y),p),u=neighbor(texCoord+vec2(0,pixel.y),p)-p;
+    vec3 dx=dot(l,l)>0.0&&(dot(l,l)<dot(r,r)||dot(r,r)==0.0)?l:r;
+    vec3 dy=dot(d,d)>0.0&&(dot(d,d)<dot(u,u)||dot(u,u)==0.0)?d:u;
+    float xx=dot(dx,dx),yy=dot(dy,dy);if(xx<1e-20||yy<1e-20)return vec3(0);
+    vec3 n=cross(dx*inversesqrt(xx),dy*inversesqrt(yy));float nn=dot(n,n);if(nn<1e-12)return vec3(0);
+    n*=inversesqrt(nn);return dot(n,-p)<0.0?-n:n;
+}
+vec4 cell(sampler2D volume,ivec3 p,vec4 atlas){
+    int side=int(atlas.x),cols=int(atlas.y);
+    p=clamp(p,ivec3(0),ivec3(side-1));
+    vec4 v=texelFetch(volume,ivec2(p.x+(p.y%cols)*side,p.z+(p.y/cols)*side),0);
+    vec3 spectrum=pow(vec3(.8),vec3(31)-v.rgb*(255.0/8.0))*step(vec3(.5/255.0),v.rgb);
+    float peak=max(spectrum.r,max(spectrum.g,spectrum.b));
+    float energy=max(0.0,(peak-pow(.8,15.0))/(1.0-pow(.8,15.0)));
+    v.rgb=spectrum*(energy/max(peak,1e-12));
+    return v;
+}
+vec4 field(sampler2D volume,vec3 p,vec4 atlas){
+    vec3 edges=min(p,vec3(atlas.x)-p);
+    float margin=smoothstep(14.0,18.0,min(edges.x,min(edges.y,edges.z)));if(margin<=0.0)return vec4(0);
+    vec3 at=p-.5;ivec3 base=ivec3(floor(at));vec3 f=fract(at);vec4 result=vec4(0);
+    for(int y=0;y<2;y++)for(int z=0;z<2;z++)for(int x=0;x<2;x++){
+        float w=(x==0?1.0-f.x:f.x)*(y==0?1.0-f.y:f.y)*(z==0?1.0-f.z:f.z);
+        result+=cell(volume,base+ivec3(x,y,z),atlas)*w;
+    }
+    result.rgb*=margin;return result;
+}
+vec3 tintGain(vec4 light,float amount){
+    float energy=max(light.r,max(light.g,light.b));if(energy<1e-12)return vec3(1);
+    vec3 tint=clamp(light.rgb/max(dot(light.rgb,vec3(.2126,.7152,.0722)),1e-12),vec3(.02),vec3(3));
+    // Linear close to darkness: no fourth-root halo at the edge of a light pool.
+    float response=energy/(energy+.08);
+    return pow(tint,vec3(clamp(amount*response*(1.0-.8*light.a*ClipSkyFog.y),0.0,.95)));
+}
+void main(){
+    vec3 scene=texture(SceneColor,texCoord).rgb;fragColor=vec4(scene,0);
+    float depth=texture(WorldDepth,texCoord).r;if(depth<=0.0)return;
+    vec3 p=positionAt(texCoord,depth),n=normalAt(p);if(dot(n,n)<.5)return;
+    vec3 a=abs(n);float axis=max(a.x,max(a.y,a.z));
+    // Sample outside opaque block faces. Bilinear atlas filtering would leak
+    // across unrelated slices, so the eight neighbours are explicitly addressed.
+    vec3 offset=n*(axis>.995?.51:.06);
+    float border=1.0-smoothstep(VolumeSize.x*.75,VolumeSize.x,length(p));if(border<=0.0)return;
+    vec4 light=field(LightVolume,p+CameraStrength.xyz+offset,Atlas);
+    vec4 before=VolumeSize.y<1.0&&PreviousCamera.w>.5?field(PreviousVolume,p+PreviousCamera.xyz+offset,PreviousAtlas):vec4(0);
+    vec3 dynamic=vec3(0);
+    for(int i=0;i<int(VolumeSize.w);i++){
+        vec3 delta=p-DynamicPosition[i].xyz;float square=dot(delta,delta),radius=DynamicPosition[i].w;
+        if(square>=radius*radius)continue;
+        float remaining=radius-sqrt(square);
+        float power=max(0.0,(pow(.8,15.0-remaining)-pow(.8,15.0))/(1.0-pow(.8,15.0)));
+        float response=power/(power+.08)*smoothstep(0.0,1.0,DynamicColor[i].a);
+        float fadedPower=.08*response/max(1e-6,1.0-response);
+        dynamic=max(dynamic,DynamicColor[i].rgb*fadedPower);
+    }
+    light.rgb=max(light.rgb,dynamic);before.rgb=max(before.rgb,dynamic);
+    float fog=max(clamp((max(length(p.xz),abs(p.y))-FogDistance.x)/max(.001,FogDistance.y-FogDistance.x),0,1),clamp((length(p)-FogDistance.z)/max(.001,FogDistance.w-FogDistance.z),0,1));
+    float amount=CameraStrength.w*1.35*border*(1.0-fog*ClipSkyFog.z)*smoothstep(0.0,1.0,VolumeSize.z);
+    vec3 gain=tintGain(light,amount);
+    // Fade the rendered response, preserving colour and avoiding a bright first frame.
+    if(VolumeSize.y<1.0)gain=mix(tintGain(before,amount),gain,smoothstep(0.0,1.0,VolumeSize.y));
+    fragColor=vec4(scene*gain,0);
+}
@@ -5,6 +5,20 @@ uniform sampler2D SceneColor;
 uniform sampler2D BlockAtlas;
 uniform sampler2D MaterialAtlas;
 uniform sampler2D SunDepth;
+uniform sampler2D LightDirection;
+uniform sampler2D PreviousDirection;
+layout(std140) uniform ColoredLightScene {
+    mat4 LocalInverseViewProjection;
+    vec4 CameraStrength;
+    vec4 ClipSkyFog;
+    vec4 FogDistance;
+    vec4 VolumeSize;
+    vec4 Atlas;
+    vec4 PreviousCamera;
+    vec4 PreviousAtlas;
+    vec4 DynamicPosition[128];
+    vec4 DynamicColor[128];
+};
 layout(std140) uniform PbrScene {
    mat4 PbrInverseVP;
    vec4 PbrSun;
@@ -36,6 +50,52 @@ float visibility(vec3 p,vec3 n){
    if(any(lessThan(q,vec3(0)))||any(greaterThan(q,vec3(1))))return 1.0;
    return q.z>texture(SunDepth,q.xy).r+0.00015?0.0:1.0;
 }
+// Cached direction moments; filtering moments before normalization avoids unstable
+// switches between nearby/opposed sources. Alpha stores the light response.
+vec4 directionField(sampler2D field,vec3 p,vec4 atlas){
+    if(textureSize(field,0).x<int(atlas.z))return vec4(0);
+    vec3 edges=min(p,vec3(atlas.x)-p);float margin=smoothstep(14.0,18.0,min(edges.x,min(edges.y,edges.z)));
+    if(margin<=0.0)return vec4(0);
+    int side=int(atlas.x),cols=int(atlas.y);vec3 at=p-.5;ivec3 base=ivec3(floor(at));vec3 f=fract(at);vec4 sum=vec4(0);
+    for(int y=0;y<2;y++)for(int z=0;z<2;z++)for(int x=0;x<2;x++){
+        ivec3 q=clamp(base+ivec3(x,y,z),ivec3(0),ivec3(side-1));
+        vec4 cell=texelFetch(field,ivec2(q.x+(q.y%cols)*side,q.z+(q.y/cols)*side),0);
+        float w=(x==0?1.0-f.x:f.x)*(y==0?1.0-f.y:f.y)*(z==0?1.0-f.z:f.z);
+        sum+=vec4((cell.rgb*255.0-128.0)/127.0*cell.a,cell.a)*w;
+    }
+    return sum*margin;
+}
+vec4 localArrival(vec3 p,vec3 normal){
+    if(PbrEnvironment.y<.5)return vec4(0);
+    vec3 offset=normal*.51;
+    vec4 field=directionField(LightDirection,p+CameraStrength.xyz+offset,Atlas);
+    if(VolumeSize.y<1.0){
+        vec4 before=PreviousCamera.w>.5?directionField(PreviousDirection,p+PreviousCamera.xyz+offset,PreviousAtlas):vec4(0);
+        field=mix(before,field,smoothstep(0.0,1.0,VolumeSize.y));
+    }
+    for(int i=0;i<int(VolumeSize.w);i++){
+        vec3 delta=DynamicPosition[i].xyz-p;float distance=length(delta),radius=DynamicPosition[i].w;
+        if(distance>=radius||distance<.001)continue;
+        float power=max(0.0,(pow(.8,15.0-radius+distance)-pow(.8,15.0))/(1.0-pow(.8,15.0)));
+        float weight=power/(power+.08)*smoothstep(0.0,1.0,DynamicColor[i].a);
+        field+=vec4(delta/distance*weight,weight);
+    }
+    float magnitude=length(field.xyz);if(magnitude<.00001||field.a<.00001)return vec4(0);
+    float confidence=smoothstep(.02,1.0,magnitude/field.a);
+    float fade=(1.0-smoothstep(VolumeSize.x*.75,VolumeSize.x,length(p)))*smoothstep(0.0,1.0,VolumeSize.z);
+    return vec4(field.xyz/magnitude,confidence*min(field.a,1.0)*fade*clamp(CameraStrength.w/0.3,0.0,1.0));
+}
+vec3 localShine(vec3 n,vec3 v,vec3 l,vec4 material,vec3 albedo){
+    vec3 halfVector=l+v;float size=dot(halfVector,halfVector);if(size<.00001)return vec3(0);
+    vec3 h=halfVector*inversesqrt(size);
+    float nl=max(dot(n,l),0.0),nv=max(dot(n,v),.001),nh=max(dot(n,h),0.0),vh=max(dot(v,h),0.0);
+    float roughness=max(material.b,.25),alpha=roughness*roughness,a2=alpha*alpha;
+    float denom=nh*nh*(a2-1.0)+1.0,distribution=a2/max(3.14159265*denom*denom,.00001);
+    float k=(roughness+1.0)*(roughness+1.0)/8.0;
+    float geometry=nv/(nv*(1.0-k)+k)*nl/max(nl*(1.0-k)+k,.00001);
+    vec3 f0=mix(vec3(.04),albedo,material.a),fresnel=f0+(1.0-f0)*pow(1.0-vh,5.0);
+    return distribution*geometry*fresnel/max(4.0*nv*nl,.0001)*nl;
+}
 void main(){
    // Derivatives precede divergent discard; UV-space tangents preserve rotated/mirrored block textures.
    vec3 dx=dFdx(relativePosition),dy=dFdy(relativePosition);
@@ -67,12 +127,18 @@ void main(){
                  clamp((length(relativePosition)-PbrFog.z)/max(PbrFog.w-PbrFog.z,.001),0.0,1.0));
    float amount=PbrSun.w*pow(tint.a,8.0)*visibility(relativePosition,baseNormal)*(1.0-fog*PbrEnvironment.x)
                 *(1.0-smoothstep(PbrParams.w*.75,PbrParams.w,length(relativePosition)));
-    if(amount<=0.0001)discard;
+    vec4 arrival=localArrival(relativePosition,baseNormal);
+    float localAmount=arrival.w*(1.0-fog*PbrEnvironment.x)*(1.0-smoothstep(PbrParams.w*.75,PbrParams.w,length(relativePosition)));
+    if(amount<=0.0001&&localAmount<=0.0001)discard;
    vec3 scene=texture(SceneColor,uv).rgb;vec3 linear=scene*scene;
    // Native diffuse light already exists. Apply only the perturbed-normal difference, then add GGX.
    float relief=(nl-max(dot(baseNormal,l),0.0))*.7;
    vec3 lit=clamp(linear*(1.0+relief*amount),0.0,1.0);
-    vec3 shine=min(specular*PbrParams.x*amount*3.0,vec3(0.5));
+    if(localAmount>.0001){
+        float localRelief=(max(dot(n,arrival.xyz),0.0)-max(dot(baseNormal,arrival.xyz),0.0))*.7;
+        lit=clamp(lit*(1.0+localRelief*localAmount),0.0,1.0);
+    }
+    vec3 shine=min((specular*amount+localShine(n,v,arrival.xyz,material,albedo)*localAmount)*PbrParams.x*3.0,vec3(0.5));
    lit+=(1.0-lit)*(1.0-exp(-shine));
    fragColor=vec4(sqrt(clamp(lit,0.0,1.0)),1.0);
 }
@@ -52,6 +52,13 @@ public final class Dynamic030Smoke {
            for(var light:lights)expected=Math.max(expected,(int)Math.max(0,(light.light()-Math.sqrt(light.distanceSquared(x,y,z)))*16));
            require(indexed.apply(nativeSky,x,y,z)==(nativeSky|expected),"Indexed samples agree with brute-force oracle");
        }
+        var colored=new DynamicLightField.Collector(4);colored.add(42,false,2,3,4,10,0x55BDFF);
+        var blue=colored.finish(32,0,0,0,42);var blueField=new DynamicLightField.Snapshot(blue);
+        require(blueField.sources().iterator().next().color()==0x55BDFF,"Snapshot retains source colour");
+        require((blueField.apply(nativeSky,2,3,4)&255)==160,"RGB metadata preserves native intensity");
+        var changed=new DynamicLightField.Collector(4);changed.add(42,false,2,3,4,10,0x62FFA0);
+        field.update(blue);require(field.update(changed.finish(32,0,0,0,42)),"Same intensity can change colour");
+        require(blueField.sources().iterator().next().color()==0x55BDFF,"Older coloured snapshot remains immutable");
        long begin=System.nanoTime();long sum=0;
        for(int i=0;i<1000000;i++)sum+=stress.apply(0,i%80,2,(i/80)%80);
        System.out.printf("LIGHT-01 passed: 10,000-drop clustering, 100,000 oracle samples; 1M cached queries %.1f ms (checksum %d)%n",(System.nanoTime()-begin)/1e6,sum);
@@ -1,6 +1,6 @@
 name = "Sanctuary"
 author = "KOKA99CAB"
-version = "beta.138"
+version = "beta.141"
 pack-format = "packwiz:1.1.0"

 [index]
Author	SHA1	Message	Date
koka	93ed5574a4	Drive PBR normals with cached local light directions in beta.141 Build Sanctuary / build (push) Canceled after 0s Details	2026-09-18 04:11:03 +02:00
koka	c9f5c56e68	Document verified beta.140 publication and Prism synchronization Build Sanctuary / build (push) Canceled after 0s Details	2026-09-18 03:15:07 +02:00
koka	6e1b3b7108	Add colored dynamic lights and smooth hue-preserving fades for beta.140 Build Sanctuary / build (push) Canceled after 0s Details	2026-09-18 03:13:43 +02:00
koka	c05c338e6b	Record beta.139 release and preserved Prism state Build Sanctuary / build (push) Canceled after 0s Details	2026-09-18 02:27:19 +02:00
koka	dc33ffa546	Add optional local colored lights for beta.139 Build Sanctuary / build (push) Canceled after 0s Details	2026-09-18 02:25:48 +02:00