NX2navi/runtime/vk_fg_pose.inc

// Final submitted pose inputs for owned player models. Replay workers change history under
// the motion-list lock; the submitting thread selects and consumes it after the group finishes.
// Model and shape identities come from producer-side ownership records, never from a mesh fingerprint.
#include "motion_owner.h"
#define POSE_ROWS 256
#define POSE_BYTES (128u * 1024u)
#define POSE_BANKS 5  // c3 through c7
#define POSE_VIEWS 8
typedef struct {
    uint64_t frame, cam, indices;
    VkImage depth;
    const GfxShader *shader;
    NVNbufferRange vertex[16];
    uint64_t bindings[POSE_BANKS];
    uint32_t size[POSE_BANKS], capacity;
    unsigned char *bytes;
    uint32_t width, height;
    int seen, selected, ambiguous;
    int visibility_guard, guard_missing_depth;
} ActorPose;
typedef struct {
    ActorPose view[POSE_VIEWS];
    ActorPose *scene;
} PoseFrame;
typedef struct {
    uint32_t count, width, base, actor;
    uint64_t indices, last_frame;
    MotionOwner owner;
    PoseFrame history[2];
} PoseRange;
static PoseRange pose_ranges[POSE_ROWS];
static int pose_count;
static unsigned pose_seen[3], pose_written[3], pose_missing, pose_full, pose_unowned;

static int pose_enabled(void) { return motion_owner_enabled(); }
static int pose_raw(void) {
    static int raw = -1;
    if (raw < 0) raw = rt_knob("SELECTIVE_MOTION_RAW", "0");
    return raw;
}

static int pose_same_owner(const MotionOwner *a, const MotionOwner *b) {
    return a->player == b->player && a->actor == b->actor && a->link == b->link &&
        a->generation == b->generation && a->model == b->model && a->part == b->part && a->lifetime == b->lifetime &&
        a->flags == b->flags;
}

static void pose_clear(PoseRange *r) {
    for (int j = 0; j < 2; ++j)
        for (int k = 0; k < POSE_VIEWS; ++k) free(r->history[j].view[k].bytes);
    memset(r, 0, sizeof *r);
}

static int pose_owner(VkExec *ex, MotionOwner *out) {
    MotionOwner owner = {0};
    // Only vertex resources consumed by this shader can establish identity. Stale unused bindings cannot.
    const GfxShaderRes *res;
    int nres = gfx_shader_resources(ex->dc->B.st.vs, GFX_RES_UBO, &res);
    for (int j = 0; j < nres; ++j) {
        int bank = res[j].slot;
        if (bank < 3 || bank > 7) continue;
        const p_bind_buf *b = &ex->ubo[NVN_STAGE_VS][bank - 3];
        MotionOwner m;
        if (!vk_usnap_motion_owner(b->addr, b->size, &m)) continue;
        if (owner.model && (owner.model != m.model || owner.lifetime != m.lifetime ||
                           (owner.part && m.part && owner.part != m.part))) return 0;
        if (!owner.model || m.part) owner = m;
    }
    // The per-shape record is required even for skinned meshes; one palette can serve several pieces.
    if (!owner.model || !owner.part) return 0;
    *out = owner;
    return 1;
}

// The caller holds the motion-list lock while parallel replay workers record draws.
static PoseRange *pose_match(VkExec *ex, const p_draw_idx *d, const MotionOwner *identity) {
    MotionOwner owner = *identity;
    uint64_t frame = __atomic_load_n(&gfx_counters.frames, __ATOMIC_RELAXED);
    uint32_t width = d->itype == NVN_INDEX_TYPE_UNSIGNED_SHORT ? 2u : 4u;
    PoseRange *free_row = NULL;
    for (int i = 0; i < pose_count; ++i) {
        PoseRange *r = &pose_ranges[i];
        if (pose_same_owner(&r->owner, &owner) && r->indices == d->ibuf &&
            r->count == (uint32_t)d->count && r->width == width && r->base == (uint32_t)d->base_vertex) {
            r->last_frame = frame;
            ++pose_seen[r->actor];
            return r;
        }
        if (!free_row && r->last_frame + 2 < frame) free_row = r;
    }
    if (pose_count < POSE_ROWS) free_row = &pose_ranges[pose_count++];
    if (!free_row) { ++pose_full; return NULL; }
    pose_clear(free_row);
    free_row->owner = owner;
    free_row->indices = d->ibuf;
    free_row->count = (uint32_t)d->count;
    free_row->width = width;
    free_row->base = (uint32_t)d->base_vertex;
    free_row->actor = owner.kind ? 2 : 1;
    free_row->last_frame = frame;
    ++pose_seen[free_row->actor];
    return free_row;
}

static ActorPose *pose_previous(PoseRange *r, VkExec *ex, const p_draw_idx *d, uint64_t frame, uint32_t banks,
                                ActorPose **candidate) {
    PoseFrame *now = &r->history[frame & 1];
    ActorPose *prev = r->history[(frame & 1) ^ 1].scene;
    uint64_t cam = ex->ubo[NVN_STAGE_VS][0].addr;
    // The same mesh is drawn into several depth targets. Only the resolve knows which view supplies FG.
    ActorPose *cur = NULL;
    for (int i = 0; i < POSE_VIEWS; ++i) {
        ActorPose *p = &now->view[i];
        if (!p->seen || p->frame != frame || (p->cam == cam && p->depth == ex->depth.image)) {
            cur = p;
            break;
        }
    }
    *candidate = cur;
    if (!cur) return NULL;
    int repeated = cur->seen && cur->frame == frame;
    if (repeated && cur->ambiguous) return NULL;
    if (!repeated) {
        cur->seen = 1;
        cur->frame = frame;
        cur->selected = cur->ambiguous = 0;
        cur->visibility_guard = cur->guard_missing_depth = 0;
        cur->cam = cam;
        cur->depth = ex->depth.image;
        cur->width = ex->depth.width;
        cur->height = ex->depth.height;
    }

    // Unused bindings retain the previous draw's values. Only the shader's vertex inputs identify this mesh.
    NVNbufferRange vertex[16] = {0};
    uint32_t inputs = gfx_shader_inputs(ex->dc->B.st.vs, NULL);
    for (int i = 0; i < 16; ++i) {
        va_st a;
        memcpy(&a, &ex->dc->B.st.vattr[i], sizeof a);
        if ((inputs >> i & 1) && a.fmt && a.stream < 16) vertex[a.stream] = ex->vbuf[a.stream];
    }
    uint32_t size[POSE_BANKS] = {0}, n = 0;
    uint64_t bindings[POSE_BANKS] = {0};
    const uint8_t *part[POSE_BANKS] = {0};
    for (int i = 0; i < POSE_BANKS; ++i) {
        if (!(banks & (1u << (i + 3)))) continue;
        const p_bind_buf *u = &ex->ubo[NVN_STAGE_VS][i];
        VkDescriptorBufferInfo snap;
        if (!u->size || u->size > LIM.ubo_max || u->size > POSE_BYTES - n ||
            !vk_usnap_find(u->addr, u->size, LIM.ubo_align, &snap)) {
            cur->ambiguous = 1;
            ++pose_missing;
            return NULL;
        }
        part[i] = vk_usnap_map() + snap.offset;
        size[i] = (uint32_t)u->size;
        bindings[i] = u->addr;
        n += size[i];
    }
    if (repeated) {
        // The same instance can be submitted again in the same pass. A second instance of this mesh
        // can use another palette, or rewrite a palette at the same address between submissions.
        cur->ambiguous = cur->depth != ex->depth.image || cur->indices != d->ibuf ||
                         memcmp(vertex, cur->vertex, sizeof vertex) || memcmp(size, cur->size, sizeof size) ||
                         memcmp(bindings, cur->bindings, sizeof bindings);
        uint32_t offset = 0;
        for (int i = 0; !cur->ambiguous && i < POSE_BANKS; ++i) {
            if (size[i] && memcmp(cur->bytes + offset, part[i], size[i])) cur->ambiguous = 1;
            offset += size[i];
        }
        return NULL;
    }
    cur->shader = ex->dc->B.st.vs;
    cur->indices = d->ibuf;
    memcpy(cur->vertex, vertex, sizeof vertex);
    memcpy(cur->bindings, bindings, sizeof bindings);
    memcpy(cur->size, size, sizeof size);
    if (n > cur->capacity) {
        uint8_t *larger = realloc(cur->bytes, n);
        if (!larger) { cur->ambiguous = 1; return NULL; }
        cur->bytes = larger;
        cur->capacity = n;
    }
    uint8_t *data = cur->bytes;
    for (int i = 0; i < POSE_BANKS; ++i) {
        if (part[i]) memcpy(data, part[i], cur->size[i]);
        data += cur->size[i];
    }
    return prev && frame && prev->frame == frame - 1 && prev->selected && !prev->ambiguous &&
           prev->width == cur->width && prev->height == cur->height &&
           prev->shader == cur->shader && prev->indices == cur->indices && cur->vertex[0].address &&
           !memcmp(prev->vertex, cur->vertex, sizeof cur->vertex) &&
           !memcmp(prev->size, cur->size, sizeof cur->size) ? prev : NULL;
}

// c6 holds a part's submitted transform. Translation is deliberately excluded: a fast jump
// does not itself make a vector unreliable. Only a positively identified sharp rotation opts in.
static float pose_rotation_trace_limit(void) {
    static int degrees;
    static float limit;
    if (!degrees) {
        const char *setting = cfg_get("NX2NAVI_MOTION_GUARD_DEGREES");   // motion_guard_degrees in nx2navi.ini too
        degrees = setting && !strcmp(setting, "35") ? 35 : setting && !strcmp(setting, "45") ? 45 : 60;
        limit = degrees == 60 ? 2.0f : degrees == 45 ? 2.41421356f : 2.63830409f;
        rt_log("motion policy: rotation guard threshold %d degrees per rendered frame", degrees);
    }
    return limit;
}
// Two 3x4 matrices (rows of four floats) of one part or bone, this frame's and last frame's: 1 when both are plain
// rotations and the turn between them is past the guard threshold. vk_skin_motion.inc asks it for each bone of a palette.
static int pose_matrix_sharp(const uint8_t *now, const uint8_t *prev) {
    float m[2][12];
    const uint8_t *p[2] = {now, prev};
    for (int k = 0; k < 2; ++k) {
        memcpy(m[k], p[k], sizeof m[k]);
        for (int a = 0; a < 3; ++a) {
            for (int b = a; b < 3; ++b) {
                float dot = 0.0f;
                for (int j = 0; j < 3; ++j) dot += m[k][4 * a + j] * m[k][4 * b + j];
                float wanted = a == b ? 1.0f : 0.0f;
                if (!(dot >= wanted - 0.005f && dot <= wanted + 0.005f)) return 0;
            }
        }
    }
    float trace = 0.0f;
    for (int i = 0; i < 3; ++i)
        for (int j = 0; j < 3; ++j) trace += m[0][4 * i + j] * m[1][4 * i + j];
    // trace(R1 * transpose(R0)) = 1 + 2*cos(angle). The selected threshold controls
    // when this part needs visibility filtering; equipment retains its separate raw policy.
    return trace < pose_rotation_trace_limit();
}
static int pose_sharp_rotation(const ActorPose *now, const ActorPose *prev) {
    if (!now || !prev || prev->frame + 1 != now->frame || now->size[3] < 48 || prev->size[3] < 48) return 0;
    return pose_matrix_sharp(now->bytes + now->size[0] + now->size[1] + now->size[2],
                             prev->bytes + prev->size[0] + prev->size[1] + prev->size[2]);
}

static int pose_guard_needed(const PoseRange *range, const ActorPose *now, const ActorPose *previous) {
    if (pose_raw() || (range->owner.flags & MOTION_OWNER_RIGID_EQUIPMENT)) return 0;
    return pose_sharp_rotation(now, previous);
}

static unsigned pose_guarded_parts, pose_raw_parts, pose_rigid_parts;
static void pose_select(uint64_t frame, uint64_t camera, VkImage depth) {
    unsigned guarded = 0, raw = 0, rigid = 0, missing_depth = 0;
    for (int i = 0; i < pose_count; ++i) {
        PoseFrame *h = &pose_ranges[i].history[frame & 1];
        h->scene = NULL;
        for (int j = 0; j < POSE_VIEWS; ++j) {
            ActorPose *p = &h->view[j];
            p->selected = p->seen && p->frame == frame && !p->ambiguous && p->cam == camera && p->depth == depth;
            if (p->selected) {
                h->scene = p;
                guarded += p->visibility_guard;
                raw += !p->visibility_guard;
                rigid += !!(pose_ranges[i].owner.flags & MOTION_OWNER_RIGID_EQUIPMENT);
                missing_depth += p->guard_missing_depth;
            }
        }
    }
    // Selection preserves each part independently. No six-frame hold and no queue-wide drop:
    // a risky body triangle cannot suppress the shield, sword, or another well-behaved part.
    pose_guarded_parts += guarded;
    pose_raw_parts += raw;
    pose_rigid_parts += rigid;
    static int trace = -1;
    if (trace < 0) trace = rt_knob("MOTION_POLICY_TRACE", "0");
    if (trace && (guarded || raw))
        rt_log("motion policy: world %.3f frame %llu guarded %u raw %u rigid %u depth-unavailable %u",
               frame_step_world_us() / 1e6, (unsigned long long)frame, guarded, raw, rigid, missing_depth);
}

// The motion status line, every 120 frames with motion vectors: the player's parts (ownership records), then the
// other skinned draws (vk_skin_motion.inc skin_status).
static int skin_status(char *out, size_t cap);
static void pose_status(uint64_t frame) {
    if (frame % 120) return;
    char skinned[1200];
    skin_status(skinned, sizeof skinned);
    rt_log("selective motion: body %u/%u, attached equipment %u/%u matched/written; missing blocks %u, "
           "unowned draws %u, history capacity misses %u; selected parts guarded %u, raw %u, rigid equipment %u%s",
           pose_seen[1], pose_written[1], pose_seen[2], pose_written[2], pose_missing, pose_unowned, pose_full,
           pose_guarded_parts, pose_raw_parts, pose_rigid_parts, skinned);
}

static void pose_shutdown(void) {
    for (int i = 0; i < pose_count; ++i) pose_clear(&pose_ranges[i]);
    pose_count = 0;
    pose_guarded_parts = pose_raw_parts = pose_rigid_parts = 0;
}