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.
@@ -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 true3
* 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 use6
* UNPACK_FLIP_Y=false (image top → v=0). Tile centers are Y-flipped so the7
* 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} glCtx16
* @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
size58
};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
try94
{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
finally106
{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 / 2123
};124
}125
126
/**127
* Draw one fluid tile into the currently bound atlas pass.128
* @param {object} glCtx129
* @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 } | null137
* }} opts138
*/139
export function drawFluidAtlasTile (glCtx, {140
textureHtml,141
secondaryHtml = null,142
localX,143
localY,144
shader,145
uniforms,146
uvRect = null147
})148
{149
if (!textureHtml || !shader)150
{ return; }151
const center = fluidAtlasTileCenter(localX, localY);152
const textures = secondaryHtml153
? { 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: null170
});171
}@@ -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 @@ import31
uploadCanvasTextureRgba31
uploadCanvasTextureRgba32
} from "./canvasSprite.js";32
} from "./canvasSprite.js";33
import { setNearestFilter } from "./sprites.js";33
import { setNearestFilter } from "./sprites.js";34
import35
{36
createFluidAtlasTarget,37
destroyFluidAtlasTarget,38
withFluidAtlasPass,39
drawFluidAtlasTile40
} from "./fluidChunkAtlas.js";34
import { waterDebugUniforms, lavaDebugUniforms } from "../play/waterDebug.js";41
import { waterDebugUniforms, lavaDebugUniforms } from "../play/waterDebug.js";35
import { natureNoise01, natureTintUniforms, NATURE_TINT, NATURE_NOISE_SIZE, NATURE_NOISE_PAD } from "/shared/render/natureNoise.js";42
import { natureNoise01, natureTintUniforms, NATURE_TINT, NATURE_NOISE_SIZE, NATURE_NOISE_PAD } from "/shared/render/natureNoise.js";36
import { SeasonId, seasonIdAt, resolveSeasonalVisualState } from "/shared/world/season.js";43
import { SeasonId, seasonIdAt, resolveSeasonalVisualState } from "/shared/world/season.js";@@ -1058,6 +1065,8 @@ export class WorldView1058
#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 WorldView3177
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 WorldView3264
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 WorldView3281
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 WorldView3674
{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 WorldView4133
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 WorldView4341
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 WorldView4365
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
else4454
{ 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) ?? null4564
});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) ?? null4602
});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 WorldView5366
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 WorldView5374
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 WorldView6127
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
{