BlueGit

timfa questward

Perf: render water/lava at true 16×16 via per-chunk atlases.

Stop re-assigning static water/lava debug uniforms every frame; apply them
once when the shader uniform bag is created. Draw liquid water and lava
(plus lava bloom) into CHUNK_SIZE×16 FBOs with the existing shaders, hide
per-tile fluid sprites, and nearest-upscale one atlas GameObject per chunk
so the pixel look stays the same at far lower fragment cost.

timfa Tim Falken · pushed by timfa

Authored 2026-09-13 · 2 months ago

Hash
8eff65f82016b14c175791054c89d4c9ffd2ff04
Parent
98ea78ec
2 files changed +419 −5
client/src/render/fluidChunkAtlas.js added +171 −0
@@ -0,0 +1,171 @@
1 /**
2 * Per-chunk fluid (water / lava) atlas: render procedural shaders at true
3 * SPRITE_SIZE_PX, then nearest-upscale the atlas to chunk world size.
4 *
5 * FBO textures use WebGL's bottom-left origin; Framework HTML uploads use
6 * UNPACK_FLIP_Y=false (image top → v=0). Tile centers are Y-flipped so the
7 * displayed atlas matches world orientation without mirrorY.
8 */
9 import { CHUNK_SIZE, SPRITE_SIZE_PX } from "/shared/protocol/constants.js";
10 import { frameworkImageFromCanvas } from "./canvasSprite.js";
11
12 export const FLUID_ATLAS_PX = CHUNK_SIZE * SPRITE_SIZE_PX;
13
14 /**
15 * @param {import("../../frameworkv3/framework/engine/gl/glContext.js").default | object} glCtx
16 * @returns {{ canvas: HTMLCanvasElement, tex: WebGLTexture, fb: WebGLFramebuffer, image: object, size: number } | null}
17 */
18 export function createFluidAtlasTarget (glCtx)
19 {
20 const gl = glCtx?.gl;
21 if (!gl)
22 { return null; }
23 const size = FLUID_ATLAS_PX;
24 const canvas = document.createElement("canvas");
25 canvas.width = size;
26 canvas.height = size;
27
28 const tex = gl.createTexture();
29 gl.bindTexture(gl.TEXTURE_2D, tex);
30 gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
31 gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
32 gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
33 gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
34 gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, size, size, 0, gl.RGBA, gl.UNSIGNED_BYTE, null);
35
36 // Seed WeakMap so Framework getTexture(canvas) returns this FBO color attachment.
37 glCtx.textures.set(canvas, tex);
38
39 const fb = gl.createFramebuffer();
40 gl.bindFramebuffer(gl.FRAMEBUFFER, fb);
41 gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, tex, 0);
42 const status = gl.checkFramebufferStatus(gl.FRAMEBUFFER);
43 gl.bindFramebuffer(gl.FRAMEBUFFER, null);
44 if (status !== gl.FRAMEBUFFER_COMPLETE)
45 {
46 gl.deleteFramebuffer(fb);
47 gl.deleteTexture(tex);
48 glCtx.textures.delete(canvas);
49 return null;
50 }
51
52 return {
53 canvas,
54 tex,
55 fb,
56 image: frameworkImageFromCanvas(canvas),
57 size
58 };
59 }
60
61 export function destroyFluidAtlasTarget (glCtx, target)
62 {
63 if (!target)
64 { return; }
65 const gl = glCtx?.gl;
66 if (gl)
67 {
68 if (target.fb)
69 { gl.deleteFramebuffer(target.fb); }
70 if (target.tex)
71 { gl.deleteTexture(target.tex); }
72 }
73 if (glCtx?.textures && target.canvas)
74 { glCtx.textures.delete(target.canvas); }
75 target.fb = null;
76 target.tex = null;
77 }
78
79 /**
80 * Bind atlas FBO, clear transparent, run drawFn with drawSprite matrix sized to atlas.
81 * Restores framebuffer, viewport, and _lastWidth/_lastHeight.
82 */
83 export function withFluidAtlasPass (glCtx, target, drawFn)
84 {
85 const gl = glCtx?.gl;
86 if (!gl || !target?.fb)
87 { return; }
88 const prevFb = gl.getParameter(gl.FRAMEBUFFER_BINDING);
89 const prevViewport = gl.getParameter(gl.VIEWPORT);
90 const prevW = glCtx._lastWidth;
91 const prevH = glCtx._lastHeight;
92 const prevBlend = gl.isEnabled(gl.BLEND);
93 try
94 {
95 glCtx._lastWidth = target.size;
96 glCtx._lastHeight = target.size;
97 gl.bindFramebuffer(gl.FRAMEBUFFER, target.fb);
98 gl.viewport(0, 0, target.size, target.size);
99 gl.enable(gl.BLEND);
100 gl.blendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA);
101 gl.clearColor(0, 0, 0, 0);
102 gl.clear(gl.COLOR_BUFFER_BIT);
103 drawFn();
104 }
105 finally
106 {
107 glCtx._lastWidth = prevW;
108 glCtx._lastHeight = prevH;
109 gl.bindFramebuffer(gl.FRAMEBUFFER, prevFb);
110 gl.viewport(prevViewport[0], prevViewport[1], prevViewport[2], prevViewport[3]);
111 if (!prevBlend)
112 { gl.disable(gl.BLEND); }
113 gl.blendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA);
114 }
115 }
116
117 /** Pixel-space center of a chunk-local tile inside the FBO (Y-flipped). */
118 export function fluidAtlasTileCenter (localX, localY)
119 {
120 return {
121 x: localX * SPRITE_SIZE_PX + SPRITE_SIZE_PX / 2,
122 y: (CHUNK_SIZE - 1 - localY) * SPRITE_SIZE_PX + SPRITE_SIZE_PX / 2
123 };
124 }
125
126 /**
127 * Draw one fluid tile into the currently bound atlas pass.
128 * @param {object} glCtx
129 * @param {{
130 * textureHtml: TexImageSource,
131 * secondaryHtml?: TexImageSource | null,
132 * localX: number,
133 * localY: number,
134 * shader: object,
135 * uniforms: object,
136 * uvRect?: { u0: number, v0: number, u1: number, v1: number } | null
137 * }} opts
138 */
139 export function drawFluidAtlasTile (glCtx, {
140 textureHtml,
141 secondaryHtml = null,
142 localX,
143 localY,
144 shader,
145 uniforms,
146 uvRect = null
147 })
148 {
149 if (!textureHtml || !shader)
150 { return; }
151 const center = fluidAtlasTileCenter(localX, localY);
152 const textures = secondaryHtml
153 ? { u_secondary: glCtx.getTexture(secondaryHtml) }
154 : null;
155 glCtx.drawSprite({
156 texture: glCtx.getTexture(textureHtml),
157 x: center.x,
158 y: center.y,
159 w: SPRITE_SIZE_PX,
160 h: SPRITE_SIZE_PX,
161 rotationDeg: 0,
162 mirrorX: false,
163 mirrorY: false,
164 alpha: 1,
165 uvRect: uvRect ?? { u0: 0, v0: 0, u1: 1, v1: 1 },
166 shader,
167 uniforms,
168 textures,
169 lights: null
170 });
171 }
@@ -0,0 +1,171 @@
1/**
2 * Per-chunk fluid (water / lava) atlas: render procedural shaders at true
3 * SPRITE_SIZE_PX, then nearest-upscale the atlas to chunk world size.
4 *
5 * FBO textures use WebGL's bottom-left origin; Framework HTML uploads use
6 * UNPACK_FLIP_Y=false (image top → v=0). Tile centers are Y-flipped so the
7 * displayed atlas matches world orientation without mirrorY.
8 */
9import { CHUNK_SIZE, SPRITE_SIZE_PX } from "/shared/protocol/constants.js";
10import { frameworkImageFromCanvas } from "./canvasSprite.js";
11
12export const FLUID_ATLAS_PX = CHUNK_SIZE * SPRITE_SIZE_PX;
13
14/**
15 * @param {import("../../frameworkv3/framework/engine/gl/glContext.js").default | object} glCtx
16 * @returns {{ canvas: HTMLCanvasElement, tex: WebGLTexture, fb: WebGLFramebuffer, image: object, size: number } | null}
17 */
18export function createFluidAtlasTarget (glCtx)
19{
20 const gl = glCtx?.gl;
21 if (!gl)
22 { return null; }
23 const size = FLUID_ATLAS_PX;
24 const canvas = document.createElement("canvas");
25 canvas.width = size;
26 canvas.height = size;
27
28 const tex = gl.createTexture();
29 gl.bindTexture(gl.TEXTURE_2D, tex);
30 gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
31 gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
32 gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
33 gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
34 gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, size, size, 0, gl.RGBA, gl.UNSIGNED_BYTE, null);
35
36 // Seed WeakMap so Framework getTexture(canvas) returns this FBO color attachment.
37 glCtx.textures.set(canvas, tex);
38
39 const fb = gl.createFramebuffer();
40 gl.bindFramebuffer(gl.FRAMEBUFFER, fb);
41 gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, tex, 0);
42 const status = gl.checkFramebufferStatus(gl.FRAMEBUFFER);
43 gl.bindFramebuffer(gl.FRAMEBUFFER, null);
44 if (status !== gl.FRAMEBUFFER_COMPLETE)
45 {
46 gl.deleteFramebuffer(fb);
47 gl.deleteTexture(tex);
48 glCtx.textures.delete(canvas);
49 return null;
50 }
51
52 return {
53 canvas,
54 tex,
55 fb,
56 image: frameworkImageFromCanvas(canvas),
57 size
58 };
59}
60
61export function destroyFluidAtlasTarget (glCtx, target)
62{
63 if (!target)
64 { return; }
65 const gl = glCtx?.gl;
66 if (gl)
67 {
68 if (target.fb)
69 { gl.deleteFramebuffer(target.fb); }
70 if (target.tex)
71 { gl.deleteTexture(target.tex); }
72 }
73 if (glCtx?.textures && target.canvas)
74 { glCtx.textures.delete(target.canvas); }
75 target.fb = null;
76 target.tex = null;
77}
78
79/**
80 * Bind atlas FBO, clear transparent, run drawFn with drawSprite matrix sized to atlas.
81 * Restores framebuffer, viewport, and _lastWidth/_lastHeight.
82 */
83export function withFluidAtlasPass (glCtx, target, drawFn)
84{
85 const gl = glCtx?.gl;
86 if (!gl || !target?.fb)
87 { return; }
88 const prevFb = gl.getParameter(gl.FRAMEBUFFER_BINDING);
89 const prevViewport = gl.getParameter(gl.VIEWPORT);
90 const prevW = glCtx._lastWidth;
91 const prevH = glCtx._lastHeight;
92 const prevBlend = gl.isEnabled(gl.BLEND);
93 try
94 {
95 glCtx._lastWidth = target.size;
96 glCtx._lastHeight = target.size;
97 gl.bindFramebuffer(gl.FRAMEBUFFER, target.fb);
98 gl.viewport(0, 0, target.size, target.size);
99 gl.enable(gl.BLEND);
100 gl.blendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA);
101 gl.clearColor(0, 0, 0, 0);
102 gl.clear(gl.COLOR_BUFFER_BIT);
103 drawFn();
104 }
105 finally
106 {
107 glCtx._lastWidth = prevW;
108 glCtx._lastHeight = prevH;
109 gl.bindFramebuffer(gl.FRAMEBUFFER, prevFb);
110 gl.viewport(prevViewport[0], prevViewport[1], prevViewport[2], prevViewport[3]);
111 if (!prevBlend)
112 { gl.disable(gl.BLEND); }
113 gl.blendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA);
114 }
115}
116
117/** Pixel-space center of a chunk-local tile inside the FBO (Y-flipped). */
118export function fluidAtlasTileCenter (localX, localY)
119{
120 return {
121 x: localX * SPRITE_SIZE_PX + SPRITE_SIZE_PX / 2,
122 y: (CHUNK_SIZE - 1 - localY) * SPRITE_SIZE_PX + SPRITE_SIZE_PX / 2
123 };
124}
125
126/**
127 * Draw one fluid tile into the currently bound atlas pass.
128 * @param {object} glCtx
129 * @param {{
130 * textureHtml: TexImageSource,
131 * secondaryHtml?: TexImageSource | null,
132 * localX: number,
133 * localY: number,
134 * shader: object,
135 * uniforms: object,
136 * uvRect?: { u0: number, v0: number, u1: number, v1: number } | null
137 * }} opts
138 */
139export function drawFluidAtlasTile (glCtx, {
140 textureHtml,
141 secondaryHtml = null,
142 localX,
143 localY,
144 shader,
145 uniforms,
146 uvRect = null
147})
148{
149 if (!textureHtml || !shader)
150 { return; }
151 const center = fluidAtlasTileCenter(localX, localY);
152 const textures = secondaryHtml
153 ? { u_secondary: glCtx.getTexture(secondaryHtml) }
154 : null;
155 glCtx.drawSprite({
156 texture: glCtx.getTexture(textureHtml),
157 x: center.x,
158 y: center.y,
159 w: SPRITE_SIZE_PX,
160 h: SPRITE_SIZE_PX,
161 rotationDeg: 0,
162 mirrorX: false,
163 mirrorY: false,
164 alpha: 1,
165 uvRect: uvRect ?? { u0: 0, v0: 0, u1: 1, v1: 1 },
166 shader,
167 uniforms,
168 textures,
169 lights: null
170 });
171}
client/src/render/worldView.js +248 −5
@@ -31,6 +31,13 @@ import
31 31 uploadCanvasTextureRgba
32 32 } from "./canvasSprite.js";
33 33 import { setNearestFilter } from "./sprites.js";
34 import
35 {
36 createFluidAtlasTarget,
37 destroyFluidAtlasTarget,
38 withFluidAtlasPass,
39 drawFluidAtlasTile
40 } from "./fluidChunkAtlas.js";
34 41 import { waterDebugUniforms, lavaDebugUniforms } from "../play/waterDebug.js";
35 42 import { natureNoise01, natureTintUniforms, NATURE_TINT, NATURE_NOISE_SIZE, NATURE_NOISE_PAD } from "/shared/render/natureNoise.js";
36 43 import { SeasonId, seasonIdAt, resolveSeasonalVisualState } from "/shared/world/season.js";
@@ -1058,6 +1065,8 @@ export class WorldView
1058 1065 #playerMoveChunkDy = 0;
1059 1066 /** Reused by {@link #placePivoted} to avoid per-call `new vector()`. */
1060 1067 #placeSizeScratch = new vector(0, 0);
1068 /** When true, water/lava shade into per-chunk 16×16 atlases (set false if FBO init fails). */
1069 #useFluidAtlas = true;
1061 1070
1062 1071 constructor(game, scene, catalog = { grounds: {}, blocks: {} })
1063 1072 {
@@ -3177,6 +3186,8 @@ export class WorldView
3177 3186 this.#setLayer(baked.blockObjects?.[row], this.#depthLayer(rowY, SORT_BLOCK));
3178 3187 }
3179 3188 this.#setLayer(baked.bloomObject, this.#depthLayer(top + chunkPx, SORT_BLOCK));
3189 this.#layoutFluidAtlasObject(baked, "ground");
3190 this.#layoutFluidAtlasObject(baked, "bloom");
3180 3191 }
3181 3192 // Unbaked tile sprites: tall blocks, doors and animated grounds.
3182 3193 for (const objects of this.tiles.values())
@@ -3264,6 +3275,12 @@ export class WorldView
3264 3275 const chunkVisible = this.#rectIntersects(left, top, left + chunkPx, top + chunkPx, bounds);
3265 3276 this.#setRendererVisible(baked.groundObject, chunkVisible);
3266 3277 this.#setRendererVisible(baked.bloomObject, chunkVisible && this.bloomEnabled);
3278 // Fluid atlas objects are shown/hidden in #syncFluidAtlases; keep offscreen ones off.
3279 if (!chunkVisible)
3280 {
3281 this.#setRendererVisible(baked.fluidGroundObject, false);
3282 this.#setRendererVisible(baked.fluidBloomObject, false);
3283 }
3267 3284 baked._inViewport = chunkVisible;
3268 3285 for (let row = 0; row < CHUNK_SIZE; row++)
3269 3286 {
@@ -3281,11 +3298,12 @@ export class WorldView
3281 3298 const top = objects.tileY * size;
3282 3299 const visible = this.#rectIntersects(left, top, left + size, top + size, bounds);
3283 3300 objects._inViewport = visible;
3284 this.#setRendererVisible(objects.ground, visible);
3301 const fluidAtlas = this.#useFluidAtlas && this.#tileUsesFluidAtlas(objects);
3302 this.#setRendererVisible(objects.ground, visible && !fluidAtlas);
3285 3303 this.#setRendererVisible(objects.groundBloom, visible && this.bloomEnabled);
3286 3304 this.#setRendererVisible(objects.block, visible);
3287 3305 this.#setRendererVisible(objects.blockBloom, visible && this.bloomEnabled);
3288 this.#setRendererVisible(objects.lavaBloom, visible && this.bloomEnabled);
3306 this.#setRendererVisible(objects.lavaBloom, visible && this.bloomEnabled && !fluidAtlas);
3289 3307 }
3290 3308 }
3291 3309
@@ -3674,6 +3692,11 @@ export class WorldView
3674 3692 {
3675 3693 renderer.shaderUniforms = {};
3676 3694 renderer._shaderUniformKind = kind;
3695 // Static water/lava tune uniforms — apply once per kind, not every frame.
3696 if (kind === "water")
3697 { Object.assign(renderer.shaderUniforms, waterDebugUniforms()); }
3698 else if (kind === "lava" || kind === "lavaBloom")
3699 { Object.assign(renderer.shaderUniforms, lavaDebugUniforms()); }
3677 3700 }
3678 3701 return renderer.shaderUniforms;
3679 3702 }
@@ -4133,7 +4156,6 @@ export class WorldView
4133 4156 uniforms.u_shoreEdgeSE = shore?.edgeSE ?? 0;
4134 4157 uniforms.u_shoreEdgeSW = shore?.edgeSW ?? 0;
4135 4158 this.#writeUniformVec4(uniforms, "u_shoreUvRect", shoreUv.u0, shoreUv.v0, shoreUv.u1, shoreUv.v1);
4136 Object.assign(uniforms, waterDebugUniforms());
4137 4159 }
4138 4160
4139 4161 /** Liquid water gets coast foam; frozen shallow ice uses the normal lit sprite. Lava is procedural heat. */
@@ -4341,7 +4363,6 @@ export class WorldView
4341 4363 uniforms.u_shoreEdgeSE = shore?.edgeSE ?? 0;
4342 4364 uniforms.u_shoreEdgeSW = shore?.edgeSW ?? 0;
4343 4365 this.#writeUniformVec4(uniforms, "u_shoreUvRect", shoreUv.u0, shoreUv.v0, shoreUv.u1, shoreUv.v1);
4344 Object.assign(uniforms, lavaDebugUniforms());
4345 4366 }
4346 4367
4347 4368 #syncLavaBloomSprite (object, {
@@ -4365,7 +4386,225 @@ export class WorldView
4365 4386 uniforms.u_edgeNW = edges?.nw ?? 0;
4366 4387 uniforms.u_edgeSE = edges?.se ?? 0;
4367 4388 uniforms.u_edgeSW = edges?.sw ?? 0;
4368 Object.assign(uniforms, lavaDebugUniforms());
4389 }
4390
4391 #tileUsesFluidAtlas (objects)
4392 {
4393 if (!objects?.groundTypeId)
4394 { return false; }
4395 if (isLavaGround(objects.groundTypeId))
4396 { return true; }
4397 return isLiquidWaterGround(objects.groundTypeId, this.worldSeason);
4398 }
4399
4400 #ensureFluidAtlasSlot (baked, kind)
4401 {
4402 const glCtx = this.scene?.glContext;
4403 if (!glCtx?.gl || !baked)
4404 { return null; }
4405 const key = kind === "bloom" ? "_fluidBloomTarget" : "_fluidGroundTarget";
4406 const objKey = kind === "bloom" ? "fluidBloomObject" : "fluidGroundObject";
4407 if (!baked[key])
4408 {
4409 const target = createFluidAtlasTarget(glCtx);
4410 if (!target)
4411 {
4412 this.#useFluidAtlas = false;
4413 return null;
4414 }
4415 baked[key] = target;
4416 setNearestFilter(this.scene, target.canvas);
4417 }
4418 const target = baked[key];
4419 if (!baked[objKey])
4420 {
4421 const object = new GameObject(0, 0, target.image, LAYER_GROUND);
4422 if (kind === "bloom")
4423 {
4424 object.renderer.layer = RENDER_LAYER_BLOOM;
4425 }
4426 this.#markUnlit(object);
4427 this.scene.addObject(object);
4428 baked[objKey] = object;
4429 this.#layoutFluidAtlasObject(baked, kind);
4430 }
4431 else if (baked[objKey].renderer)
4432 { baked[objKey].renderer.sprite = target.image; }
4433 return { target, object: baked[objKey] };
4434 }
4435
4436 #layoutFluidAtlasObject (baked, kind = "ground")
4437 {
4438 const object = kind === "bloom" ? baked.fluidBloomObject : baked.fluidGroundObject;
4439 if (!object || baked.chunkX == null || baked.chunkY == null)
4440 { return; }
4441 const size = this.tileSize();
4442 const left = baked.chunkX * CHUNK_SIZE * size;
4443 const top = baked.chunkY * CHUNK_SIZE * size;
4444 const chunkPx = CHUNK_SIZE * size;
4445 object.transform.position.x = left + chunkPx / 2;
4446 object.transform.position.y = top + chunkPx / 2;
4447 object.transform.size = new vector(chunkPx, chunkPx);
4448 if (kind === "bloom")
4449 {
4450 this.#setLayer(object, this.#depthLayer(top + chunkPx, SORT_BLOCK));
4451 object.renderer.layer = RENDER_LAYER_BLOOM;
4452 }
4453 else
4454 { this.#setLayer(object, LAYER_GROUND); }
4455 }
4456
4457 #destroyFluidAtlasSlot (baked)
4458 {
4459 const glCtx = this.scene?.glContext;
4460 if (!baked)
4461 { return; }
4462 baked.fluidGroundObject?.destroy();
4463 baked.fluidGroundObject = null;
4464 baked.fluidBloomObject?.destroy();
4465 baked.fluidBloomObject = null;
4466 destroyFluidAtlasTarget(glCtx, baked._fluidGroundTarget);
4467 destroyFluidAtlasTarget(glCtx, baked._fluidBloomTarget);
4468 baked._fluidGroundTarget = null;
4469 baked._fluidBloomTarget = null;
4470 }
4471
4472 /**
4473 * Render liquid water + lava into per-chunk 16×16 atlases; hide per-tile fluid sprites.
4474 * Lighting/time uniforms stay on the (hidden) tile renderers and are sampled here.
4475 */
4476 #syncFluidAtlases ()
4477 {
4478 if (!this.#useFluidAtlas)
4479 { return; }
4480 const glCtx = this.scene?.glContext;
4481 if (!glCtx?.gl)
4482 { return; }
4483
4484 const byChunk = new Map();
4485 for (const objects of this.tiles.values())
4486 {
4487 if (!objects.ground)
4488 { continue; }
4489 if (!this.#tileUsesFluidAtlas(objects))
4490 { continue; }
4491 // Hide per-tile fluid sprites (keep objects + uniforms for atlas + lighting data).
4492 this.#setRendererVisible(objects.ground, false);
4493 this.#setRendererVisible(objects.lavaBloom, false);
4494 if (objects._inViewport === false)
4495 { continue; }
4496 const key = `${objects.chunkX},${objects.chunkY}`;
4497 let list = byChunk.get(key);
4498 if (!list)
4499 {
4500 list = [];
4501 byChunk.set(key, list);
4502 }
4503 list.push(objects);
4504 }
4505
4506 const active = new Set();
4507 for (const [key, list] of byChunk)
4508 {
4509 const baked = this.bakedChunks.get(key);
4510 if (!baked || baked._inViewport === false)
4511 { continue; }
4512 active.add(key);
4513 this.#renderFluidAtlasChunk(baked, list);
4514 }
4515
4516 for (const baked of this.bakedChunks.values())
4517 {
4518 const key = `${baked.chunkX},${baked.chunkY}`;
4519 if (active.has(key))
4520 { continue; }
4521 this.#setRendererVisible(baked.fluidGroundObject, false);
4522 this.#setRendererVisible(baked.fluidBloomObject, false);
4523 }
4524 }
4525
4526 #showFluidTilesFallback (tileObjects)
4527 {
4528 for (const objects of tileObjects)
4529 {
4530 const vis = objects._inViewport !== false;
4531 this.#setRendererVisible(objects.ground, vis);
4532 this.#setRendererVisible(objects.lavaBloom, vis && this.bloomEnabled);
4533 }
4534 }
4535
4536 #renderFluidAtlasChunk (baked, tileObjects)
4537 {
4538 const glCtx = this.scene?.glContext;
4539 const groundSlot = this.#ensureFluidAtlasSlot(baked, "ground");
4540 if (!groundSlot || !this.#useFluidAtlas)
4541 {
4542 this.#showFluidTilesFallback(tileObjects);
4543 return;
4544 }
4545
4546 const bloomTiles = [];
4547 withFluidAtlasPass(glCtx, groundSlot.target, () =>
4548 {
4549 for (const objects of tileObjects)
4550 {
4551 const renderer = objects.ground?.renderer;
4552 if (!renderer?.shader || !renderer.shaderUniforms || !renderer.sprite?.g_image)
4553 { continue; }
4554 const localX = objects.tileX - baked.chunkX * CHUNK_SIZE;
4555 const localY = objects.tileY - baked.chunkY * CHUNK_SIZE;
4556 drawFluidAtlasTile(glCtx, {
4557 textureHtml: renderer.sprite.g_image,
4558 secondaryHtml: renderer.secondaryMap ?? null,
4559 localX,
4560 localY,
4561 shader: renderer.shader,
4562 uniforms: renderer.shaderUniforms,
4563 uvRect: renderer.sprite.getUvRect?.(renderer.subImage | 0) ?? null
4564 });
4565 if (objects.lavaBloom?.renderer?.shader)
4566 { bloomTiles.push(objects); }
4567 }
4568 });
4569 this.#layoutFluidAtlasObject(baked, "ground");
4570 this.#setRendererVisible(groundSlot.object, true);
4571 setNearestFilter(this.scene, groundSlot.target.canvas);
4572
4573 if (!bloomTiles.length || !this.bloomEnabled)
4574 {
4575 this.#setRendererVisible(baked.fluidBloomObject, false);
4576 return;
4577 }
4578
4579 const bloomSlot = this.#ensureFluidAtlasSlot(baked, "bloom");
4580 if (!bloomSlot || !this.#useFluidAtlas)
4581 { return; }
4582 withFluidAtlasPass(glCtx, bloomSlot.target, () =>
4583 {
4584 for (const objects of bloomTiles)
4585 {
4586 const renderer = objects.lavaBloom?.renderer;
4587 if (!renderer?.shader || !renderer.shaderUniforms)
4588 { continue; }
4589 const tex = renderer.sprite?.g_image ?? objects.ground?.renderer?.sprite?.g_image;
4590 if (!tex)
4591 { continue; }
4592 const localX = objects.tileX - baked.chunkX * CHUNK_SIZE;
4593 const localY = objects.tileY - baked.chunkY * CHUNK_SIZE;
4594 drawFluidAtlasTile(glCtx, {
4595 textureHtml: tex,
4596 secondaryHtml: null,
4597 localX,
4598 localY,
4599 shader: renderer.shader,
4600 uniforms: renderer.shaderUniforms,
4601 uvRect: renderer.sprite?.getUvRect?.(renderer.subImage | 0) ?? null
4602 });
4603 }
4604 });
4605 this.#layoutFluidAtlasObject(baked, "bloom");
4606 this.#setRendererVisible(bloomSlot.object, true);
4607 setNearestFilter(this.scene, bloomSlot.target.canvas);
4369 4608 }
4370 4609
4371 4610 #ambientDarkness ()
@@ -5366,6 +5605,8 @@ export class WorldView
5366 5605 baked.bloomObject.transform.size = new vector(chunkPx, chunkPx);
5367 5606 this.#setLayer(baked.bloomObject, this.#depthLayer(top + chunkPx, SORT_BLOCK));
5368 5607 baked.bloomObject.renderer.layer = RENDER_LAYER_BLOOM;
5608 this.#layoutFluidAtlasObject(baked, "ground");
5609 this.#layoutFluidAtlasObject(baked, "bloom");
5369 5610 }
5370 5611
5371 5612 #destroyBakedChunk (key)
@@ -5374,6 +5615,7 @@ export class WorldView
5374 5615 if (!baked)
5375 5616 { return; }
5376 5617 this.#releaseBakedAtlasRefs(baked);
5618 this.#destroyFluidAtlasSlot(baked);
5377 5619 baked.groundObject?.destroy();
5378 5620 for (const object of baked.blockObjects ?? [])
5379 5621 { object.destroy(); }
@@ -6127,6 +6369,7 @@ export class WorldView
6127 6369 this.#syncLitSprite(objects.ground, objects.shadeAlpha);
6128 6370 }
6129 6371 }
6372 this.#syncFluidAtlases();
6130 6373
6131 6374 for (const item of this.groundItems.values())
6132 6375 {
@@ -31,6 +31,13 @@ import
31 uploadCanvasTextureRgba
31 uploadCanvasTextureRgba
32} from "./canvasSprite.js";
32} from "./canvasSprite.js";
33import { setNearestFilter } from "./sprites.js";
33import { setNearestFilter } from "./sprites.js";
34import
35{
36 createFluidAtlasTarget,
37 destroyFluidAtlasTarget,
38 withFluidAtlasPass,
39 drawFluidAtlasTile
40} from "./fluidChunkAtlas.js";
34import { waterDebugUniforms, lavaDebugUniforms } from "../play/waterDebug.js";
41import { waterDebugUniforms, lavaDebugUniforms } from "../play/waterDebug.js";
35import { natureNoise01, natureTintUniforms, NATURE_TINT, NATURE_NOISE_SIZE, NATURE_NOISE_PAD } from "/shared/render/natureNoise.js";
42import { natureNoise01, natureTintUniforms, NATURE_TINT, NATURE_NOISE_SIZE, NATURE_NOISE_PAD } from "/shared/render/natureNoise.js";
36import { SeasonId, seasonIdAt, resolveSeasonalVisualState } from "/shared/world/season.js";
43import { SeasonId, seasonIdAt, resolveSeasonalVisualState } from "/shared/world/season.js";
@@ -1058,6 +1065,8 @@ export class WorldView
1058 #playerMoveChunkDy = 0;
1065 #playerMoveChunkDy = 0;
1059 /** Reused by {@link #placePivoted} to avoid per-call `new vector()`. */
1066 /** Reused by {@link #placePivoted} to avoid per-call `new vector()`. */
1060 #placeSizeScratch = new vector(0, 0);
1067 #placeSizeScratch = new vector(0, 0);
1068 /** When true, water/lava shade into per-chunk 16×16 atlases (set false if FBO init fails). */
1069 #useFluidAtlas = true;
1061
1070
1062 constructor(game, scene, catalog = { grounds: {}, blocks: {} })
1071 constructor(game, scene, catalog = { grounds: {}, blocks: {} })
1063 {
1072 {
@@ -3177,6 +3186,8 @@ export class WorldView
3177 this.#setLayer(baked.blockObjects?.[row], this.#depthLayer(rowY, SORT_BLOCK));
3186 this.#setLayer(baked.blockObjects?.[row], this.#depthLayer(rowY, SORT_BLOCK));
3178 }
3187 }
3179 this.#setLayer(baked.bloomObject, this.#depthLayer(top + chunkPx, SORT_BLOCK));
3188 this.#setLayer(baked.bloomObject, this.#depthLayer(top + chunkPx, SORT_BLOCK));
3189 this.#layoutFluidAtlasObject(baked, "ground");
3190 this.#layoutFluidAtlasObject(baked, "bloom");
3180 }
3191 }
3181 // Unbaked tile sprites: tall blocks, doors and animated grounds.
3192 // Unbaked tile sprites: tall blocks, doors and animated grounds.
3182 for (const objects of this.tiles.values())
3193 for (const objects of this.tiles.values())
@@ -3264,6 +3275,12 @@ export class WorldView
3264 const chunkVisible = this.#rectIntersects(left, top, left + chunkPx, top + chunkPx, bounds);
3275 const chunkVisible = this.#rectIntersects(left, top, left + chunkPx, top + chunkPx, bounds);
3265 this.#setRendererVisible(baked.groundObject, chunkVisible);
3276 this.#setRendererVisible(baked.groundObject, chunkVisible);
3266 this.#setRendererVisible(baked.bloomObject, chunkVisible && this.bloomEnabled);
3277 this.#setRendererVisible(baked.bloomObject, chunkVisible && this.bloomEnabled);
3278 // Fluid atlas objects are shown/hidden in #syncFluidAtlases; keep offscreen ones off.
3279 if (!chunkVisible)
3280 {
3281 this.#setRendererVisible(baked.fluidGroundObject, false);
3282 this.#setRendererVisible(baked.fluidBloomObject, false);
3283 }
3267 baked._inViewport = chunkVisible;
3284 baked._inViewport = chunkVisible;
3268 for (let row = 0; row < CHUNK_SIZE; row++)
3285 for (let row = 0; row < CHUNK_SIZE; row++)
3269 {
3286 {
@@ -3281,11 +3298,12 @@ export class WorldView
3281 const top = objects.tileY * size;
3298 const top = objects.tileY * size;
3282 const visible = this.#rectIntersects(left, top, left + size, top + size, bounds);
3299 const visible = this.#rectIntersects(left, top, left + size, top + size, bounds);
3283 objects._inViewport = visible;
3300 objects._inViewport = visible;
3284 this.#setRendererVisible(objects.ground, visible);
3301 const fluidAtlas = this.#useFluidAtlas && this.#tileUsesFluidAtlas(objects);
3302 this.#setRendererVisible(objects.ground, visible && !fluidAtlas);
3285 this.#setRendererVisible(objects.groundBloom, visible && this.bloomEnabled);
3303 this.#setRendererVisible(objects.groundBloom, visible && this.bloomEnabled);
3286 this.#setRendererVisible(objects.block, visible);
3304 this.#setRendererVisible(objects.block, visible);
3287 this.#setRendererVisible(objects.blockBloom, visible && this.bloomEnabled);
3305 this.#setRendererVisible(objects.blockBloom, visible && this.bloomEnabled);
3288 this.#setRendererVisible(objects.lavaBloom, visible && this.bloomEnabled);
3306 this.#setRendererVisible(objects.lavaBloom, visible && this.bloomEnabled && !fluidAtlas);
3289 }
3307 }
3290 }
3308 }
3291
3309
@@ -3674,6 +3692,11 @@ export class WorldView
3674 {
3692 {
3675 renderer.shaderUniforms = {};
3693 renderer.shaderUniforms = {};
3676 renderer._shaderUniformKind = kind;
3694 renderer._shaderUniformKind = kind;
3695 // Static water/lava tune uniforms — apply once per kind, not every frame.
3696 if (kind === "water")
3697 { Object.assign(renderer.shaderUniforms, waterDebugUniforms()); }
3698 else if (kind === "lava" || kind === "lavaBloom")
3699 { Object.assign(renderer.shaderUniforms, lavaDebugUniforms()); }
3677 }
3700 }
3678 return renderer.shaderUniforms;
3701 return renderer.shaderUniforms;
3679 }
3702 }
@@ -4133,7 +4156,6 @@ export class WorldView
4133 uniforms.u_shoreEdgeSE = shore?.edgeSE ?? 0;
4156 uniforms.u_shoreEdgeSE = shore?.edgeSE ?? 0;
4134 uniforms.u_shoreEdgeSW = shore?.edgeSW ?? 0;
4157 uniforms.u_shoreEdgeSW = shore?.edgeSW ?? 0;
4135 this.#writeUniformVec4(uniforms, "u_shoreUvRect", shoreUv.u0, shoreUv.v0, shoreUv.u1, shoreUv.v1);
4158 this.#writeUniformVec4(uniforms, "u_shoreUvRect", shoreUv.u0, shoreUv.v0, shoreUv.u1, shoreUv.v1);
4136 Object.assign(uniforms, waterDebugUniforms());
4137 }
4159 }
4138
4160
4139 /** Liquid water gets coast foam; frozen shallow ice uses the normal lit sprite. Lava is procedural heat. */
4161 /** Liquid water gets coast foam; frozen shallow ice uses the normal lit sprite. Lava is procedural heat. */
@@ -4341,7 +4363,6 @@ export class WorldView
4341 uniforms.u_shoreEdgeSE = shore?.edgeSE ?? 0;
4363 uniforms.u_shoreEdgeSE = shore?.edgeSE ?? 0;
4342 uniforms.u_shoreEdgeSW = shore?.edgeSW ?? 0;
4364 uniforms.u_shoreEdgeSW = shore?.edgeSW ?? 0;
4343 this.#writeUniformVec4(uniforms, "u_shoreUvRect", shoreUv.u0, shoreUv.v0, shoreUv.u1, shoreUv.v1);
4365 this.#writeUniformVec4(uniforms, "u_shoreUvRect", shoreUv.u0, shoreUv.v0, shoreUv.u1, shoreUv.v1);
4344 Object.assign(uniforms, lavaDebugUniforms());
4345 }
4366 }
4346
4367
4347 #syncLavaBloomSprite (object, {
4368 #syncLavaBloomSprite (object, {
@@ -4365,7 +4386,225 @@ export class WorldView
4365 uniforms.u_edgeNW = edges?.nw ?? 0;
4386 uniforms.u_edgeNW = edges?.nw ?? 0;
4366 uniforms.u_edgeSE = edges?.se ?? 0;
4387 uniforms.u_edgeSE = edges?.se ?? 0;
4367 uniforms.u_edgeSW = edges?.sw ?? 0;
4388 uniforms.u_edgeSW = edges?.sw ?? 0;
4368 Object.assign(uniforms, lavaDebugUniforms());
4389 }
4390
4391 #tileUsesFluidAtlas (objects)
4392 {
4393 if (!objects?.groundTypeId)
4394 { return false; }
4395 if (isLavaGround(objects.groundTypeId))
4396 { return true; }
4397 return isLiquidWaterGround(objects.groundTypeId, this.worldSeason);
4398 }
4399
4400 #ensureFluidAtlasSlot (baked, kind)
4401 {
4402 const glCtx = this.scene?.glContext;
4403 if (!glCtx?.gl || !baked)
4404 { return null; }
4405 const key = kind === "bloom" ? "_fluidBloomTarget" : "_fluidGroundTarget";
4406 const objKey = kind === "bloom" ? "fluidBloomObject" : "fluidGroundObject";
4407 if (!baked[key])
4408 {
4409 const target = createFluidAtlasTarget(glCtx);
4410 if (!target)
4411 {
4412 this.#useFluidAtlas = false;
4413 return null;
4414 }
4415 baked[key] = target;
4416 setNearestFilter(this.scene, target.canvas);
4417 }
4418 const target = baked[key];
4419 if (!baked[objKey])
4420 {
4421 const object = new GameObject(0, 0, target.image, LAYER_GROUND);
4422 if (kind === "bloom")
4423 {
4424 object.renderer.layer = RENDER_LAYER_BLOOM;
4425 }
4426 this.#markUnlit(object);
4427 this.scene.addObject(object);
4428 baked[objKey] = object;
4429 this.#layoutFluidAtlasObject(baked, kind);
4430 }
4431 else if (baked[objKey].renderer)
4432 { baked[objKey].renderer.sprite = target.image; }
4433 return { target, object: baked[objKey] };
4434 }
4435
4436 #layoutFluidAtlasObject (baked, kind = "ground")
4437 {
4438 const object = kind === "bloom" ? baked.fluidBloomObject : baked.fluidGroundObject;
4439 if (!object || baked.chunkX == null || baked.chunkY == null)
4440 { return; }
4441 const size = this.tileSize();
4442 const left = baked.chunkX * CHUNK_SIZE * size;
4443 const top = baked.chunkY * CHUNK_SIZE * size;
4444 const chunkPx = CHUNK_SIZE * size;
4445 object.transform.position.x = left + chunkPx / 2;
4446 object.transform.position.y = top + chunkPx / 2;
4447 object.transform.size = new vector(chunkPx, chunkPx);
4448 if (kind === "bloom")
4449 {
4450 this.#setLayer(object, this.#depthLayer(top + chunkPx, SORT_BLOCK));
4451 object.renderer.layer = RENDER_LAYER_BLOOM;
4452 }
4453 else
4454 { this.#setLayer(object, LAYER_GROUND); }
4455 }
4456
4457 #destroyFluidAtlasSlot (baked)
4458 {
4459 const glCtx = this.scene?.glContext;
4460 if (!baked)
4461 { return; }
4462 baked.fluidGroundObject?.destroy();
4463 baked.fluidGroundObject = null;
4464 baked.fluidBloomObject?.destroy();
4465 baked.fluidBloomObject = null;
4466 destroyFluidAtlasTarget(glCtx, baked._fluidGroundTarget);
4467 destroyFluidAtlasTarget(glCtx, baked._fluidBloomTarget);
4468 baked._fluidGroundTarget = null;
4469 baked._fluidBloomTarget = null;
4470 }
4471
4472 /**
4473 * Render liquid water + lava into per-chunk 16×16 atlases; hide per-tile fluid sprites.
4474 * Lighting/time uniforms stay on the (hidden) tile renderers and are sampled here.
4475 */
4476 #syncFluidAtlases ()
4477 {
4478 if (!this.#useFluidAtlas)
4479 { return; }
4480 const glCtx = this.scene?.glContext;
4481 if (!glCtx?.gl)
4482 { return; }
4483
4484 const byChunk = new Map();
4485 for (const objects of this.tiles.values())
4486 {
4487 if (!objects.ground)
4488 { continue; }
4489 if (!this.#tileUsesFluidAtlas(objects))
4490 { continue; }
4491 // Hide per-tile fluid sprites (keep objects + uniforms for atlas + lighting data).
4492 this.#setRendererVisible(objects.ground, false);
4493 this.#setRendererVisible(objects.lavaBloom, false);
4494 if (objects._inViewport === false)
4495 { continue; }
4496 const key = `${objects.chunkX},${objects.chunkY}`;
4497 let list = byChunk.get(key);
4498 if (!list)
4499 {
4500 list = [];
4501 byChunk.set(key, list);
4502 }
4503 list.push(objects);
4504 }
4505
4506 const active = new Set();
4507 for (const [key, list] of byChunk)
4508 {
4509 const baked = this.bakedChunks.get(key);
4510 if (!baked || baked._inViewport === false)
4511 { continue; }
4512 active.add(key);
4513 this.#renderFluidAtlasChunk(baked, list);
4514 }
4515
4516 for (const baked of this.bakedChunks.values())
4517 {
4518 const key = `${baked.chunkX},${baked.chunkY}`;
4519 if (active.has(key))
4520 { continue; }
4521 this.#setRendererVisible(baked.fluidGroundObject, false);
4522 this.#setRendererVisible(baked.fluidBloomObject, false);
4523 }
4524 }
4525
4526 #showFluidTilesFallback (tileObjects)
4527 {
4528 for (const objects of tileObjects)
4529 {
4530 const vis = objects._inViewport !== false;
4531 this.#setRendererVisible(objects.ground, vis);
4532 this.#setRendererVisible(objects.lavaBloom, vis && this.bloomEnabled);
4533 }
4534 }
4535
4536 #renderFluidAtlasChunk (baked, tileObjects)
4537 {
4538 const glCtx = this.scene?.glContext;
4539 const groundSlot = this.#ensureFluidAtlasSlot(baked, "ground");
4540 if (!groundSlot || !this.#useFluidAtlas)
4541 {
4542 this.#showFluidTilesFallback(tileObjects);
4543 return;
4544 }
4545
4546 const bloomTiles = [];
4547 withFluidAtlasPass(glCtx, groundSlot.target, () =>
4548 {
4549 for (const objects of tileObjects)
4550 {
4551 const renderer = objects.ground?.renderer;
4552 if (!renderer?.shader || !renderer.shaderUniforms || !renderer.sprite?.g_image)
4553 { continue; }
4554 const localX = objects.tileX - baked.chunkX * CHUNK_SIZE;
4555 const localY = objects.tileY - baked.chunkY * CHUNK_SIZE;
4556 drawFluidAtlasTile(glCtx, {
4557 textureHtml: renderer.sprite.g_image,
4558 secondaryHtml: renderer.secondaryMap ?? null,
4559 localX,
4560 localY,
4561 shader: renderer.shader,
4562 uniforms: renderer.shaderUniforms,
4563 uvRect: renderer.sprite.getUvRect?.(renderer.subImage | 0) ?? null
4564 });
4565 if (objects.lavaBloom?.renderer?.shader)
4566 { bloomTiles.push(objects); }
4567 }
4568 });
4569 this.#layoutFluidAtlasObject(baked, "ground");
4570 this.#setRendererVisible(groundSlot.object, true);
4571 setNearestFilter(this.scene, groundSlot.target.canvas);
4572
4573 if (!bloomTiles.length || !this.bloomEnabled)
4574 {
4575 this.#setRendererVisible(baked.fluidBloomObject, false);
4576 return;
4577 }
4578
4579 const bloomSlot = this.#ensureFluidAtlasSlot(baked, "bloom");
4580 if (!bloomSlot || !this.#useFluidAtlas)
4581 { return; }
4582 withFluidAtlasPass(glCtx, bloomSlot.target, () =>
4583 {
4584 for (const objects of bloomTiles)
4585 {
4586 const renderer = objects.lavaBloom?.renderer;
4587 if (!renderer?.shader || !renderer.shaderUniforms)
4588 { continue; }
4589 const tex = renderer.sprite?.g_image ?? objects.ground?.renderer?.sprite?.g_image;
4590 if (!tex)
4591 { continue; }
4592 const localX = objects.tileX - baked.chunkX * CHUNK_SIZE;
4593 const localY = objects.tileY - baked.chunkY * CHUNK_SIZE;
4594 drawFluidAtlasTile(glCtx, {
4595 textureHtml: tex,
4596 secondaryHtml: null,
4597 localX,
4598 localY,
4599 shader: renderer.shader,
4600 uniforms: renderer.shaderUniforms,
4601 uvRect: renderer.sprite?.getUvRect?.(renderer.subImage | 0) ?? null
4602 });
4603 }
4604 });
4605 this.#layoutFluidAtlasObject(baked, "bloom");
4606 this.#setRendererVisible(bloomSlot.object, true);
4607 setNearestFilter(this.scene, bloomSlot.target.canvas);
4369 }
4608 }
4370
4609
4371 #ambientDarkness ()
4610 #ambientDarkness ()
@@ -5366,6 +5605,8 @@ export class WorldView
5366 baked.bloomObject.transform.size = new vector(chunkPx, chunkPx);
5605 baked.bloomObject.transform.size = new vector(chunkPx, chunkPx);
5367 this.#setLayer(baked.bloomObject, this.#depthLayer(top + chunkPx, SORT_BLOCK));
5606 this.#setLayer(baked.bloomObject, this.#depthLayer(top + chunkPx, SORT_BLOCK));
5368 baked.bloomObject.renderer.layer = RENDER_LAYER_BLOOM;
5607 baked.bloomObject.renderer.layer = RENDER_LAYER_BLOOM;
5608 this.#layoutFluidAtlasObject(baked, "ground");
5609 this.#layoutFluidAtlasObject(baked, "bloom");
5369 }
5610 }
5370
5611
5371 #destroyBakedChunk (key)
5612 #destroyBakedChunk (key)
@@ -5374,6 +5615,7 @@ export class WorldView
5374 if (!baked)
5615 if (!baked)
5375 { return; }
5616 { return; }
5376 this.#releaseBakedAtlasRefs(baked);
5617 this.#releaseBakedAtlasRefs(baked);
5618 this.#destroyFluidAtlasSlot(baked);
5377 baked.groundObject?.destroy();
5619 baked.groundObject?.destroy();
5378 for (const object of baked.blockObjects ?? [])
5620 for (const object of baked.blockObjects ?? [])
5379 { object.destroy(); }
5621 { object.destroy(); }
@@ -6127,6 +6369,7 @@ export class WorldView
6127 this.#syncLitSprite(objects.ground, objects.shadeAlpha);
6369 this.#syncLitSprite(objects.ground, objects.shadeAlpha);
6128 }
6370 }
6129 }
6371 }
6372 this.#syncFluidAtlases();
6130
6373
6131 for (const item of this.groundItems.values())
6374 for (const item of this.groundItems.values())
6132 {
6375 {