void main() {

    uint local_id = gl_LocalInvocationIndex;
    uint group_id = (gl_WorkGroupID.z * grid_size + gl_WorkGroupID.y) * grid_size + gl_WorkGroupID.x;

    // task parameters
    [[branch]] if(local_id == 0u) {

        // instance index
        OUT.instance = group_id;

        // instance transform
        uint instance = group_id * 3u;
        transform[0] = instances_buffer[instance + 0u];
        transform[1] = instances_buffer[instance + 1u];
        transform[2] = instances_buffer[instance + 2u];

        // clear geometries
        num_geometries = 0;

        // first geometry
        shared_depth = 1;
        shared_stack[0] = 0;
    }
    memoryBarrierShared(); barrier();

    // graph intersection
    int local_depth = 0;
    uint local_stack[LOCAL_STACK];
    [[loop]] while(atomicLoad(shared_depth) > 0) {

        // stack barrier
        memoryBarrierShared(); barrier();

        // geometry index
        int index = atomicDecrement(shared_depth) - 1;
        [[branch]] if(index >= 0) {

            // geometry index
            uint geometry_index = shared_stack[index];

            // transform bound box
            vec3 bound_min = geometries_buffer[geometry_index].bound_min.xyz;
            vec3 bound_max = geometries_buffer[geometry_index].bound_max.xyz;
            transform_box(mat3x4(transform[0], transform[1], transform[2]), bound_min, bound_max);

            // check current geometry visibility
            [[branch]] if(is_box_visible(bound_min, bound_max)) {

                // geometry is visible
                bool is_visible = true;

                // distance to the bound box
                float distance = get_box_distance(camera.xyz, bound_min, bound_max);

                // the visibility error is larger than the threshold
                [[branch]] if(distance < geometries_buffer[geometry_index].error * projection_scale) {

                    uint num_children = geometries_buffer[geometry_index].num_children;
                    uint base_child = geometries_buffer[geometry_index].base_child;

                    // draw geometry if this is a leaf
                    is_visible = (num_children == 0u);

                    // process children geometry
                    [[loop]] for(uint i = 0u; i < num_children; i++) {

                        // child geometry index
                        uint child_index = children_buffer[base_child + i];

                        // we came here from the second parent
                        [[branch]] if(geometries_buffer[child_index].parent_1 == geometry_index) {

                            // the first parent index
                            uint parent_index = geometries_buffer[child_index].parent_0;

                            // transform bound box
                            vec3 bound_min = geometries_buffer[parent_index].bound_min.xyz;
                            vec3 bound_max = geometries_buffer[parent_index].bound_max.xyz;
                            transform_box(mat3x4(transform[0], transform[1], transform[2]), bound_min, bound_max);

                            // distance to the bound box
                            float distance = get_box_distance(camera.xyz, bound_min, bound_max);

                            // skip children if the first parent is visible
                            [[branch]] if(distance < geometries_buffer[parent_index].error * projection_scale) continue;
                        }

                        // next geometry to visit
                        [[branch]] if(local_depth < LOCAL_STACK) {
                            local_stack[local_depth++] = child_index;
                        }
                    }
                }

                // draw geometry
                [[branch]] if(is_visible) {
                    int index = atomicIncrement(num_geometries);
                    [[branch]] if(index < MAX_GEOMETRIES) OUT.geometries[index] = geometry_index;
                }
            }
        }

        // minimal stack depth
        atomicMax(shared_depth, 0);
        memoryBarrierShared(); barrier();

        // shared stack
        index = atomicAdd(shared_depth, local_depth);
        [[loop]] for(int i = 0; i < local_depth && index < SHARED_STACK; i++) {
            shared_stack[index++] = local_stack[i];
        }
        local_depth = 0;

        // maximal stack depth
        atomicMin(shared_depth, SHARED_STACK);
        memoryBarrierShared(); barrier();
    }

    // emit meshes
    EmitMeshTasksEXT(min(num_geometries, MAX_GEOMETRIES), 1, 1);
}

void main() {

    uint local_id = gl_LocalInvocationIndex;
    uint group_id = gl_WorkGroupID.x;

    // mesh parameters
    [[branch]] if(local_id == 0u) {

        // instance transformation
        uint instance = IN.instance * 3u;
        transform[0] = instances_buffer[instance + 0u];
        transform[1] = instances_buffer[instance + 1u];
        transform[2] = instances_buffer[instance + 2u];

        // geometry parameters
        uint geometry = IN.geometries[group_id];
        num_vertices = geometries_buffer[geometry].num_vertices;
        num_primitives = geometries_buffer[geometry].num_indices / 3u;
        base_vertex = geometries_buffer[geometry].base_vertex;
        base_index = geometries_buffer[geometry].base_index;

        // mesh color
        float seed = mod(instance + geometry * 93.7351f, 1024.0f);
        color = cos(vec3(0.0f, 0.5f, 1.0f) * 3.14f + seed) * 0.5f + 0.5f;
    }
    memoryBarrierShared(); barrier();

    // number of primitives
    SetMeshOutputsEXT(num_vertices, num_primitives);

    // vertices
    [[loop]] for(uint i = local_id; i < num_vertices; i += GROUP_SIZE) {

        // fetch vertex
        uint vertex = base_vertex + i;
        vec4 position = vec4(vertices_buffer[vertex].position.xyz, 1.0f);
        vec3 normal = vertices_buffer[vertex].normal.xyz;

        // position
        position = vec4(dot(transform[0], position), dot(transform[1], position), dot(transform[2], position), 1.0f);
        gl_MeshVerticesEXT[i].gl_Position = projection * (modelview * position);

        // camera direction
        OUT[i].direction = camera.xyz - position.xyz;

        // normal vector
        OUT[i].normal = vec3(dot(transform[0].xyz, normal), dot(transform[1].xyz, normal), dot(transform[2].xyz, normal));

        // color value
        OUT[i].color = color;
    }

    // primitives
    [[loop]] for(uint i = local_id; i < num_primitives; i += GROUP_SIZE) {

        // fetch indices
        uint index = base_index + i * 3u;
        uint index_0 = indices_buffer[index + 0u];
        uint index_1 = indices_buffer[index + 1u];
        uint index_2 = indices_buffer[index + 2u];

        // triangle indices
        gl_PrimitiveTriangleIndicesEXT[i] = uvec3(index_0, index_1, index_2);
    }
}