mirror of
https://github.com/tangerineturtle1/NX2navi.git
synced 2026-11-15 19:19:58 -04:00
a3da8569c8
A translated task or mesh module is the program as a compute function over shared memory plus an entry function that hands that memory to the mesh pipeline. mesh_fb.c replaces the entry function by one that copies the memory into a storage buffer, and generates the vertex stage that draws from that buffer. The translator and its identity are not touched, so no install translates a shader again. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
52 lines
3.8 KiB
C
52 lines
3.8 KiB
C
// The mesh shader fallback's modules (mesh_fb.c): what a task or mesh program computes, as compute modules that write
|
|
// it into storage buffers, and the vertex stage that draws from those buffers. No Vulkan calls here.
|
|
#pragma once
|
|
#include <stddef.h>
|
|
#include <stdint.h>
|
|
|
|
#define MESHFB_MAX_LINES 136 // 8 system value components and 32 generic vectors of 4
|
|
|
|
// A task or mesh program's stage buffer, as tools/xlate/AmpereLowering.cs MeshInfo lays it out in the shared memory
|
|
// of the translated module.
|
|
typedef struct {
|
|
int stage; // 6 task, 7 mesh
|
|
uint32_t threads; // workgroup size
|
|
uint32_t maxv, maxp; // mesh: vertex and primitive limits
|
|
uint32_t ipp; // mesh: indices per primitive (1 points, 2 lines, 3 triangles)
|
|
uint32_t payload_bytes; // the task payload (task, or a mesh program a task feeds), with its header
|
|
int has_task; // mesh: a task stage feeds it
|
|
uint32_t nlines; // mesh: output components per vertex
|
|
uint16_t lines[MESHFB_MAX_LINES]; // their attribute addresses: 0x6c point size, 0x70.. position, 0x80 + 16 g + 4 c
|
|
uint32_t attr, map, pay, shared_bytes; // byte offsets in shared memory, and its size
|
|
} MeshFbInfo;
|
|
|
|
// Where a module's extra storage buffers are bound: res.json "cb_slot" of their entries (vk_exec_draw.c ssbo_info).
|
|
enum { MESHFB_CB_TASK = 0x41, MESHFB_CB_MESH = 0x42, MESHFB_CB_LIST = 0x43 };
|
|
// A list entry: the task workgroup in bits 0-23, the mesh workgroup's index among that task's in bits 24-31.
|
|
#define MESHFB_LIST_TASK_BITS 24
|
|
|
|
// From the program's control section and the first 0x80 bytes of its code (the header with the output map). 0 with
|
|
// err filled when the program uses what the fallback does not carry.
|
|
int meshfb_info(const uint8_t *control, const uint8_t *header, int stage, MeshFbInfo *out, char *err, size_t cap);
|
|
// Words one mesh workgroup's output takes in the mesh buffer: its vertex lines and its primitive area.
|
|
static inline uint32_t meshfb_slot_words(const MeshFbInfo *m) { return m->pay / 4; }
|
|
|
|
// The compute module of a TaskEXT module (spirv, as the translator wrote it): the same program, then the payload of
|
|
// workgroup t into words [t * payload_bytes / 4, ..) of the task buffer, a storage buffer at `binding`. malloc'd;
|
|
// NULL with err filled.
|
|
uint32_t *meshfb_task_cs(const uint32_t *spirv, uint64_t words, const MeshFbInfo *m, uint32_t binding, uint64_t *out_words,
|
|
char *err, size_t cap);
|
|
// The compute module of a MeshEXT module. Workgroup g writes its stage buffer (meshfb_slot_words) into slot g of the
|
|
// mesh buffer at binding + 1. After a task stage (m->has_task) entry g of the list at binding + 2 names its task
|
|
// workgroup and its index among that task's mesh workgroups, and the payload comes from the task buffer at `binding`,
|
|
// task_payload_words apart.
|
|
uint32_t *meshfb_mesh_cs(const uint32_t *spirv, uint64_t words, const MeshFbInfo *m, uint32_t binding,
|
|
uint32_t task_payload_words, uint64_t *out_words, char *err, size_t cap);
|
|
// The vertex module that draws the mesh buffer (binding 1): instance = slot, maxp * ipp vertices an instance; vertex
|
|
// index / ipp is the primitive, and a primitive past the slot's count is degenerate. Outputs: position, point size for
|
|
// points, and a 4-component vector at every Location of out_mask, of out_type[location] (GFX_TYPE_*).
|
|
uint32_t *meshfb_vs(const MeshFbInfo *m, uint32_t out_mask, const uint8_t out_type[32], uint64_t *out_words);
|
|
// A copy of the translator's res.json text res for a compute module made above: its stage is "cs" and its storage
|
|
// buffers gain the entries of the extra buffers (n of them from `binding` on, cb_slots[i] each). malloc'd.
|
|
char *meshfb_res_json(const char *res, uint32_t binding, const int *cb_slots, int n);
|