Initial sanctuary sources

2026-07-04 20:27:08 +02:00
commit c796a20321
1582 changed files with 253264 additions and 0 deletions
@@ -0,0 +1,99 @@
+package fr.koka99cab.ambiance.client;
+
+import net.fabricmc.fabric.api.client.rendering.v1.ColorResolverRegistry;
+import net.minecraft.client.color.block.BlockTintSource;
+import net.minecraft.client.renderer.block.BlockAndTintGetter;
+import net.minecraft.core.BlockPos;
+import net.minecraft.world.level.ColorResolver;
+import net.minecraft.world.level.biome.Biome;
+import net.minecraft.world.level.block.state.BlockState;
+
+public final class AmbianceBiomeTints {
+	private static final int BIRCH_LEAVES_COLOR = 0xFFB7FF36;
+	private static final int DEFAULT_GRASS_COLOR = 0xFF91BD59;
+	private static final int DEFAULT_FOLIAGE_COLOR = 0xFF48B518;
+	private static final int DEFAULT_WATER_COLOR = 0xFF3F76E4;
+	private static final int DEFAULT_LILY_PAD_COLOR = 0xFF208030;
+	private static final int SWAMP_LUSH_GRASS_COLOR = 0xFF8F7FCF;
+	private static final int SWAMP_MURKY_GRASS_COLOR = 0xFF68609D;
+	private static final int SWAMP_FOLIAGE_COLOR = 0xFF716EA6;
+	private static final int SWAMP_WATER_COLOR = 0xFF4C47B8;
+	private static final int SWAMP_WATER = 0x617B64;
+	private static final int MANGROVE_SWAMP_WATER = 0x3A7A6A;
+	private static final int VANILLA_SWAMP_LUSH_GRASS = 0x4C763C;
+	private static final int VANILLA_SWAMP_MURKY_GRASS = 0x6A7039;
+	private static final double SWAMP_NOISE_SCALE = 0.0225D;
+	private static final double SWAMP_LUSH_THRESHOLD = -0.1D;
+
+	static final ColorResolver SWAMP_GRASS_RESOLVER = (biome, x, z) -> isSwamp(biome, x, z) ? swampGrassColor(x, z) : biome.getGrassColor(x, z);
+	static final ColorResolver SWAMP_FOLIAGE_RESOLVER = (biome, x, z) -> isSwamp(biome, x, z) ? SWAMP_FOLIAGE_COLOR : biome.getFoliageColor();
+	static final ColorResolver SWAMP_WATER_RESOLVER = (biome, x, z) -> isSwamp(biome, x, z) ? SWAMP_WATER_COLOR : biome.getWaterColor();
+	static final ColorResolver SWAMP_LILY_PAD_RESOLVER = (biome, x, z) -> isSwamp(biome, x, z) ? SWAMP_FOLIAGE_COLOR : DEFAULT_LILY_PAD_COLOR;
+	static final ColorResolver SWAMP_MASK_RESOLVER = (biome, x, z) -> isSwamp(biome, x, z) ? 0xFFFFFFFF : 0xFF000000;
+
+	public static final BlockTintSource BIRCH_LEAVES = constant(BIRCH_LEAVES_COLOR);
+	public static final BlockTintSource GRASS = biomeTint(DEFAULT_GRASS_COLOR, SWAMP_GRASS_RESOLVER);
+	public static final BlockTintSource FOLIAGE = biomeTint(DEFAULT_FOLIAGE_COLOR, SWAMP_FOLIAGE_RESOLVER);
+	public static final BlockTintSource WATER = biomeTint(DEFAULT_WATER_COLOR, SWAMP_WATER_RESOLVER);
+	public static final BlockTintSource LILY_PAD = biomeTint(DEFAULT_LILY_PAD_COLOR, SWAMP_LILY_PAD_RESOLVER);
+
+	private AmbianceBiomeTints() {
+	}
+
+	public static void registerColorResolvers() {
+		registerColorResolver(SWAMP_GRASS_RESOLVER);
+		registerColorResolver(SWAMP_FOLIAGE_RESOLVER);
+		registerColorResolver(SWAMP_WATER_RESOLVER);
+		registerColorResolver(SWAMP_LILY_PAD_RESOLVER);
+		registerColorResolver(SWAMP_MASK_RESOLVER);
+	}
+
+	private static BlockTintSource constant(int color) {
+		return new BlockTintSource() {
+			@Override
+			public int color(BlockState state) {
+				return color;
+			}
+		};
+	}
+
+	private static BlockTintSource biomeTint(int fallbackColor, ColorResolver resolver) {
+		return new BlockTintSource() {
+			@Override
+			public int color(BlockState state) {
+				return fallbackColor;
+			}
+
+			@Override
+			public int colorInWorld(BlockState state, BlockAndTintGetter level, BlockPos pos) {
+				return level.getBlockTint(pos, resolver);
+			}
+		};
+	}
+
+	private static void registerColorResolver(ColorResolver resolver) {
+		if (!ColorResolverRegistry.isRegistered(resolver)) {
+			ColorResolverRegistry.register(resolver);
+		}
+	}
+
+	private static boolean isSwamp(Biome biome, double x, double z) {
+		int waterColor = biome.getWaterColor() & 0xFFFFFF;
+		if (waterColor == MANGROVE_SWAMP_WATER) {
+			return false;
+		}
+
+		return waterColor == SWAMP_WATER || isVanillaSwampGrassColor(biome.getGrassColor(x, z));
+	}
+
+	private static boolean isVanillaSwampGrassColor(int color) {
+		int rgb = color & 0xFFFFFF;
+		return rgb == VANILLA_SWAMP_LUSH_GRASS || rgb == VANILLA_SWAMP_MURKY_GRASS;
+	}
+
+	@SuppressWarnings("removal")
+	private static int swampGrassColor(double x, double z) {
+		double swampNoise = Biome.BIOME_INFO_NOISE.getValue(x * SWAMP_NOISE_SCALE, z * SWAMP_NOISE_SCALE, false);
+		return swampNoise < SWAMP_LUSH_THRESHOLD ? SWAMP_LUSH_GRASS_COLOR : SWAMP_MURKY_GRASS_COLOR;
+	}
+}
@@ -0,0 +1,58 @@
+package fr.koka99cab.ambiance.client;
+
+import fr.koka99cab.ambiance.AmbianceMod;
+import net.fabricmc.api.ClientModInitializer;
+import net.fabricmc.fabric.api.client.render.fluid.v1.FluidRenderingRegistry;
+import net.fabricmc.fabric.api.client.rendering.v1.BlockColorRegistry;
+import net.minecraft.client.renderer.block.FluidModel;
+import net.minecraft.client.resources.model.sprite.Material;
+import net.minecraft.resources.Identifier;
+import net.minecraft.world.level.block.Blocks;
+import net.minecraft.world.level.material.Fluids;
+
+import java.util.List;
+
+public class AmbianceClient implements ClientModInitializer {
+	@Override
+	public void onInitializeClient() {
+		AmbianceBiomeTints.registerColorResolvers();
+		registerWaterFluidTint();
+		BlockColorRegistry.register(List.of(AmbianceBiomeTints.GRASS),
+				Blocks.GRASS_BLOCK,
+				Blocks.SHORT_GRASS,
+				Blocks.FERN,
+				Blocks.POTTED_FERN,
+				Blocks.BUSH,
+				Blocks.TALL_GRASS,
+				Blocks.LARGE_FERN,
+				Blocks.SUGAR_CANE
+		);
+		BlockColorRegistry.register(List.of(AmbianceBiomeTints.FOLIAGE),
+				Blocks.OAK_LEAVES,
+				Blocks.JUNGLE_LEAVES,
+				Blocks.ACACIA_LEAVES,
+				Blocks.DARK_OAK_LEAVES,
+				Blocks.PALE_OAK_LEAVES,
+				Blocks.MANGROVE_LEAVES,
+				Blocks.VINE
+		);
+		BlockColorRegistry.register(List.of(AmbianceBiomeTints.WATER),
+				Blocks.WATER,
+				Blocks.BUBBLE_COLUMN,
+				Blocks.WATER_CAULDRON
+		);
+		BlockColorRegistry.register(List.of(AmbianceBiomeTints.LILY_PAD), Blocks.LILY_PAD);
+		BlockColorRegistry.register(List.of(AmbianceBiomeTints.BIRCH_LEAVES), Blocks.BIRCH_LEAVES);
+		AmbianceMod.LOGGER.info("Ambiance client initialise.");
+	}
+
+	private static void registerWaterFluidTint() {
+		FluidModel.Unbaked waterModel = new FluidModel.Unbaked(
+				new Material(Identifier.withDefaultNamespace("block/water_still")),
+				new Material(Identifier.withDefaultNamespace("block/water_flow")),
+				new Material(Identifier.withDefaultNamespace("block/water_overlay")),
+				AmbianceBiomeTints.WATER
+		);
+		FluidRenderingRegistry.register(Fluids.WATER, Fluids.FLOWING_WATER, waterModel);
+	}
+}
@@ -0,0 +1,176 @@
+package fr.koka99cab.ambiance.client;
+
+import net.minecraft.client.Camera;
+import net.minecraft.client.DeltaTracker;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.multiplayer.ClientLevel;
+import net.minecraft.client.renderer.fog.FogData;
+import net.minecraft.client.renderer.state.LightmapRenderState;
+import net.minecraft.core.BlockPos;
+import net.minecraft.util.ARGB;
+import net.minecraft.util.Mth;
+import net.minecraft.world.attribute.EnvironmentAttributes;
+import net.minecraft.world.level.material.FogType;
+import org.joml.Vector3f;
+import org.joml.Vector3fc;
+import org.joml.Vector4f;
+
+public final class AmbianceEffects {
+	private static final float FULL_CIRCLE = (float) (Math.PI * 2.0);
+	private static final float DAY_LENGTH = 24000.0F;
+	private static final float DAY_FOG_INTENSITY = 1.5F;
+	private static final float NIGHT_FOG_INTENSITY = 2.0F;
+	private static final float MIN_CLOUD_HEIGHT = 288.0F;
+	private static final int SWAMP_FOG_SAMPLE_STEP = 24;
+	private static final int SWAMP_FOG_SAMPLE_RADIUS = 2;
+
+	private AmbianceEffects() {
+	}
+
+	public static void adjustFog(FogData fogData, Camera camera, int viewDistance, DeltaTracker deltaTracker, ClientLevel level) {
+		if (fogData == null || camera.getFluidInCamera() != FogType.NONE) {
+			return;
+		}
+
+		float tickDelta = deltaTracker.getGameTimeDeltaPartialTick(false);
+		float renderDistance = Math.max(32.0F, viewDistance * 16.0F);
+		float night = nightFactor(level, tickDelta);
+		float rain = level.getRainLevel(tickDelta);
+		float thunder = level.getThunderLevel(tickDelta);
+		float weather = Mth.clamp(rain * 0.35F + thunder * 0.45F, 0.0F, 0.65F);
+		float pressure = Math.max(night * 0.25F, weather);
+		float fogIntensity = Mth.lerp(night, DAY_FOG_INTENSITY, NIGHT_FOG_INTENSITY);
+
+		float fogStart = renderDistance * Mth.lerp(weather, 0.25F, 0.12F) / fogIntensity;
+		float fogEnd = renderDistance * Mth.lerp(pressure, 0.96F, 0.72F) / fogIntensity;
+		fogEnd = Math.max(fogStart + 16.0F, fogEnd);
+
+		fogData.environmentalStart = fogStart;
+		fogData.environmentalEnd = fogEnd;
+		fogData.renderDistanceStart = fogStart;
+		fogData.renderDistanceEnd = Math.max(fogEnd, renderDistance / fogIntensity);
+		fogData.skyEnd = Math.min(fogData.skyEnd, renderDistance * Mth.lerp(night, 0.82F, 0.65F) / fogIntensity);
+		fogData.cloudEnd = Math.min(fogData.cloudEnd, renderDistance * 0.78F / fogIntensity);
+
+		Vector4f color = fogData.color;
+		keepFogColorInVoid(color, camera, level, tickDelta);
+		float dim = Mth.clamp(1.0F - night * 0.48F - weather * 0.22F, 0.38F, 1.0F);
+		float saturation = 1.18F + night * 0.10F;
+		setAdjustedColor(color, saturation, dim);
+		float swamp = swampFogInfluence(level, camera.blockPosition());
+		if (swamp > 0.01F) {
+			float purple = swamp * Mth.clamp(0.34F + weather * 0.14F + night * 0.06F, 0.0F, 0.54F);
+			color.set(
+					Mth.lerp(purple, color.x(), 0.56F),
+					Mth.lerp(purple, color.y(), 0.35F),
+					Mth.lerp(purple, color.z(), 0.76F),
+					color.w()
+			);
+		}
+	}
+
+	public static void adjustLightmap(LightmapRenderState state, float tickDelta) {
+		Minecraft minecraft = Minecraft.getInstance();
+		ClientLevel level = minecraft.level;
+		if (level == null || minecraft.player == null || !state.needsUpdate) {
+			return;
+		}
+
+		float nightVision = Mth.clamp(state.nightVisionEffectIntensity, 0.0F, 1.0F);
+		float night = nightFactor(level, tickDelta) * (1.0F - nightVision * 0.85F);
+		float rain = level.getRainLevel(tickDelta);
+		float thunder = level.getThunderLevel(tickDelta);
+		float weather = Mth.clamp(rain * 0.22F + thunder * 0.32F, 0.0F, 0.5F);
+		float skyDimming = Mth.clamp(1.0F - night * 0.72F - weather, 0.16F, 1.0F);
+
+		state.skyFactor *= skyDimming;
+		state.ambientColor = adjustedColor(state.ambientColor, 1.14F, Mth.clamp(1.0F - night * 0.58F - weather * 0.18F, 0.24F, 1.0F));
+		state.skyLightColor = adjustedColor(state.skyLightColor, 1.12F, Mth.clamp(1.0F - night * 0.36F - weather * 0.12F, 0.42F, 1.0F));
+		state.blockLightTint = warmBlockLight(state.blockLightTint, night);
+		state.blockFactor *= Mth.lerp(night, 1.0F, 1.08F);
+		state.brightness = Math.min(state.brightness, Mth.lerp(night, 0.58F, 0.14F));
+	}
+
+	public static float adjustCloudHeight(float cloudHeight) {
+		return Math.max(cloudHeight, MIN_CLOUD_HEIGHT);
+	}
+
+	private static float nightFactor(ClientLevel level, float tickDelta) {
+		if (!level.dimensionType().hasSkyLight() || level.dimensionType().hasFixedTime()) {
+			return 0.0F;
+		}
+
+		float dayTime = (Math.floorMod(level.getDefaultClockTime(), 24000L) + tickDelta) / DAY_LENGTH;
+		float midnightWave = (float) Math.cos((dayTime - 0.75F) * FULL_CIRCLE);
+		return Mth.clamp((midnightWave - 0.02F) / 0.98F, 0.0F, 1.0F);
+	}
+
+	private static float swampFogInfluence(ClientLevel level, BlockPos center) {
+		float total = 0.0F;
+		float weightTotal = 0.0F;
+		for (int x = -SWAMP_FOG_SAMPLE_RADIUS; x <= SWAMP_FOG_SAMPLE_RADIUS; x++) {
+			for (int z = -SWAMP_FOG_SAMPLE_RADIUS; z <= SWAMP_FOG_SAMPLE_RADIUS; z++) {
+				int distance = Math.abs(x) + Math.abs(z);
+				float weight = distance == 0 ? 4.0F : 1.0F / distance;
+				BlockPos sample = center.offset(x * SWAMP_FOG_SAMPLE_STEP, 0, z * SWAMP_FOG_SAMPLE_STEP);
+				int mask = level.getBlockTint(sample, AmbianceBiomeTints.SWAMP_MASK_RESOLVER);
+				total += ((mask >> 16) & 0xFF) / 255.0F * weight;
+				weightTotal += weight;
+			}
+		}
+
+		float influence = Mth.clamp(total / weightTotal, 0.0F, 1.0F);
+		return influence * influence * (3.0F - 2.0F * influence);
+	}
+
+	private static void keepFogColorInVoid(Vector4f color, Camera camera, ClientLevel level, float tickDelta) {
+		if (!level.dimensionType().hasSkyLight()) {
+			return;
+		}
+
+		double cameraY = camera.position().y();
+		float voidOnsetRange = level.getLevelData().voidDarknessOnsetRange();
+		float voidDarkness = voidOnsetRange <= 0.0F
+				? 0.0F
+				: Mth.clamp((level.getMinY() + voidOnsetRange - (float) cameraY) / voidOnsetRange, 0.0F, 1.0F);
+
+		if (voidDarkness <= 0.0F) {
+			return;
+		}
+
+		Vector4f fogColor = ARGB.vector4fFromARGB32(camera.attributeProbe().getValue(EnvironmentAttributes.FOG_COLOR, tickDelta));
+		color.set(fogColor.x(), fogColor.y(), fogColor.z(), color.w());
+	}
+
+	private static void setAdjustedColor(Vector4f color, float saturation, float scale) {
+		Vector3f adjusted = adjustedColor(color.x(), color.y(), color.z(), saturation, scale);
+		color.set(adjusted.x(), adjusted.y(), adjusted.z(), color.w());
+	}
+
+	private static Vector3f adjustedColor(Vector3fc color, float saturation, float scale) {
+		return adjustedColor(color.x(), color.y(), color.z(), saturation, scale);
+	}
+
+	private static Vector3f adjustedColor(float red, float green, float blue, float saturation, float scale) {
+		float luminance = red * 0.2126F + green * 0.7152F + blue * 0.0722F;
+		return new Vector3f(
+				clamp01((luminance + (red - luminance) * saturation) * scale),
+				clamp01((luminance + (green - luminance) * saturation) * scale),
+				clamp01((luminance + (blue - luminance) * saturation) * scale)
+		);
+	}
+
+	private static Vector3f warmBlockLight(Vector3fc color, float night) {
+		Vector3f saturated = adjustedColor(color, 1.10F, 1.03F);
+		float warmth = 0.12F + night * 0.10F;
+		return new Vector3f(
+				Mth.lerp(warmth, saturated.x(), 1.0F),
+				Mth.lerp(warmth, saturated.y(), 0.82F),
+				Mth.lerp(warmth, saturated.z(), 0.56F)
+		);
+	}
+
+	private static float clamp01(float value) {
+		return Mth.clamp(value, 0.0F, 1.0F);
+	}
+}
@@ -0,0 +1,16 @@
+package fr.koka99cab.ambiance.mixin.client;
+
+import net.minecraft.client.gui.GuiGraphicsExtractor;
+import net.minecraft.client.gui.screens.DeathScreen;
+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;
+
+@Mixin(DeathScreen.class)
+public abstract class DeathScreenMixin {
+	@Inject(method = "extractBackground", at = @At("HEAD"), cancellable = true)
+	private void ambiance$keepWorldVisibleOnDeath(GuiGraphicsExtractor graphics, int mouseX, int mouseY, float tickDelta, CallbackInfo ci) {
+		ci.cancel();
+	}
+}
@@ -0,0 +1,20 @@
+package fr.koka99cab.ambiance.mixin.client;
+
+import fr.koka99cab.ambiance.client.AmbianceEffects;
+import net.minecraft.client.Camera;
+import net.minecraft.client.DeltaTracker;
+import net.minecraft.client.multiplayer.ClientLevel;
+import net.minecraft.client.renderer.fog.FogData;
+import net.minecraft.client.renderer.fog.FogRenderer;
+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.CallbackInfoReturnable;
+
+@Mixin(FogRenderer.class)
+public abstract class FogRendererMixin {
+	@Inject(method = "setupFog", at = @At("RETURN"))
+	private void ambiance$deepenAtmosphericFog(Camera camera, int viewDistance, DeltaTracker deltaTracker, float bossOverlayDarkening, ClientLevel level, CallbackInfoReturnable<FogData> cir) {
+		AmbianceEffects.adjustFog(cir.getReturnValue(), camera, viewDistance, deltaTracker, level);
+	}
+}
@@ -0,0 +1,30 @@
+package fr.koka99cab.ambiance.mixin.client;
+
+import fr.koka99cab.ambiance.AmbianceMod;
+import net.minecraft.client.DeltaTracker;
+import net.minecraft.client.renderer.GameRenderer;
+import net.minecraft.resources.Identifier;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.Unique;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+@Mixin(GameRenderer.class)
+public abstract class GameRendererMixin {
+	@Unique
+	private static final Identifier AMBIANCE_POST_EFFECT = Identifier.fromNamespaceAndPath(AmbianceMod.MOD_ID, "saturation");
+
+	@Shadow
+	private Identifier postEffectId;
+
+	@Shadow
+	private boolean effectActive;
+
+	@Inject(method = "renderLevel", at = @At("HEAD"))
+	private void ambiance$activateSaturationPostEffect(DeltaTracker deltaTracker, CallbackInfo ci) {
+		this.postEffectId = AMBIANCE_POST_EFFECT;
+		this.effectActive = true;
+	}
+}
@@ -0,0 +1,25 @@
+package fr.koka99cab.ambiance.mixin.client;
+
+import fr.koka99cab.ambiance.client.AmbianceEffects;
+import net.minecraft.client.Camera;
+import net.minecraft.client.DeltaTracker;
+import net.minecraft.client.renderer.LevelRenderer;
+import net.minecraft.client.renderer.state.level.LevelRenderState;
+import org.spongepowered.asm.mixin.Final;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+@Mixin(LevelRenderer.class)
+public abstract class LevelRendererMixin {
+	@Shadow
+	@Final
+	private LevelRenderState levelRenderState;
+
+	@Inject(method = "extractLevel", at = @At("TAIL"))
+	private void ambiance$raiseClouds(DeltaTracker deltaTracker, Camera camera, float tickDelta, CallbackInfo ci) {
+		this.levelRenderState.cloudHeight = AmbianceEffects.adjustCloudHeight(this.levelRenderState.cloudHeight);
+	}
+}
@@ -0,0 +1,17 @@
+package fr.koka99cab.ambiance.mixin.client;
+
+import fr.koka99cab.ambiance.client.AmbianceEffects;
+import net.minecraft.client.renderer.LightmapRenderStateExtractor;
+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;
+
+@Mixin(LightmapRenderStateExtractor.class)
+public abstract class LightmapRenderStateExtractorMixin {
+	@Inject(method = "extract", at = @At("TAIL"))
+	private void ambiance$darkenNightLightmap(LightmapRenderState state, float tickDelta, CallbackInfo ci) {
+		AmbianceEffects.adjustLightmap(state, tickDelta);
+	}
+}
@@ -0,0 +1,23 @@
+package fr.koka99cab.ambiance.mixin.client;
+
+import net.minecraft.client.Camera;
+import net.minecraft.client.multiplayer.ClientLevel;
+import net.minecraft.client.renderer.SkyRenderer;
+import net.minecraft.client.renderer.state.level.SkyRenderState;
+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;
+
+@Mixin(SkyRenderer.class)
+public abstract class SkyRendererMixin {
+	@Inject(method = "extractRenderState", at = @At("RETURN"))
+	private void ambiance$keepSkyOpenBelowHorizon(ClientLevel level, float tickDelta, Camera camera, SkyRenderState state, CallbackInfo ci) {
+		state.shouldRenderDarkDisc = false;
+	}
+
+	@Inject(method = "renderDarkDisc", at = @At("HEAD"), cancellable = true)
+	private void ambiance$skipDarkDisc(CallbackInfo ci) {
+		ci.cancel();
+	}
+}
@@ -0,0 +1,17 @@
+{
+	"required": true,
+	"minVersion": "0.8",
+	"package": "fr.koka99cab.ambiance.mixin.client",
+	"compatibilityLevel": "JAVA_25",
+	"client": [
+		"DeathScreenMixin",
+		"FogRendererMixin",
+		"GameRendererMixin",
+		"LevelRendererMixin",
+		"LightmapRenderStateExtractorMixin",
+		"SkyRendererMixin"
+	],
+	"injectors": {
+		"defaultRequire": 1
+	}
+}
@@ -0,0 +1,63 @@
+{
+	"targets": {
+		"swap": {}
+	},
+	"passes": [
+		{
+			"vertex_shader": "minecraft:core/screenquad",
+			"fragment_shader": "ambiance:post/saturation",
+			"inputs": [
+				{
+					"sampler_name": "In",
+					"target": "minecraft:main",
+					"bilinear": true
+				}
+			],
+			"output": "swap",
+			"uniforms": {
+				"AmbianceConfig": [
+					{
+						"name": "Saturation",
+						"type": "float",
+						"value": 1.18
+					},
+					{
+						"name": "Contrast",
+						"type": "float",
+						"value": 1.06
+					},
+					{
+						"name": "Exposure",
+						"type": "float",
+						"value": 0.98
+					},
+					{
+						"name": "Vignette",
+						"type": "float",
+						"value": 0.08
+					}
+				]
+			}
+		},
+		{
+			"vertex_shader": "minecraft:core/screenquad",
+			"fragment_shader": "minecraft:post/blit",
+			"inputs": [
+				{
+					"sampler_name": "In",
+					"target": "swap"
+				}
+			],
+			"uniforms": {
+				"BlitConfig": [
+					{
+						"name": "ColorModulate",
+						"type": "vec4",
+						"value": [ 1.0, 1.0, 1.0, 1.0 ]
+					}
+				]
+			},
+			"output": "minecraft:main"
+		}
+	]
+}
@@ -0,0 +1,28 @@
+#version 330
+
+uniform sampler2D InSampler;
+
+layout(std140) uniform AmbianceConfig {
+	float Saturation;
+	float Contrast;
+	float Exposure;
+	float Vignette;
+};
+
+in vec2 texCoord;
+
+out vec4 fragColor;
+
+void main() {
+	vec4 sourceColor = texture(InSampler, texCoord);
+	float luminance = dot(sourceColor.rgb, vec3(0.2126, 0.7152, 0.0722));
+	vec3 color = mix(vec3(luminance), sourceColor.rgb, Saturation);
+	color = (color - 0.5) * Contrast + 0.5;
+	color *= Exposure;
+
+	vec2 centered = texCoord * 2.0 - 1.0;
+	float edge = smoothstep(0.35, 1.25, dot(centered, centered));
+	color *= 1.0 - edge * Vignette;
+
+	fragColor = vec4(clamp(color, 0.0, 1.0), sourceColor.a);
+}
@@ -0,0 +1,12 @@
+{
+	"model": {
+		"type": "minecraft:model",
+		"model": "minecraft:block/birch_leaves",
+		"tints": [
+			{
+				"type": "minecraft:constant",
+				"value": -4718794
+			}
+		]
+	}
+}
@@ -0,0 +1,59 @@
+#version 330
+
+layout(std140) uniform LightmapInfo {
+	float SkyFactor;
+	float BlockFactor;
+	float NightVisionFactor;
+	float DarknessScale;
+	float BossOverlayWorldDarkeningFactor;
+	float BrightnessFactor;
+	vec3 BlockLightTint;
+	vec3 SkyLightColor;
+	vec3 AmbientColor;
+	vec3 NightVisionColor;
+} lightmapInfo;
+
+in vec2 texCoord;
+
+out vec4 fragColor;
+
+float betaLight(float lightLevel, float ambient) {
+	float darkness = 1.0 - lightLevel;
+	return (1.0 - darkness) / (darkness * 3.0 + 1.0) * (1.0 - ambient) + ambient;
+}
+
+vec3 softGamma(vec3 color) {
+	float maxComponent = max(max(color.r, color.g), color.b);
+	if (maxComponent <= 0.0) {
+		return color;
+	}
+
+	float maxInverted = 1.0 - maxComponent;
+	float maxScaled = 1.0 - maxInverted * maxInverted * maxInverted;
+	return color * (maxScaled / maxComponent);
+}
+
+void main() {
+	float blockLevel = floor(texCoord.x * 16.0) / 15.0;
+	float skyLevel = floor(texCoord.y * 16.0) * lightmapInfo.SkyFactor / 15.0;
+	float blockIntensity = clamp(blockLevel * lightmapInfo.BlockFactor / 1.4, 0.0, 1.25);
+	float lightLevel = clamp(max(blockIntensity, skyLevel), 0.0, 1.0);
+	float ambient = (lightmapInfo.AmbientColor.r + lightmapInfo.AmbientColor.g + lightmapInfo.AmbientColor.b) / 3.0 + 0.01;
+
+	vec3 color = vec3(betaLight(lightLevel, max(ambient, 0.025)));
+	vec3 torchTint = mix(vec3(1.0, 0.78, 0.52), vec3(1.0), smoothstep(0.15, 1.0, blockLevel));
+	color *= mix(vec3(1.0), torchTint, smoothstep(0.02, 1.0, blockLevel) * 0.22);
+	color *= mix(vec3(1.0), lightmapInfo.SkyLightColor, smoothstep(0.05, 1.0, skyLevel) * 0.12);
+
+	color = mix(color, color * max(lightLevel, 0.4), lightmapInfo.BossOverlayWorldDarkeningFactor);
+	color -= vec3(lightmapInfo.DarknessScale);
+
+	color = clamp(color, 0.0, 1.0);
+	color = mix(color, softGamma(color), lightmapInfo.BrightnessFactor);
+
+	if (lightmapInfo.NightVisionFactor > 0.0) {
+		color += lightmapInfo.NightVisionColor * lightmapInfo.NightVisionFactor;
+	}
+
+	fragColor = vec4(clamp(color, 0.0, 1.0), 1.0);
+}
@@ -0,0 +1,15 @@
+package fr.koka99cab.ambiance;
+
+import net.fabricmc.api.ModInitializer;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class AmbianceMod implements ModInitializer {
+	public static final String MOD_ID = "ambiance";
+	public static final Logger LOGGER = LoggerFactory.getLogger(MOD_ID);
+
+	@Override
+	public void onInitialize() {
+		LOGGER.info("Ambiance charge pour Minecraft 26.1.2.");
+	}
+}
@@ -0,0 +1,4 @@
+{
+	"modmenu.nameTranslation.ambiance": "Ambiance",
+	"modmenu.descriptionTranslation.ambiance": "A client-side atmosphere mod that enriches Minecraft with more saturated colors, classic deep fog, and darker nights where light matters."
+}
@@ -0,0 +1,4 @@
+{
+	"modmenu.nameTranslation.ambiance": "Ambiance",
+	"modmenu.descriptionTranslation.ambiance": "A client-side atmosphere mod that enriches Minecraft with more saturated colors, classic deep fog, and darker nights where light matters."
+}
@@ -0,0 +1,30 @@
+{
+	"schemaVersion": 1,
+	"id": "ambiance",
+	"version": "${version}",
+	"name": "Ambiance",
+	"description": "A client-side atmosphere mod that enriches Minecraft with more saturated colors, classic deep fog, and darker nights where light matters.",
+	"authors": [
+		"KOKA99CAB"
+	],
+	"icon": "assets/ambiance/hw-ambiance.png",
+	"license": "LGPL-3.0-or-later",
+	"environment": "*",
+	"entrypoints": {
+		"main": [
+			"fr.koka99cab.ambiance.AmbianceMod"
+		],
+		"client": [
+			"fr.koka99cab.ambiance.client.AmbianceClient"
+		]
+	},
+	"mixins": [
+		"ambiance.client.mixins.json"
+	],
+	"depends": {
+		"fabricloader": ">=0.19.2",
+		"minecraft": "~26.1.2",
+		"java": ">=25",
+		"fabric-api": "*"
+	}
+}