BlueGit

timfa questward

Merge branch 'feature/nature-tile-tint'

timfa Tim Falken · pushed by timfa

Authored 2026-09-04 · 2 months ago

Hash
c07a2087c17079e3f12013853713b8bac5d743a0
3 files changed +245 −10
client/src/render/worldView.js +142 −10
@@ -28,6 +28,7 @@ import
28 28 } from "./canvasSprite.js";
29 29 import { setNearestFilter } from "./sprites.js";
30 30 import { waterDebugUniforms, lavaDebugUniforms } from "../play/waterDebug.js";
31 import { natureNoise01, natureTintUniforms, NATURE_TINT, NATURE_NOISE_SIZE, NATURE_NOISE_PAD } from "/shared/render/natureNoise.js";
31 32 import { SeasonId, seasonIdAt, resolveSeasonalVisualState } from "/shared/world/season.js";
32 33 import
33 34 {
@@ -874,19 +875,52 @@ const ATLAS_LIGHTING_FRAG = [
874 875 "varying vec2 v_texCoord;",
875 876 "uniform sampler2D u_texture;",
876 877 "uniform sampler2D u_secondary;",
878 "uniform sampler2D u_bump;",
877 879 "uniform float u_alpha;",
878 880 "uniform float u_ambientDark;",
879 881 "uniform float u_lightRow;",
882 "uniform float u_useNature;",
883 "uniform float u_natureTint;",
884 "uniform float u_natureDark;",
885 "uniform float u_natureContrast;",
880 886 "void main() {",
881 887 " vec4 color = texture2D(u_texture, v_texCoord);",
882 888 " if (color.a <= 0.0) { discard; }",
889 " vec3 rgb = color.rgb;",
890 " if (u_useNature > 0.5) {",
891 // Soft bilinear over 18×18 noise (1-tile halo) so blend crosses chunk edges.
892 " vec2 texel = v_texCoord * 16.0 - 0.5;",
893 " vec2 i0 = floor(texel);",
894 " vec2 f = fract(texel);",
895 " vec2 i1 = i0 + 1.0;",
896 " vec2 c00 = (i0 + 1.5) / 18.0;",
897 " vec2 c10 = (vec2(i1.x, i0.y) + 1.5) / 18.0;",
898 " vec2 c01 = (vec2(i0.x, i1.y) + 1.5) / 18.0;",
899 " vec2 c11 = (i1 + 1.5) / 18.0;",
900 " vec4 s00 = texture2D(u_bump, c00);",
901 " vec4 s10 = texture2D(u_bump, c10);",
902 " vec4 s01 = texture2D(u_bump, c01);",
903 " vec4 s11 = texture2D(u_bump, c11);",
904 " float nRaw = mix(mix(s00.r, s10.r, f.x), mix(s01.r, s11.r, f.x), f.y);",
905 " float a = mix(mix(s00.a, s10.a, f.x), mix(s01.a, s11.a, f.x), f.y);",
906 " if (a > 0.01) {",
907 " float n = clamp((nRaw - 0.5) * max(u_natureContrast, 0.01) + 0.5, 0.0, 1.0);",
908 " float c = (n - 0.5) * 2.0;",
909 " vec3 tinted = rgb * (1.0 - c * u_natureDark);",
910 " vec3 cool = vec3(0.72, 1.14, 1.08);",
911 " vec3 warm = vec3(1.28, 1.06, 0.68);",
912 " vec3 tint = mix(cool, warm, n);",
913 " tinted *= mix(vec3(1.0), tint, clamp(u_natureTint, 0.0, 1.0));",
914 " rgb = mix(rgb, tinted, clamp(a, 0.0, 1.0));",
915 " }",
916 " }",
883 917 " vec2 lightUV = v_texCoord;",
884 918 " if (u_lightRow >= 0.0) {",
885 919 " lightUV.y = (u_lightRow + v_texCoord.y) / 16.0;",
886 920 " }",
887 921 " float lit = texture2D(u_secondary, lightUV).r;",
888 922 " float darkness = u_ambientDark * (1.0 - lit);",
889 " vec3 rgb = mix(color.rgb, vec3(0.0), darkness);",
923 " rgb = mix(rgb, vec3(0.0), darkness);",
890 924 " gl_FragColor = vec4(rgb, color.a * u_alpha);",
891 925 "}"
892 926 ].join("\n");
@@ -4672,30 +4706,35 @@ export class WorldView
4672 4706 if (!baked)
4673 4707 {
4674 4708 const lightmapCanvas = makeLightmapCanvas(atlasPx);
4709 const natureCanvas = makeNatureNoiseCanvas();
4675 4710 baked = {
4676 4711 groundCanvas: atlases.ground,
4677 4712 blockCanvases: atlases.blockRows,
4678 4713 bloomCanvas: atlases.bloom,
4679 4714 lightmapCanvas,
4715 natureCanvas,
4680 4716 groundImage,
4681 4717 blockImages,
4682 4718 bloomImage,
4683 4719 lightmapImage: frameworkImageFromCanvas(lightmapCanvas),
4720 natureImage: frameworkImageFromCanvas(natureCanvas),
4684 4721 groundObject: null,
4685 4722 blockObjects: [],
4686 4723 bloomObject: null,
4687 4724 tallBlocks: atlases.tallBlocks,
4688 4725 animatedGrounds: atlases.animatedGrounds,
4689 4726 lightmapPixels: null,
4690 atlasCacheRefs: atlases.cacheRefs
4727 atlasCacheRefs: atlases.cacheRefs,
4728 chunkX: snapshot.chunkX,
4729 chunkY: snapshot.chunkY
4691 4730 };
4692 4731 baked.groundObject = new GameObject(0, 0, baked.groundImage, LAYER_GROUND);
4693 this.#applyAtlasLighting(baked.groundObject, baked.lightmapImage, -1);
4732 this.#applyAtlasLighting(baked.groundObject, baked.lightmapImage, -1, baked.natureImage);
4694 4733 this.scene.addObject(baked.groundObject);
4695 4734 for (let row = 0; row < CHUNK_SIZE; row++)
4696 4735 {
4697 4736 const object = new GameObject(0, 0, baked.blockImages[row], SORT_BLOCK);
4698 this.#applyAtlasLighting(object, baked.lightmapImage, row);
4737 this.#applyAtlasLighting(object, baked.lightmapImage, row, null);
4699 4738 this.scene.addObject(object);
4700 4739 baked.blockObjects.push(object);
4701 4740 }
@@ -4707,13 +4746,20 @@ export class WorldView
4707 4746 }
4708 4747 else
4709 4748 {
4749 baked.chunkX = snapshot.chunkX;
4750 baked.chunkY = snapshot.chunkY;
4751 if (!baked.natureCanvas)
4752 {
4753 baked.natureCanvas = makeNatureNoiseCanvas();
4754 baked.natureImage = frameworkImageFromCanvas(baked.natureCanvas);
4755 }
4710 4756 if (baked.groundCanvas !== atlases.ground)
4711 4757 {
4712 4758 baked.groundCanvas = atlases.ground;
4713 4759 baked.groundImage = groundImage;
4714 4760 baked.groundObject.renderer.sprite = groundImage;
4715 this.#applyAtlasLighting(baked.groundObject, baked.lightmapImage, -1);
4716 4761 }
4762 this.#applyAtlasLighting(baked.groundObject, baked.lightmapImage, -1, baked.natureImage);
4717 4763 for (let row = 0; row < CHUNK_SIZE; row++)
4718 4764 {
4719 4765 if (baked.blockCanvases[row] !== atlases.blockRows[row])
@@ -4725,7 +4771,8 @@ export class WorldView
4725 4771 this.#applyAtlasLighting(
4726 4772 baked.blockObjects[row],
4727 4773 baked.lightmapImage,
4728 row
4774 row,
4775 null
4729 4776 );
4730 4777 }
4731 4778 if (baked.bloomCanvas !== atlases.bloom)
@@ -4740,6 +4787,7 @@ export class WorldView
4740 4787 }
4741 4788 baked.chunkX = snapshot.chunkX;
4742 4789 baked.chunkY = snapshot.chunkY;
4790 this.#refreshNatureNoiseAround(snapshot.chunkX, snapshot.chunkY);
4743 4791 baked.lightmapCacheKey = null;
4744 4792 this.#invalidateNeighborLightmapCaches(snapshot.chunkX, snapshot.chunkY);
4745 4793 this.#layoutBakedChunk(snapshot);
@@ -4797,6 +4845,7 @@ export class WorldView
4797 4845 { maybeWarm(baked.blockCanvases[row], refs?.blockRows?.[row]); }
4798 4846 maybeWarm(baked.bloomCanvas, refs?.bloom);
4799 4847 this.#queueCanvasTextureWarm(baked.lightmapCanvas, chunkX, chunkY);
4848 this.#queueCanvasTextureWarm(baked.natureCanvas, chunkX, chunkY);
4800 4849 }
4801 4850
4802 4851 #scheduleTextureWarm ()
@@ -4823,20 +4872,89 @@ export class WorldView
4823 4872 { this.#scheduleTextureWarm(); }
4824 4873 }
4825 4874
4826 #applyAtlasLighting (object, lightmapImage, lightRow)
4875 #applyAtlasLighting (object, lightmapImage, lightRow, natureImage = null)
4827 4876 {
4828 4877 if (!object?.renderer)
4829 4878 { return; }
4830 4879 object._lit = true;
4831 4880 object.renderer.shader = getAtlasLightingShader();
4832 object.renderer.bumpMap = null;
4881 const useNature = natureImage != null && lightRow < 0;
4882 object.renderer.bumpMap = useNature ? natureImage : null;
4833 4883 object.renderer.secondaryMap = lightmapImage;
4834 4884 object.renderer.shaderUniforms = {
4835 4885 u_ambientDark: 0,
4836 u_lightRow: lightRow
4886 u_lightRow: lightRow,
4887 u_useNature: useNature ? 1 : 0,
4888 u_natureTint: 0,
4889 u_natureDark: 0,
4890 u_natureContrast: 1,
4891 ...(useNature ? natureTintUniforms() : {})
4837 4892 };
4838 4893 }
4839 4894
4895 /** Rebuild nature noise for a chunk and neighbors (halo needs adjacent grounds). */
4896 #refreshNatureNoiseAround (chunkX, chunkY)
4897 {
4898 for (let dy = -1; dy <= 1; dy++)
4899 {
4900 for (let dx = -1; dx <= 1; dx++)
4901 {
4902 const cx = chunkX + dx;
4903 const cy = chunkY + dy;
4904 const baked = this.bakedChunks.get(`${cx},${cy}`);
4905 const snapshot = this.chunks.get(`${cx},${cy}`);
4906 if (!baked?.natureCanvas || !snapshot)
4907 { continue; }
4908 this.#fillNatureNoise(baked, snapshot);
4909 if (baked.groundObject)
4910 { this.#applyAtlasLighting(baked.groundObject, baked.lightmapImage, -1, baked.natureImage); }
4911 }
4912 }
4913 }
4914
4915 #fillNatureNoise (baked, snapshot)
4916 {
4917 if (!baked?.natureCanvas || !snapshot)
4918 { return; }
4919 const canvas = baked.natureCanvas;
4920 if (canvas.width !== NATURE_NOISE_SIZE || canvas.height !== NATURE_NOISE_SIZE)
4921 {
4922 canvas.width = NATURE_NOISE_SIZE;
4923 canvas.height = NATURE_NOISE_SIZE;
4924 }
4925 const scale = NATURE_TINT.scale;
4926 const ctx = canvas.getContext("2d");
4927 const image = ctx.createImageData(NATURE_NOISE_SIZE, NATURE_NOISE_SIZE);
4928 const baseX = snapshot.chunkX * CHUNK_SIZE;
4929 const baseY = snapshot.chunkY * CHUNK_SIZE;
4930 const pad = NATURE_NOISE_PAD;
4931 for (let py = 0; py < NATURE_NOISE_SIZE; py++)
4932 {
4933 for (let px = 0; px < NATURE_NOISE_SIZE; px++)
4934 {
4935 const lx = px - pad;
4936 const ly = py - pad;
4937 const worldX = baseX + lx;
4938 const worldY = baseY + ly;
4939 const ground = this.#groundAtTile(worldX, worldY);
4940 const typeId = ground == null ? null : normalizeGround(ground).typeId;
4941 const blendable = typeId != null && !!GROUND_DEFINITIONS[typeId]?.blendable;
4942 const n = natureNoise01(worldX, worldY, scale);
4943 const i = (py * NATURE_NOISE_SIZE + px) * 4;
4944 const v = Math.round(n * 255);
4945 image.data[i] = v;
4946 image.data[i + 1] = v;
4947 image.data[i + 2] = v;
4948 image.data[i + 3] = blendable ? 255 : 0;
4949 }
4950 }
4951 ctx.putImageData(image, 0, 0);
4952 invalidateCanvasTexture(this.scene, baked.natureCanvas);
4953 this.#queueCanvasTextureWarm(baked.natureCanvas, snapshot.chunkX, snapshot.chunkY);
4954 if (!baked.natureImage)
4955 { baked.natureImage = frameworkImageFromCanvas(baked.natureCanvas); }
4956 }
4957
4840 4958 #syncCliffGroundTopSprite (object, darkness, groundImage, localX, localY)
4841 4959 {
4842 4960 if (!object?.renderer)
@@ -4895,6 +5013,7 @@ export class WorldView
4895 5013 { object.destroy(); }
4896 5014 baked.bloomObject?.destroy();
4897 5015 invalidateCanvasTexture(this.scene, baked.lightmapCanvas);
5016 invalidateCanvasTexture(this.scene, baked.natureCanvas);
4898 5017 this.bakedChunks.delete(key);
4899 5018 }
4900 5019
@@ -5398,7 +5517,12 @@ export class WorldView
5398 5517 this.#writeChunkLightmap(baked, lights, mobileLights, blockLights, lightOcclusion, ambientDark);
5399 5518 // Lightmap stores visible light (1 − shade); shader applies darkness = 1 − lit.
5400 5519 if (baked.groundObject?.renderer?.shaderUniforms)
5401 { baked.groundObject.renderer.shaderUniforms.u_ambientDark = 1; }
5520 {
5521 Object.assign(baked.groundObject.renderer.shaderUniforms, {
5522 u_ambientDark: 1,
5523 ...natureTintUniforms()
5524 });
5525 }
5402 5526 for (const object of baked.blockObjects ?? [])
5403 5527 {
5404 5528 if (object?.renderer?.shaderUniforms)
@@ -6016,6 +6140,14 @@ function makeLightmapCanvas (size)
6016 6140 return canvas;
6017 6141 }
6018 6142
6143 function makeNatureNoiseCanvas ()
6144 {
6145 const canvas = document.createElement("canvas");
6146 canvas.width = NATURE_NOISE_SIZE;
6147 canvas.height = NATURE_NOISE_SIZE;
6148 return canvas;
6149 }
6150
6019 6151 function copyCanvas (source, dest)
6020 6152 {
6021 6153 const ctx = dest.getContext("2d");
@@ -28,6 +28,7 @@ import
28} from "./canvasSprite.js";
28} from "./canvasSprite.js";
29import { setNearestFilter } from "./sprites.js";
29import { setNearestFilter } from "./sprites.js";
30import { waterDebugUniforms, lavaDebugUniforms } from "../play/waterDebug.js";
30import { waterDebugUniforms, lavaDebugUniforms } from "../play/waterDebug.js";
31import { natureNoise01, natureTintUniforms, NATURE_TINT, NATURE_NOISE_SIZE, NATURE_NOISE_PAD } from "/shared/render/natureNoise.js";
31import { SeasonId, seasonIdAt, resolveSeasonalVisualState } from "/shared/world/season.js";
32import { SeasonId, seasonIdAt, resolveSeasonalVisualState } from "/shared/world/season.js";
32import
33import
33{
34{
@@ -874,19 +875,52 @@ const ATLAS_LIGHTING_FRAG = [
874 "varying vec2 v_texCoord;",
875 "varying vec2 v_texCoord;",
875 "uniform sampler2D u_texture;",
876 "uniform sampler2D u_texture;",
876 "uniform sampler2D u_secondary;",
877 "uniform sampler2D u_secondary;",
878 "uniform sampler2D u_bump;",
877 "uniform float u_alpha;",
879 "uniform float u_alpha;",
878 "uniform float u_ambientDark;",
880 "uniform float u_ambientDark;",
879 "uniform float u_lightRow;",
881 "uniform float u_lightRow;",
882 "uniform float u_useNature;",
883 "uniform float u_natureTint;",
884 "uniform float u_natureDark;",
885 "uniform float u_natureContrast;",
880 "void main() {",
886 "void main() {",
881 " vec4 color = texture2D(u_texture, v_texCoord);",
887 " vec4 color = texture2D(u_texture, v_texCoord);",
882 " if (color.a <= 0.0) { discard; }",
888 " if (color.a <= 0.0) { discard; }",
889 " vec3 rgb = color.rgb;",
890 " if (u_useNature > 0.5) {",
891 // Soft bilinear over 18×18 noise (1-tile halo) so blend crosses chunk edges.
892 " vec2 texel = v_texCoord * 16.0 - 0.5;",
893 " vec2 i0 = floor(texel);",
894 " vec2 f = fract(texel);",
895 " vec2 i1 = i0 + 1.0;",
896 " vec2 c00 = (i0 + 1.5) / 18.0;",
897 " vec2 c10 = (vec2(i1.x, i0.y) + 1.5) / 18.0;",
898 " vec2 c01 = (vec2(i0.x, i1.y) + 1.5) / 18.0;",
899 " vec2 c11 = (i1 + 1.5) / 18.0;",
900 " vec4 s00 = texture2D(u_bump, c00);",
901 " vec4 s10 = texture2D(u_bump, c10);",
902 " vec4 s01 = texture2D(u_bump, c01);",
903 " vec4 s11 = texture2D(u_bump, c11);",
904 " float nRaw = mix(mix(s00.r, s10.r, f.x), mix(s01.r, s11.r, f.x), f.y);",
905 " float a = mix(mix(s00.a, s10.a, f.x), mix(s01.a, s11.a, f.x), f.y);",
906 " if (a > 0.01) {",
907 " float n = clamp((nRaw - 0.5) * max(u_natureContrast, 0.01) + 0.5, 0.0, 1.0);",
908 " float c = (n - 0.5) * 2.0;",
909 " vec3 tinted = rgb * (1.0 - c * u_natureDark);",
910 " vec3 cool = vec3(0.72, 1.14, 1.08);",
911 " vec3 warm = vec3(1.28, 1.06, 0.68);",
912 " vec3 tint = mix(cool, warm, n);",
913 " tinted *= mix(vec3(1.0), tint, clamp(u_natureTint, 0.0, 1.0));",
914 " rgb = mix(rgb, tinted, clamp(a, 0.0, 1.0));",
915 " }",
916 " }",
883 " vec2 lightUV = v_texCoord;",
917 " vec2 lightUV = v_texCoord;",
884 " if (u_lightRow >= 0.0) {",
918 " if (u_lightRow >= 0.0) {",
885 " lightUV.y = (u_lightRow + v_texCoord.y) / 16.0;",
919 " lightUV.y = (u_lightRow + v_texCoord.y) / 16.0;",
886 " }",
920 " }",
887 " float lit = texture2D(u_secondary, lightUV).r;",
921 " float lit = texture2D(u_secondary, lightUV).r;",
888 " float darkness = u_ambientDark * (1.0 - lit);",
922 " float darkness = u_ambientDark * (1.0 - lit);",
889 " vec3 rgb = mix(color.rgb, vec3(0.0), darkness);",
923 " rgb = mix(rgb, vec3(0.0), darkness);",
890 " gl_FragColor = vec4(rgb, color.a * u_alpha);",
924 " gl_FragColor = vec4(rgb, color.a * u_alpha);",
891 "}"
925 "}"
892].join("\n");
926].join("\n");
@@ -4672,30 +4706,35 @@ export class WorldView
4672 if (!baked)
4706 if (!baked)
4673 {
4707 {
4674 const lightmapCanvas = makeLightmapCanvas(atlasPx);
4708 const lightmapCanvas = makeLightmapCanvas(atlasPx);
4709 const natureCanvas = makeNatureNoiseCanvas();
4675 baked = {
4710 baked = {
4676 groundCanvas: atlases.ground,
4711 groundCanvas: atlases.ground,
4677 blockCanvases: atlases.blockRows,
4712 blockCanvases: atlases.blockRows,
4678 bloomCanvas: atlases.bloom,
4713 bloomCanvas: atlases.bloom,
4679 lightmapCanvas,
4714 lightmapCanvas,
4715 natureCanvas,
4680 groundImage,
4716 groundImage,
4681 blockImages,
4717 blockImages,
4682 bloomImage,
4718 bloomImage,
4683 lightmapImage: frameworkImageFromCanvas(lightmapCanvas),
4719 lightmapImage: frameworkImageFromCanvas(lightmapCanvas),
4720 natureImage: frameworkImageFromCanvas(natureCanvas),
4684 groundObject: null,
4721 groundObject: null,
4685 blockObjects: [],
4722 blockObjects: [],
4686 bloomObject: null,
4723 bloomObject: null,
4687 tallBlocks: atlases.tallBlocks,
4724 tallBlocks: atlases.tallBlocks,
4688 animatedGrounds: atlases.animatedGrounds,
4725 animatedGrounds: atlases.animatedGrounds,
4689 lightmapPixels: null,
4726 lightmapPixels: null,
4690 atlasCacheRefs: atlases.cacheRefs
4727 atlasCacheRefs: atlases.cacheRefs,
4728 chunkX: snapshot.chunkX,
4729 chunkY: snapshot.chunkY
4691 };
4730 };
4692 baked.groundObject = new GameObject(0, 0, baked.groundImage, LAYER_GROUND);
4731 baked.groundObject = new GameObject(0, 0, baked.groundImage, LAYER_GROUND);
4693 this.#applyAtlasLighting(baked.groundObject, baked.lightmapImage, -1);
4732 this.#applyAtlasLighting(baked.groundObject, baked.lightmapImage, -1, baked.natureImage);
4694 this.scene.addObject(baked.groundObject);
4733 this.scene.addObject(baked.groundObject);
4695 for (let row = 0; row < CHUNK_SIZE; row++)
4734 for (let row = 0; row < CHUNK_SIZE; row++)
4696 {
4735 {
4697 const object = new GameObject(0, 0, baked.blockImages[row], SORT_BLOCK);
4736 const object = new GameObject(0, 0, baked.blockImages[row], SORT_BLOCK);
4698 this.#applyAtlasLighting(object, baked.lightmapImage, row);
4737 this.#applyAtlasLighting(object, baked.lightmapImage, row, null);
4699 this.scene.addObject(object);
4738 this.scene.addObject(object);
4700 baked.blockObjects.push(object);
4739 baked.blockObjects.push(object);
4701 }
4740 }
@@ -4707,13 +4746,20 @@ export class WorldView
4707 }
4746 }
4708 else
4747 else
4709 {
4748 {
4749 baked.chunkX = snapshot.chunkX;
4750 baked.chunkY = snapshot.chunkY;
4751 if (!baked.natureCanvas)
4752 {
4753 baked.natureCanvas = makeNatureNoiseCanvas();
4754 baked.natureImage = frameworkImageFromCanvas(baked.natureCanvas);
4755 }
4710 if (baked.groundCanvas !== atlases.ground)
4756 if (baked.groundCanvas !== atlases.ground)
4711 {
4757 {
4712 baked.groundCanvas = atlases.ground;
4758 baked.groundCanvas = atlases.ground;
4713 baked.groundImage = groundImage;
4759 baked.groundImage = groundImage;
4714 baked.groundObject.renderer.sprite = groundImage;
4760 baked.groundObject.renderer.sprite = groundImage;
4715 this.#applyAtlasLighting(baked.groundObject, baked.lightmapImage, -1);
4716 }
4761 }
4762 this.#applyAtlasLighting(baked.groundObject, baked.lightmapImage, -1, baked.natureImage);
4717 for (let row = 0; row < CHUNK_SIZE; row++)
4763 for (let row = 0; row < CHUNK_SIZE; row++)
4718 {
4764 {
4719 if (baked.blockCanvases[row] !== atlases.blockRows[row])
4765 if (baked.blockCanvases[row] !== atlases.blockRows[row])
@@ -4725,7 +4771,8 @@ export class WorldView
4725 this.#applyAtlasLighting(
4771 this.#applyAtlasLighting(
4726 baked.blockObjects[row],
4772 baked.blockObjects[row],
4727 baked.lightmapImage,
4773 baked.lightmapImage,
4728 row
4774 row,
4775 null
4729 );
4776 );
4730 }
4777 }
4731 if (baked.bloomCanvas !== atlases.bloom)
4778 if (baked.bloomCanvas !== atlases.bloom)
@@ -4740,6 +4787,7 @@ export class WorldView
4740 }
4787 }
4741 baked.chunkX = snapshot.chunkX;
4788 baked.chunkX = snapshot.chunkX;
4742 baked.chunkY = snapshot.chunkY;
4789 baked.chunkY = snapshot.chunkY;
4790 this.#refreshNatureNoiseAround(snapshot.chunkX, snapshot.chunkY);
4743 baked.lightmapCacheKey = null;
4791 baked.lightmapCacheKey = null;
4744 this.#invalidateNeighborLightmapCaches(snapshot.chunkX, snapshot.chunkY);
4792 this.#invalidateNeighborLightmapCaches(snapshot.chunkX, snapshot.chunkY);
4745 this.#layoutBakedChunk(snapshot);
4793 this.#layoutBakedChunk(snapshot);
@@ -4797,6 +4845,7 @@ export class WorldView
4797 { maybeWarm(baked.blockCanvases[row], refs?.blockRows?.[row]); }
4845 { maybeWarm(baked.blockCanvases[row], refs?.blockRows?.[row]); }
4798 maybeWarm(baked.bloomCanvas, refs?.bloom);
4846 maybeWarm(baked.bloomCanvas, refs?.bloom);
4799 this.#queueCanvasTextureWarm(baked.lightmapCanvas, chunkX, chunkY);
4847 this.#queueCanvasTextureWarm(baked.lightmapCanvas, chunkX, chunkY);
4848 this.#queueCanvasTextureWarm(baked.natureCanvas, chunkX, chunkY);
4800 }
4849 }
4801
4850
4802 #scheduleTextureWarm ()
4851 #scheduleTextureWarm ()
@@ -4823,20 +4872,89 @@ export class WorldView
4823 { this.#scheduleTextureWarm(); }
4872 { this.#scheduleTextureWarm(); }
4824 }
4873 }
4825
4874
4826 #applyAtlasLighting (object, lightmapImage, lightRow)
4875 #applyAtlasLighting (object, lightmapImage, lightRow, natureImage = null)
4827 {
4876 {
4828 if (!object?.renderer)
4877 if (!object?.renderer)
4829 { return; }
4878 { return; }
4830 object._lit = true;
4879 object._lit = true;
4831 object.renderer.shader = getAtlasLightingShader();
4880 object.renderer.shader = getAtlasLightingShader();
4832 object.renderer.bumpMap = null;
4881 const useNature = natureImage != null && lightRow < 0;
4882 object.renderer.bumpMap = useNature ? natureImage : null;
4833 object.renderer.secondaryMap = lightmapImage;
4883 object.renderer.secondaryMap = lightmapImage;
4834 object.renderer.shaderUniforms = {
4884 object.renderer.shaderUniforms = {
4835 u_ambientDark: 0,
4885 u_ambientDark: 0,
4836 u_lightRow: lightRow
4886 u_lightRow: lightRow,
4887 u_useNature: useNature ? 1 : 0,
4888 u_natureTint: 0,
4889 u_natureDark: 0,
4890 u_natureContrast: 1,
4891 ...(useNature ? natureTintUniforms() : {})
4837 };
4892 };
4838 }
4893 }
4839
4894
4895 /** Rebuild nature noise for a chunk and neighbors (halo needs adjacent grounds). */
4896 #refreshNatureNoiseAround (chunkX, chunkY)
4897 {
4898 for (let dy = -1; dy <= 1; dy++)
4899 {
4900 for (let dx = -1; dx <= 1; dx++)
4901 {
4902 const cx = chunkX + dx;
4903 const cy = chunkY + dy;
4904 const baked = this.bakedChunks.get(`${cx},${cy}`);
4905 const snapshot = this.chunks.get(`${cx},${cy}`);
4906 if (!baked?.natureCanvas || !snapshot)
4907 { continue; }
4908 this.#fillNatureNoise(baked, snapshot);
4909 if (baked.groundObject)
4910 { this.#applyAtlasLighting(baked.groundObject, baked.lightmapImage, -1, baked.natureImage); }
4911 }
4912 }
4913 }
4914
4915 #fillNatureNoise (baked, snapshot)
4916 {
4917 if (!baked?.natureCanvas || !snapshot)
4918 { return; }
4919 const canvas = baked.natureCanvas;
4920 if (canvas.width !== NATURE_NOISE_SIZE || canvas.height !== NATURE_NOISE_SIZE)
4921 {
4922 canvas.width = NATURE_NOISE_SIZE;
4923 canvas.height = NATURE_NOISE_SIZE;
4924 }
4925 const scale = NATURE_TINT.scale;
4926 const ctx = canvas.getContext("2d");
4927 const image = ctx.createImageData(NATURE_NOISE_SIZE, NATURE_NOISE_SIZE);
4928 const baseX = snapshot.chunkX * CHUNK_SIZE;
4929 const baseY = snapshot.chunkY * CHUNK_SIZE;
4930 const pad = NATURE_NOISE_PAD;
4931 for (let py = 0; py < NATURE_NOISE_SIZE; py++)
4932 {
4933 for (let px = 0; px < NATURE_NOISE_SIZE; px++)
4934 {
4935 const lx = px - pad;
4936 const ly = py - pad;
4937 const worldX = baseX + lx;
4938 const worldY = baseY + ly;
4939 const ground = this.#groundAtTile(worldX, worldY);
4940 const typeId = ground == null ? null : normalizeGround(ground).typeId;
4941 const blendable = typeId != null && !!GROUND_DEFINITIONS[typeId]?.blendable;
4942 const n = natureNoise01(worldX, worldY, scale);
4943 const i = (py * NATURE_NOISE_SIZE + px) * 4;
4944 const v = Math.round(n * 255);
4945 image.data[i] = v;
4946 image.data[i + 1] = v;
4947 image.data[i + 2] = v;
4948 image.data[i + 3] = blendable ? 255 : 0;
4949 }
4950 }
4951 ctx.putImageData(image, 0, 0);
4952 invalidateCanvasTexture(this.scene, baked.natureCanvas);
4953 this.#queueCanvasTextureWarm(baked.natureCanvas, snapshot.chunkX, snapshot.chunkY);
4954 if (!baked.natureImage)
4955 { baked.natureImage = frameworkImageFromCanvas(baked.natureCanvas); }
4956 }
4957
4840 #syncCliffGroundTopSprite (object, darkness, groundImage, localX, localY)
4958 #syncCliffGroundTopSprite (object, darkness, groundImage, localX, localY)
4841 {
4959 {
4842 if (!object?.renderer)
4960 if (!object?.renderer)
@@ -4895,6 +5013,7 @@ export class WorldView
4895 { object.destroy(); }
5013 { object.destroy(); }
4896 baked.bloomObject?.destroy();
5014 baked.bloomObject?.destroy();
4897 invalidateCanvasTexture(this.scene, baked.lightmapCanvas);
5015 invalidateCanvasTexture(this.scene, baked.lightmapCanvas);
5016 invalidateCanvasTexture(this.scene, baked.natureCanvas);
4898 this.bakedChunks.delete(key);
5017 this.bakedChunks.delete(key);
4899 }
5018 }
4900
5019
@@ -5398,7 +5517,12 @@ export class WorldView
5398 this.#writeChunkLightmap(baked, lights, mobileLights, blockLights, lightOcclusion, ambientDark);
5517 this.#writeChunkLightmap(baked, lights, mobileLights, blockLights, lightOcclusion, ambientDark);
5399 // Lightmap stores visible light (1 − shade); shader applies darkness = 1 − lit.
5518 // Lightmap stores visible light (1 − shade); shader applies darkness = 1 − lit.
5400 if (baked.groundObject?.renderer?.shaderUniforms)
5519 if (baked.groundObject?.renderer?.shaderUniforms)
5401 { baked.groundObject.renderer.shaderUniforms.u_ambientDark = 1; }
5520 {
5521 Object.assign(baked.groundObject.renderer.shaderUniforms, {
5522 u_ambientDark: 1,
5523 ...natureTintUniforms()
5524 });
5525 }
5402 for (const object of baked.blockObjects ?? [])
5526 for (const object of baked.blockObjects ?? [])
5403 {
5527 {
5404 if (object?.renderer?.shaderUniforms)
5528 if (object?.renderer?.shaderUniforms)
@@ -6016,6 +6140,14 @@ function makeLightmapCanvas (size)
6016 return canvas;
6140 return canvas;
6017}
6141}
6018
6142
6143function makeNatureNoiseCanvas ()
6144{
6145 const canvas = document.createElement("canvas");
6146 canvas.width = NATURE_NOISE_SIZE;
6147 canvas.height = NATURE_NOISE_SIZE;
6148 return canvas;
6149}
6150
6019function copyCanvas (source, dest)
6151function copyCanvas (source, dest)
6020{
6152{
6021 const ctx = dest.getContext("2d");
6153 const ctx = dest.getContext("2d");
server/tests/nature-noise.test.js added +24 −0
@@ -0,0 +1,24 @@
1 import test from "node:test";
2 import assert from "node:assert/strict";
3 import { natureNoise01, perlin2, NATURE_TINT, NATURE_NOISE_SIZE } from "../../shared/render/natureNoise.js";
4 import { CHUNK_SIZE } from "../../shared/protocol/constants.js";
5
6 test("nature noise is continuous across chunk borders", () =>
7 {
8 const scale = NATURE_TINT.scale;
9 const a = natureNoise01(CHUNK_SIZE - 1, 5, scale);
10 const b = natureNoise01(CHUNK_SIZE, 5, scale);
11 assert.ok(Math.abs(a - b) < 0.25, `border jump too large: ${a} vs ${b}`);
12 });
13
14 test("perlin is deterministic and bounded", () =>
15 {
16 assert.equal(perlin2(1.5, 2.5), perlin2(1.5, 2.5));
17 const n = natureNoise01(12, 34, NATURE_TINT.scale);
18 assert.ok(n >= 0 && n <= 1);
19 });
20
21 test("nature noise texture includes a one-tile halo", () =>
22 {
23 assert.equal(NATURE_NOISE_SIZE, CHUNK_SIZE + 2);
24 });
@@ -0,0 +1,24 @@
1import test from "node:test";
2import assert from "node:assert/strict";
3import { natureNoise01, perlin2, NATURE_TINT, NATURE_NOISE_SIZE } from "../../shared/render/natureNoise.js";
4import { CHUNK_SIZE } from "../../shared/protocol/constants.js";
5
6test("nature noise is continuous across chunk borders", () =>
7{
8 const scale = NATURE_TINT.scale;
9 const a = natureNoise01(CHUNK_SIZE - 1, 5, scale);
10 const b = natureNoise01(CHUNK_SIZE, 5, scale);
11 assert.ok(Math.abs(a - b) < 0.25, `border jump too large: ${a} vs ${b}`);
12});
13
14test("perlin is deterministic and bounded", () =>
15{
16 assert.equal(perlin2(1.5, 2.5), perlin2(1.5, 2.5));
17 const n = natureNoise01(12, 34, NATURE_TINT.scale);
18 assert.ok(n >= 0 && n <= 1);
19});
20
21test("nature noise texture includes a one-tile halo", () =>
22{
23 assert.equal(NATURE_NOISE_SIZE, CHUNK_SIZE + 2);
24});
shared/render/natureNoise.js added +79 −0
@@ -0,0 +1,79 @@
1 /**
2 * World-space tile noise for subtle nature-ground tint (1 sample per tile).
3 * Uses chunk+local indices so adjacent chunks share a continuous field.
4 */
5
6 import { CHUNK_SIZE } from "../protocol/constants.js";
7
8 /** Locked look from playtest (scale / contrast / tint / darken). */
9 export const NATURE_TINT = Object.freeze({
10 scale: 0.17,
11 contrast: 1.65,
12 tint: 0.31,
13 darken: 0.16
14 });
15
16 /** Shader uniforms for atlas nature tint (ground only). */
17 export function natureTintUniforms ()
18 {
19 return {
20 u_useNature: 1,
21 u_natureTint: NATURE_TINT.tint,
22 u_natureDark: NATURE_TINT.darken,
23 u_natureContrast: NATURE_TINT.contrast
24 };
25 }
26
27 /** Noise texture includes a 1-tile halo so soft blend crosses chunk edges. */
28 export const NATURE_NOISE_PAD = 1;
29 export const NATURE_NOISE_SIZE = CHUNK_SIZE + NATURE_NOISE_PAD * 2;
30
31 function fade (t)
32 {
33 return t * t * t * (t * (t * 6 - 15) + 10);
34 }
35
36 function lerp (a, b, t)
37 {
38 return a + (b - a) * t;
39 }
40
41 function hash2 (ix, iy)
42 {
43 const n = Math.sin(ix * 127.1 + iy * 311.7) * 43758.5453123;
44 return n - Math.floor(n);
45 }
46
47 /** Gradient-style value at integer lattice. */
48 function gradDot (ix, iy, x, y)
49 {
50 const angle = hash2(ix, iy) * Math.PI * 2;
51 return Math.cos(angle) * x + Math.sin(angle) * y;
52 }
53
54 /** Classic 2D Perlin in roughly [-1, 1]. */
55 export function perlin2 (x, y)
56 {
57 const x0 = Math.floor(x);
58 const y0 = Math.floor(y);
59 const fx = x - x0;
60 const fy = y - y0;
61 const u = fade(fx);
62 const v = fade(fy);
63 const n00 = gradDot(x0, y0, fx, fy);
64 const n10 = gradDot(x0 + 1, y0, fx - 1, fy);
65 const n01 = gradDot(x0, y0 + 1, fx, fy - 1);
66 const n11 = gradDot(x0 + 1, y0 + 1, fx - 1, fy - 1);
67 return lerp(lerp(n00, n10, u), lerp(n01, n11, u), v);
68 }
69
70 /** 0..1 FBM of Perlin (2 octaves — cheap for 18×18 fills). */
71 export function natureNoise01 (worldTileX, worldTileY, scale = NATURE_TINT.scale)
72 {
73 const s = Math.max(0.001, Number(scale) || NATURE_TINT.scale);
74 const x = worldTileX * s;
75 const y = worldTileY * s;
76 let sum = perlin2(x, y);
77 sum += 0.5 * perlin2(x * 2.0 + 19.1, y * 2.0 - 7.3);
78 return Math.min(1, Math.max(0, sum * 0.5 + 0.5));
79 }
@@ -0,0 +1,79 @@
1/**
2 * World-space tile noise for subtle nature-ground tint (1 sample per tile).
3 * Uses chunk+local indices so adjacent chunks share a continuous field.
4 */
5
6import { CHUNK_SIZE } from "../protocol/constants.js";
7
8/** Locked look from playtest (scale / contrast / tint / darken). */
9export const NATURE_TINT = Object.freeze({
10 scale: 0.17,
11 contrast: 1.65,
12 tint: 0.31,
13 darken: 0.16
14});
15
16/** Shader uniforms for atlas nature tint (ground only). */
17export function natureTintUniforms ()
18{
19 return {
20 u_useNature: 1,
21 u_natureTint: NATURE_TINT.tint,
22 u_natureDark: NATURE_TINT.darken,
23 u_natureContrast: NATURE_TINT.contrast
24 };
25}
26
27/** Noise texture includes a 1-tile halo so soft blend crosses chunk edges. */
28export const NATURE_NOISE_PAD = 1;
29export const NATURE_NOISE_SIZE = CHUNK_SIZE + NATURE_NOISE_PAD * 2;
30
31function fade (t)
32{
33 return t * t * t * (t * (t * 6 - 15) + 10);
34}
35
36function lerp (a, b, t)
37{
38 return a + (b - a) * t;
39}
40
41function hash2 (ix, iy)
42{
43 const n = Math.sin(ix * 127.1 + iy * 311.7) * 43758.5453123;
44 return n - Math.floor(n);
45}
46
47/** Gradient-style value at integer lattice. */
48function gradDot (ix, iy, x, y)
49{
50 const angle = hash2(ix, iy) * Math.PI * 2;
51 return Math.cos(angle) * x + Math.sin(angle) * y;
52}
53
54/** Classic 2D Perlin in roughly [-1, 1]. */
55export function perlin2 (x, y)
56{
57 const x0 = Math.floor(x);
58 const y0 = Math.floor(y);
59 const fx = x - x0;
60 const fy = y - y0;
61 const u = fade(fx);
62 const v = fade(fy);
63 const n00 = gradDot(x0, y0, fx, fy);
64 const n10 = gradDot(x0 + 1, y0, fx - 1, fy);
65 const n01 = gradDot(x0, y0 + 1, fx, fy - 1);
66 const n11 = gradDot(x0 + 1, y0 + 1, fx - 1, fy - 1);
67 return lerp(lerp(n00, n10, u), lerp(n01, n11, u), v);
68}
69
70/** 0..1 FBM of Perlin (2 octaves — cheap for 18×18 fills). */
71export function natureNoise01 (worldTileX, worldTileY, scale = NATURE_TINT.scale)
72{
73 const s = Math.max(0.001, Number(scale) || NATURE_TINT.scale);
74 const x = worldTileX * s;
75 const y = worldTileY * s;
76 let sum = perlin2(x, y);
77 sum += 0.5 * perlin2(x * 2.0 + 19.1, y * 2.0 - 7.3);
78 return Math.min(1, Math.max(0, sum * 0.5 + 0.5));
79}