fac0940711
terrain_modern.frag declared `uniform float uTexTiling[36]` - the per-layer
tiling factors retail passes to TexMerge::CopyAndTile / TexMerge::Merge, one per
terrain atlas layer. Vulkan GLSL has no default uniform block, so a loose array
is unspellable there, and 144 bytes of payload cannot ride the pinned 96-byte
push-constant block. GpuBindingModel reserved UniformTerrainTiling (binding 3)
for exactly this at slice V4d. The array now lives in that block.
The ELEMENT TYPE is deliberately unchanged. std140 pads every array element out
to 16 bytes, so the block is 576 bytes rather than 144, and packing four values
per vec4 would be tighter - but it would also rewrite the accessor and every use
site, and this commit's whole value is that its pixel gate measures the move to
a uniform buffer and nothing else. `uTexTiling[int(layer)]` reads exactly as it
did.
That padding is the hazard the change introduces, so it is pinned twice. The CPU
writer walks TerrainTextureTilingTable.UniformElementStrideBytes and zero-fills
the dead words rather than blitting 36 packed floats, and a new test asserts the
stride is 16, the block is 576, and the two are consistent with LayerCapacity. A
tightly-packed writer would not crash or even look obviously wrong: the shader
would read layer 0's factor for layers 0-3, layer 4's for 4-7, and in a scene
where most layers tile at 1 the error stays invisible until a layer that does
not appears. Nothing else in the suite could see that.
The buffer is allocated once in the constructor, through the same
TrackedGlResource + ResourceCleanupGroup rollback path every other terrain
buffer uses, written on the first bound draw - preserving the upload-once
property the linked program's uniform had for free - and released through the
dispose ledger. It is REBOUND every draw rather than once: GL's uniform-buffer
binding points are global and shared with SceneLighting at 1 and the sky's
params at 4, so a renderer running between two terrain draws can take binding 3
out from under us. Self-contained render state, per the standing rule.
Gates. Release build clean. App tests 4,073 passed / 3 skipped - the baseline
4,072 plus the new layout test. Offline pixel gate against 5e13b45f: 21 differing
pixels of 563,200 compared (fraction 3.73e-05), inside the documented 15-23
pixel band and ~27x under the 0.001 threshold. This gate is a real test of the
layout rather than a formality: terrain blending, road overlays and the water
edge are most of the captured frame, and every one of those samples goes through
terrainTiling(), so a stride mismatch would have shown as a wholesale retexture
rather than as noise. The gate run's client log has zero exceptions and an empty
stderr.
Manifest regenerated in the same commit. terrain_modern's remaining Vulkan error
moved from `'uTexTiling' : undeclared identifier` to the frag's direct
`sampler2DArray(...)` construction, which is the same dialect migration V6e ran
for mesh_modern and which lands next. The pair count is unchanged at 7/9.
No divergence-register row: the tiling values, their source and their use are
unchanged, and no retail-facing behaviour moves.
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
59 lines
2.4 KiB
C#
59 lines
2.4 KiB
C#
namespace AcDream.App.Rendering;
|
|
|
|
/// <summary>
|
|
/// Builds the layer-indexed adapter table consumed by
|
|
/// <c>terrain_modern.frag</c>. Retail passes <c>TerrainTex::tex_tiling</c>
|
|
/// directly to <c>ImgTex::TileCSI</c> / <c>ImgTex::MergeTexture</c>
|
|
/// (`TexMerge::CopyAndTile` 0x00503580, `TexMerge::Merge` 0x005038C0).
|
|
/// The table is the modern texture-array equivalent of that per-texture
|
|
/// argument.
|
|
/// </summary>
|
|
internal static class TerrainTextureTilingTable
|
|
{
|
|
// WorldBuilder's extracted terrain-array path uses the same 36-layer
|
|
// contract. Packed terrain layer indices are validated against this
|
|
// capacity before the shader table is built.
|
|
internal const int LayerCapacity = 36;
|
|
|
|
/// <summary>
|
|
/// std140 stride of one <c>float</c> in the shader's <c>uTexTiling</c> array.
|
|
/// std140 pads every array element out to 16 bytes, which is why the block is
|
|
/// 576 bytes rather than the 144 the payload occupies. Packing four values
|
|
/// per <c>vec4</c> would be tighter but would change the shader's use site;
|
|
/// keeping the element type means <c>uTexTiling[int(layer)]</c> reads exactly
|
|
/// as it did when the array was a loose uniform.
|
|
/// </summary>
|
|
internal const int UniformElementStrideBytes = 16;
|
|
|
|
/// <summary>
|
|
/// Size of the <c>TerrainTiling</c> uniform buffer
|
|
/// (<c>GpuBindingModel.UniformTerrainTiling</c>, binding 3) that has carried
|
|
/// this table since slice V6f-2. Asserted against the stride above rather
|
|
/// than written as a literal, because the two disagreeing is a mismatch only
|
|
/// a wrongly-tiled terrain texture would reveal.
|
|
/// </summary>
|
|
internal const int UniformBufferBytes = LayerCapacity * UniformElementStrideBytes;
|
|
|
|
internal static float[] Build(IEnumerable<(uint Layer, uint RepeatCount)> entries)
|
|
{
|
|
ArgumentNullException.ThrowIfNull(entries);
|
|
|
|
var table = new float[LayerCapacity];
|
|
Array.Fill(table, 1f);
|
|
|
|
foreach (var (layer, repeatCount) in entries)
|
|
{
|
|
if (layer >= LayerCapacity)
|
|
{
|
|
throw new InvalidOperationException(
|
|
$"Terrain atlas layer {layer} exceeds the shader capacity of {LayerCapacity} layers.");
|
|
}
|
|
|
|
// Preserve the dat value exactly. Retail forwards the unsigned
|
|
// field without normalizing it in both CopyAndTile and Merge.
|
|
table[layer] = repeatCount;
|
|
}
|
|
|
|
return table;
|
|
}
|
|
}
|