acdream/src/AcDream.App/Rendering/Wb/FoliageWindClassification.cs

using AcDream.Core.Meshing;
using AcDream.Core.World;

namespace AcDream.App.Rendering.Wb;

/// <summary>
/// Campaign VM VM6: the two <c>BatchData.flags</c> bits that mark a world
/// draw batch as swaying foliage — bit 0 remains #226's built-mesh marker
/// (see <c>mesh_detail.frag</c>'s <c>vBatchFlags &amp; 1u</c> check) and is
/// never touched here. <c>mesh_atmospheric.vert</c> and the four
/// <c>directional_shadow_world_*.vert</c> caster shaders read these bits
/// through the shared <c>foliage_wind.glsl</c> include
/// (<c>acdreamFoliageDisplace</c>'s <c>batchFlags &amp; 0x6u</c> gate); the
/// retail <c>mesh_modern</c> pipelines never read them, so setting them does
/// not change pack-off output.
/// </summary>
internal static class FoliageWindClassification
{
    /// <summary>
    /// Bit 1: the subset is an alpha-cutout/ClipMap material AND its owning
    /// entity is procedural scenery (see <see cref="Classify"/>). Leaves,
    /// fronds, bushes, grass tufts.
    /// </summary>
    internal const uint CutoutFoliageFlag = 0x2u;

    /// <summary>
    /// Bit 2: the subset is opaque AND its owning entity is procedural
    /// scenery AND that same entity owns at least one cutout subset — a
    /// tree trunk or branch, not a rock (rocks have no cutout subset).
    /// </summary>
    internal const uint TrunkFlag = 0x4u;

    /// <summary>
    /// Pure classification: no allocation, no scan. <paramref name="meshHasCutoutSubset"/>
    /// is expected to be computed once per GfxObj/Setup mesh and cached with
    /// the mesh record (<see cref="AcDream.App.Rendering.Wb.ObjectRenderData.HasCutoutSubset"/>),
    /// not recomputed per call.
    /// </summary>
    internal static uint Classify(
        uint entityId,
        bool isExcluded,
        TranslucencyKind translucency,
        bool meshHasCutoutSubset)
    {
        if (!IsProceduralScenery(entityId) || isExcluded)
            return 0u;
        if (translucency == TranslucencyKind.ClipMap)
            return CutoutFoliageFlag;
        if (translucency == TranslucencyKind.Opaque && meshHasCutoutSubset)
            return TrunkFlag;
        return 0u;
    }

    /// <summary>
    /// Campaign VM VM6 review fix round (A4): a Setup composite's parts are
    /// separate GfxObjs, each with its own independently-cached
    /// <c>ObjectRenderData.HasCutoutSubset</c> — an opaque trunk part carries
    /// no cutout batches of its own (the leaves are a DIFFERENT part), so
    /// classifying it from only its own <c>HasCutoutSubset</c> never gives
    /// it <see cref="TrunkFlag"/>. Both the world-receiver and
    /// directional-shadow-caster Setup-part walks, and the packed production
    /// classifier, call this ONCE per entity per frame (not per batch) to OR
    /// every currently-resolved part's <c>HasCutoutSubset</c> into one
    /// entity-scoped value before classifying each part against it. Generic
    /// over the caller's own part representation so it needs no dependency
    /// on <c>ObjectRenderData</c> or the mesh adapter — the caller supplies
    /// <paramref name="hasCutoutSubset"/> to look each part's value up
    /// however it already does. Short-circuits on the first
    /// <see langword="true"/>; a part the caller cannot currently resolve
    /// simply contributes nothing (the caller marks the entity incomplete
    /// separately and reclassifies once every part loads).
    ///
    /// <para>Campaign VM VM6 review fix round 2 (F3), round 3 (N5): takes
    /// the would-be-captured value (e.g. the mesh adapter) as an explicit
    /// <typeparamref name="TContext"/> argument to a
    /// <see langword="static"/> lambda instead of letting a caller's lambda
    /// close over an instance field — a closure-capturing lambda would
    /// allocate a fresh closure object AND delegate on every call, and this
    /// runs once per Setup entity per frame from all three production
    /// classifiers. A <see langword="static"/> lambda with no captures lets
    /// the C# compiler cache a single delegate instance for the method's
    /// lifetime instead. Round 3 deleted the single-generic predecessor of
    /// this overload — every call site (production and test) now goes
    /// through this one, so there is exactly one
    /// <c>ComputeEntityHasCutoutSubset</c> to keep correct.</para>
    /// </summary>
    internal static bool ComputeEntityHasCutoutSubset<T, TContext>(
        IReadOnlyList<T> setupParts,
        TContext context,
        Func<TContext, T, bool> hasCutoutSubset)
    {
        for (int i = 0; i < setupParts.Count; i++)
        {
            if (hasCutoutSubset(context, setupParts[i]))
                return true;
        }
        return false;
    }

    /// <summary>
    /// The full top-nibble <c>0x8...</c> test via
    /// <see cref="ProceduralSceneryIdAllocator.IsInNamespace"/> — NOT bit 31
    /// alone. Bit 31 alone also matches <c>LandblockStaticEntityIdAllocator</c>'s
    /// <c>0xC...</c> ids (fences, gates, building shells) and the synthetic
    /// render ids <c>0xDA11_D0xx</c> / <c>0xFFFF_FF01</c> — using bit 31
    /// alone here would sway non-scenery objects that happen to have a
    /// cutout subset.
    /// </summary>
    internal static bool IsProceduralScenery(uint entityId) =>
        ProceduralSceneryIdAllocator.IsInNamespace(entityId);
}