fix #426: extract solid-colour (NO_POS_UVS) faces; skip untextured subsets only on building shells and cells like retail

The Holtburg windmill axle (GfxObj 0x010010CE, 8 polygons, all
Stippling.NoPos + SurfaceType.Base1Solid) extracted to a 0-vertex mesh.
NoPos ("NO_POS_UVS", acclient.h:7380-7388) means "this side has no
texture coordinates" — true of every solid-colour polygon, since
nothing samples them — not "there is no positive face". Extraction read
it as the latter and dropped the polygon entirely, client-wide, for
every untextured polygon on every object.

Retail's D3DPolyRender::DrawMesh (@0x0059d4a0, named-retail decomp
~line 426048) draws an untextured subset on an ordinary object exactly
like a textured one; the only retail cases that skip an untextured
subset are a building shell (RenderDeviceD3D::DrawBuilding @0x0059f2a0
sets ObjBuildingOrBuildingPart=1) or an EnvCell interior
(RenderDeviceD3D::DrawEnvCell @0x0059f170, arg4=1). The #119
investigation's "retail's skipNoTexture never draws them either"
conclusion was itself wrong as a general rule.

- MeshExtractor.PrepareGfxObjMeshData / GfxObjMesh.Build: emit the
  positive side whenever PosSurface is a valid index, regardless of
  NoPos; the existing UV-index-0 fallback already produces zero
  texcoords for a NoPos polygon with no UVs on the wire.
- RetailUntexturedSurfacePolicy.IsUntextured(SurfaceType): the one
  place that answers "is this surface textured"
  ((type & (Base1Image|Base1ClipMap)) == 0), replacing the old
  `isSolid = NoPos || Base1Solid` (which also mis-classified a NEG-side
  batch by the POS-side's NoPos flag).
- RetailUntexturedSubsetPolicy.Draws(isBuildingShell, isUntextured):
  the shared draw-time gate wired into WbDrawDispatcher.ClassifyBatches,
  .PackedOracle.ClassifyPackedBatches, and
  .DirectionalShadows.AddDirectionalShadowBatches — one predicate so the
  three walks cannot drift (Campaign VM VM6 lesson).
- CellMesh.cs / MeshExtractor.PrepareCellStructMeshData deliberately
  KEEP their NoPos-gated skip for cell-wall geometry — retail's
  DrawEnvCell really does skip untextured subsets there; register row
  AP-234 documents the NoPos-vs-Surface.Type approximation.
- PakFormat.CurrentBakeToolVersion 4->5 (LauncherInstallRecordStore in
  lockstep): a pak baked by an older tool is missing every untextured
  face. No bake was run as part of this commit.

Also fixed: WorldBuilder's own upstream ObjectMeshManager.cs has the
identical NoPos bug (ObjectMeshManager.cs:959,984) — our port had
faithfully carried it over, and our own conformance test
(Build_NoPosFlag_OnlyEmitsNegSide) asserted the bug as correct WB
conformance. Renamed/reworded to Build_NoPosFlag_EmitsBothPosAndNegSide
with a citation for why retail decomp overrides WB here.

Issue119UpNullGfxObjDumpTests re-run against the installed DAT:
#119's own two objects (0x010002B4 9/9 polys, 0x010008A8 1/1 poly) now
gate DRAWS on every polygon instead of extracting to nothing.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

tests/AcDream.Content.Tests/MeshExtractorSolidFaceExtractionTests.cs

@@ -0,0 +1,294 @@
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using System.Numerics;
+using AcDream.Content;
+using DatReaderWriter;
+using DatReaderWriter.DBObjs;
+using DatReaderWriter.Enums;
+using DatReaderWriter.Lib.IO;
+using DatReaderWriter.Types;
+using Microsoft.Extensions.Logging.Abstractions;
+
+namespace AcDream.Content.Tests;
+
+/// <summary>
+/// #426 (2026-08-23, the Holtburg windmill axle 0x010010CE, 8 polygons all
+/// NoPos + Base1Solid): MeshExtractor.PrepareGfxObjMeshData used to gate the
+/// positive side on <c>!Stippling.NoPos</c>, dropping every solid-colour
+/// polygon on every object client-wide (NoPos means "no positive UVs" —
+/// acclient.h:7386 — not "no positive face"). These tests exercise the fix
+/// through the PUBLIC PrepareMeshData entry point against a synthetic,
+/// entirely in-memory dat graph (no installed DAT directory required — this
+/// lane stays hermetic), using a hand-rolled <see cref="IDatReaderWriter"/> /
+/// <see cref="IDatDatabase"/> pair in the same shape as
+/// DatResolutionPrecedenceTests' ResolutionSource/StubDatabase.
+/// </summary>
+public sealed class MeshExtractorSolidFaceExtractionTests
+{
+    private const uint GfxObjId = 0x01000001u;
+    private const uint SolidSurfaceId = 0x08000001u;
+    private const uint TexturedSurfaceId = 0x08000002u;
+    private const uint SurfaceTextureId = 0x05000001u;
+    private const uint RenderSurfaceId = 0x06000001u;
+
+    /// <summary>
+    /// One quad polygon, NoPos + Base1Solid: the exact shape of the windmill
+    /// axle's own polygons. Must now extract to 4 vertices / 6 indices in a
+    /// single batch flagged solid, instead of the pre-#426 0-vertex mesh.
+    /// </summary>
+    [Fact]
+    public void PrepareMeshData_NoPosSolidQuad_EmitsSolidBatchWithFourVerticesAndSixIndices()
+    {
+        var dats = new FakeMeshExtractorDats();
+        dats.RegisterRootGfxObj(GfxObjId, BuildQuadGfxObj(SolidSurfaceId, noPos: true));
+        var color = new ColorARGB { Alpha = 255, Red = 12, Green = 34, Blue = 56 };
+        dats.Register(SolidSurfaceId, new Surface
+        {
+            Type = SurfaceType.Base1Solid,
+            ColorValue = color,
+        });
+
+        var extractor = new MeshExtractor(dats, NullLogger.Instance, sideStagedSink: null);
+
+        ObjectMeshData? mesh = extractor.PrepareMeshData(GfxObjId, isSetup: false);
+
+        Assert.NotNull(mesh);
+        Assert.Equal(4, mesh!.Vertices.Length);
+        List<TextureBatchData> batches = mesh.TextureBatches.Values.Single();
+        TextureBatchData batch = Assert.Single(batches);
+        Assert.Equal(6, batch.Indices.Count);
+        Assert.True(batch.Key.IsSolid);
+
+        // GetOrCreateSolidColorTexture bakes the surface's own ColorValue.
+        Assert.Equal((byte)color.Red, batch.TextureData[0]);
+        Assert.Equal((byte)color.Green, batch.TextureData[1]);
+        Assert.Equal((byte)color.Blue, batch.TextureData[2]);
+        Assert.Equal((byte)color.Alpha, batch.TextureData[3]);
+    }
+
+    /// <summary>
+    /// Same NoPos quad, but the positive surface is TEXTURED
+    /// (Base1Image) rather than solid. NoPos still means "no UVs on this
+    /// polygon's wire data" regardless of what the surface is — the emitted
+    /// vertices fall back to UV (0,0), and the batch must be classified
+    /// non-solid (IsSolid == false) so it decodes the real texture instead
+    /// of baking a flat colour fill.
+    /// </summary>
+    [Fact]
+    public void PrepareMeshData_NoPosTexturedQuad_EmitsWithZeroUVsAndIsSolidFalse()
+    {
+        var dats = new FakeMeshExtractorDats();
+        dats.RegisterRootGfxObj(GfxObjId, BuildQuadGfxObj(TexturedSurfaceId, noPos: true));
+        dats.Register(TexturedSurfaceId, new Surface
+        {
+            Type = SurfaceType.Base1Image,
+            OrigTextureId = SurfaceTextureId,
+        });
+        dats.Register(SurfaceTextureId, new SurfaceTexture
+        {
+            Textures = new List<QualifiedDataId<RenderSurface>> { RenderSurfaceId },
+        });
+        dats.Register(RenderSurfaceId, new RenderSurface
+        {
+            Width = 1,
+            Height = 1,
+            Format = PixelFormat.PFID_A8R8G8B8,
+            SourceData = new byte[] { 10, 20, 30, 255 },
+        });
+
+        var extractor = new MeshExtractor(dats, NullLogger.Instance, sideStagedSink: null);
+
+        ObjectMeshData? mesh = extractor.PrepareMeshData(GfxObjId, isSetup: false);
+
+        Assert.NotNull(mesh);
+        Assert.Equal(4, mesh!.Vertices.Length);
+        Assert.All(mesh.Vertices, v => Assert.Equal(Vector2.Zero, v.UV));
+
+        List<TextureBatchData> batches = mesh.TextureBatches.Values.Single();
+        TextureBatchData batch = Assert.Single(batches);
+        Assert.Equal(6, batch.Indices.Count);
+        Assert.False(batch.Key.IsSolid);
+    }
+
+    /// <summary>One quad (4 verts), single polygon, PosSurface referencing <paramref name="surfaceId"/>.</summary>
+    private static GfxObj BuildQuadGfxObj(uint surfaceId, bool noPos)
+    {
+        return new GfxObj
+        {
+            Surfaces = { surfaceId },
+            VertexArray = new VertexArray
+            {
+                Vertices =
+                {
+                    // No UVs at all — matches a real NoPos polygon's vertices,
+                    // which carry no UV entries because nothing samples them.
+                    [0] = new SWVertex { Origin = new Vector3(0, 0, 0), Normal = Vector3.UnitZ },
+                    [1] = new SWVertex { Origin = new Vector3(1, 0, 0), Normal = Vector3.UnitZ },
+                    [2] = new SWVertex { Origin = new Vector3(1, 1, 0), Normal = Vector3.UnitZ },
+                    [3] = new SWVertex { Origin = new Vector3(0, 1, 0), Normal = Vector3.UnitZ },
+                },
+            },
+            Polygons =
+            {
+                [0] = new Polygon
+                {
+                    Stippling = noPos ? StipplingType.NoPos : default,
+                    PosSurface = 0,
+                    NegSurface = -1,
+                    VertexIds = { 0, 1, 2, 3 },
+                },
+            },
+        };
+    }
+
+    /// <summary>
+    /// Minimal in-memory <see cref="IDatReaderWriter"/> for MeshExtractor:
+    /// resolves exactly one "root" GfxObj through Portal (the only path
+    /// PrepareMeshData needs for TryResolvePreferred's default
+    /// implementation), plus arbitrary typed lookups (Surface,
+    /// SurfaceTexture, RenderSurface) also through Portal.
+    /// </summary>
+    private sealed class FakeMeshExtractorDats : IDatReaderWriter
+    {
+        private readonly Dictionary<uint, IDBObj> _portalObjects = new();
+        private uint _rootId;
+
+        public FakeMeshExtractorDats() => Portal = new FakeDatDatabase(_portalObjects);
+
+        public void RegisterRootGfxObj(uint id, GfxObj gfxObj)
+        {
+            _rootId = id;
+            _portalObjects[id] = gfxObj;
+        }
+
+        public void Register<T>(uint id, T obj) where T : IDBObj => _portalObjects[id] = obj;
+
+        public string SourceDirectory => string.Empty;
+        public IDatDatabase Portal { get; }
+        public IDatDatabase Cell => EmptyDatDatabase.Instance;
+        public ReadOnlyDictionary<uint, IDatDatabase> CellRegions { get; } =
+            new(new Dictionary<uint, IDatDatabase>());
+        public IDatDatabase HighRes => EmptyDatDatabase.Instance;
+        public IDatDatabase Language => EmptyDatDatabase.Instance;
+        public IDatDatabase Local => EmptyDatDatabase.Instance;
+        public ReadOnlyDictionary<uint, uint> RegionFileMap { get; } =
+            new(new Dictionary<uint, uint>());
+        public int PortalIteration => 0;
+        public int CellIteration => 0;
+        public int HighResIteration => 0;
+        public int LanguageIteration => 0;
+
+        public bool TryGetFileBytes(uint regionId, uint fileId, ref byte[] bytes, out int bytesRead)
+        {
+            bytesRead = 0;
+            return false;
+        }
+
+        public IEnumerable<uint> GetAllIdsOfType<T>() where T : IDBObj => Array.Empty<uint>();
+
+        public IEnumerable<IDatReaderWriter.IdResolution> ResolveId(uint id) =>
+            id == _rootId
+                ? new[] { new IDatReaderWriter.IdResolution(Portal, DBObjType.GfxObj) }
+                : Array.Empty<IDatReaderWriter.IdResolution>();
+
+        public bool TrySave<T>(T obj, int iteration = 0) where T : IDBObj =>
+            throw new NotSupportedException();
+
+        public bool TrySave<T>(uint regionId, T obj, int iteration = 0) where T : IDBObj =>
+            throw new NotSupportedException();
+
+        [return: MaybeNull]
+        public T Get<T>(uint fileId) where T : IDBObj =>
+            Portal.TryGet<T>(fileId, out var value) ? value : default;
+
+        public bool TryGet<T>(uint fileId, [MaybeNullWhen(false)] out T value) where T : IDBObj =>
+            Portal.TryGet(fileId, out value);
+
+        public void Dispose()
+        {
+        }
+    }
+
+    private sealed class FakeDatDatabase : IDatDatabase
+    {
+        private readonly Dictionary<uint, IDBObj> _objects;
+
+        public FakeDatDatabase(Dictionary<uint, IDBObj> objects) => _objects = objects;
+
+        // Never dereferenced by MeshExtractor's own code paths (only
+        // RetailPhysicsScriptLoader's ctor reads it, into a NULLABLE field
+        // it never touches unless a physics-script emitter is loaded, which
+        // these tests never trigger).
+        public DatDatabase Db => null!;
+        public int Iteration => 0;
+
+        public IEnumerable<uint> GetAllIdsOfType<T>() where T : IDBObj => Array.Empty<uint>();
+
+        public bool TryGet<T>(uint fileId, [MaybeNullWhen(false)] out T value) where T : IDBObj
+        {
+            if (_objects.TryGetValue(fileId, out IDBObj? obj) && obj is T typed)
+            {
+                value = typed;
+                return true;
+            }
+            value = default;
+            return false;
+        }
+
+        public bool TryGetFileBytes(uint fileId, [MaybeNullWhen(false)] out byte[] value)
+        {
+            value = null;
+            return false;
+        }
+
+        public bool TryGetFileBytes(uint fileId, ref byte[] bytes, out int bytesRead)
+        {
+            bytesRead = 0;
+            return false;
+        }
+
+        public bool TrySave<T>(T obj, int iteration = 0) where T : IDBObj =>
+            throw new NotSupportedException();
+
+        public void Dispose()
+        {
+        }
+    }
+
+    private sealed class EmptyDatDatabase : IDatDatabase
+    {
+        public static readonly EmptyDatDatabase Instance = new();
+
+        public DatDatabase Db => null!;
+        public int Iteration => 0;
+
+        public IEnumerable<uint> GetAllIdsOfType<T>() where T : IDBObj => Array.Empty<uint>();
+
+        public bool TryGet<T>(uint fileId, [MaybeNullWhen(false)] out T value) where T : IDBObj
+        {
+            value = default;
+            return false;
+        }
+
+        public bool TryGetFileBytes(uint fileId, [MaybeNullWhen(false)] out byte[] value)
+        {
+            value = null;
+            return false;
+        }
+
+        public bool TryGetFileBytes(uint fileId, ref byte[] bytes, out int bytesRead)
+        {
+            bytesRead = 0;
+            return false;
+        }
+
+        public bool TrySave<T>(T obj, int iteration = 0) where T : IDBObj =>
+            throw new NotSupportedException();
+
+        public void Dispose()
+        {
+        }
+    }
+}