Method render_idle_clear

perro_source/render_stack/perro_graphics/src/gpu.rs:626–676

(&mut self)

    pub shader_variant_mode: crate::ShaderVariantMode,
    pub shadow_quality: crate::ShadowQuality,
}

struct GpuCameraStreamTarget {
    texture: wgpu::Texture,
    post_input: Option<wgpu::Texture>,
    tonemap_input: Option<wgpu::Texture>,
    depth: Option<wgpu::Texture>,
    resolution: [u32; 2],
    post_view_key: u64,
}

struct CameraStreamContentRevision {
    draws: Arc<[CameraStreamDraw3DState]>,
    draw_revision: u64,
    sprites: Arc<[Sprite2DCommand]>,
    sprite_revision: u64,
}

fn update_camera_stream_content_revisions(
    revisions: &mut AHashMap<NodeID, CameraStreamContentRevision>,
    next_revision: &mut u64,
    node: NodeID,
    draws: &Arc<[CameraStreamDraw3DState]>,
    sprites: &Arc<[Sprite2DCommand]>,
) -> (u64, u64) {
    match revisions.entry(node) {
        std::collections::hash_map::Entry::Occupied(mut entry) => {
            let state = entry.get_mut();
            // ptr_eq fast path: no upsert since last render leaves the same
            // Arc in the retained state, so skip the elementwise compare. On
            // equal content in a fresh allocation (no-op upsert), converge to
            // the new Arc so later frames hit the pointer check again.
            if !Arc::ptr_eq(&state.draws, draws) {
                if state.draws.as_ref() != draws.as_ref() {
                    *next_revision = next_nonzero_generation(*next_revision);
                    state.draw_revision = *next_revision;
                }
                state.draws = draws.clone();
            }
            if !Arc::ptr_eq(&state.sprites, sprites) {
                if state.sprites.as_ref() != sprites.as_ref() {
                    *next_revision = next_nonzero_generation(*next_revision);
                    state.sprite_revision = *next_revision;
                }
                state.sprites = sprites.clone();
            }
            (state.draw_revision, state.sprite_revision)
        }
        std::collections::hash_map::Entry::Vacant(entry) => {
            *next_revision = next_nonzero_generation(*next_revision);
            let draw_revision = *next_revision;
            *next_revision = next_nonzero_generation(*next_revision);
            let sprite_revision = *next_revision;
            entry.insert(CameraStreamContentRevision {