nightshade 0.36.1

A cross-platform data-oriented game engine.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

struct ObjectData {
    transform_index: u32,
    mesh_id: u32,
    material_id: u32,
    batch_id: u32,
    morph_weights: array<f32, 8>,
    morph_target_count: u32,
    morph_displacement_offset: u32,
    mesh_vertex_offset: u32,
    mesh_vertex_count: u32,
    entity_id: u32,
    is_overlay: u32,
    skip_occlusion: u32,
    flip_winding: u32,
    culling_mask: u32,
    visible: u32,
    pipeline_class: u32,
    _pad_culling_2: u32,
};

struct BatchKey {
    pipeline_class: u32,
    mesh_id: u32,
    material_id: u32,
    base_slot: u32,
};

struct AssignParams {
    object_count: u32,
    key_count: u32,
    invalid_batch: u32,
    mode: u32,
    cap: u32,
    _pad0: u32,
    _pad1: u32,
    _pad2: u32,
};

const NUM_CLASSES: u32 = 9u;

@group(0) @binding(0)
var<storage, read_write> objects: array<ObjectData>;

@group(0) @binding(1)
var<storage, read> keys: array<BatchKey>;

@group(0) @binding(2)
var<uniform> params: AssignParams;

@group(0) @binding(3)
var<storage, read> batch_meta: array<u32>;

fn key_less(object_class: u32, mesh: u32, material: u32, other: BatchKey) -> bool {
    if object_class != other.pipeline_class {
        return object_class < other.pipeline_class;
    }
    if mesh != other.mesh_id {
        return mesh < other.mesh_id;
    }
    return material < other.material_id;
}

fn key_equal(object_class: u32, mesh: u32, material: u32, other: BatchKey) -> bool {
    return object_class == other.pipeline_class && mesh == other.mesh_id && material == other.material_id;
}

@compute @workgroup_size(64)
fn main(@builtin(global_invocation_id) global_id: vec3<u32>) {
    let object_index = global_id.x;
    if object_index >= params.object_count {
        return;
    }

    let object = objects[object_index];
    if object.batch_id == params.invalid_batch {
        return;
    }

    let object_class = object.pipeline_class;
    let mesh = object.mesh_id;
    let material = object.material_id;

    // GPU-driven mode: keys live in a fixed per-class region; linear search it.
    if params.mode == 1u {
        let key_count = batch_meta[NUM_CLASSES + object_class];
        let region = object_class * params.cap;
        var found = params.invalid_batch;
        for (var k = 0u; k < key_count; k = k + 1u) {
            let key = keys[region + k];
            if key.mesh_id == mesh && key.material_id == material {
                found = key.base_slot;
                break;
            }
        }
        objects[object_index].batch_id = found;
        return;
    }

    var low = 0u;
    var high = params.key_count;
    while low < high {
        let mid = (low + high) >> 1u;
        if key_less(object_class, mesh, material, keys[mid]) {
            high = mid;
        } else {
            low = mid + 1u;
        }
    }

    if low == 0u {
        objects[object_index].batch_id = params.invalid_batch;
        return;
    }
    let found = keys[low - 1u];
    if key_equal(object_class, mesh, material, found) {
        objects[object_index].batch_id = found.base_slot;
    } else {
        objects[object_index].batch_id = params.invalid_batch;
    }
}