ifc_lite_processing/

prepass_styled.rs

// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at https://mozilla.org/MPL/2.0/.

//! Styled-item resolution helpers for the pre-pass (split from `prepass.rs`).
//! The loop here is byte-identical to the historic inline loop in
//! `resolve_prepass`; the sharded pre-pass fans slices of it across workers.

use ifc_lite_core::EntityDecoder;
use rustc_hash::FxHashMap;

use crate::prepass::{collect_geometry_style_info, extract_style_info_from_styled_item, surface_style_from_styled_item, Span};
use crate::style::{GeometryStyleInfo, SpecularMaterial};

/// Pre-resolved styled maps: `(orphan id -> rgba, geometry id -> style info)`.
pub type StyleSeeds = (FxHashMap<u32, [f32; 4]>, FxHashMap<u32, GeometryStyleInfo>);

/// The styled-item classification/resolution loop of [`resolve_prepass`],
/// exposed so the browser's SHARDED pre-pass can fan slices of the (file-
/// ordered) styled-item span list across workers: each worker resolves its
/// contiguous slice with this exact loop, and the host merges shard results in
/// shard order with first-wins per geometry id — reproducing the serial
/// resolver's file-order first-wins precedence (`collect_geometry_style_info`
/// skips ids already present).
pub fn resolve_styled_items_into(
    styled_items: &[Span],
    decoder: &mut EntityDecoder,
    defer_attached_styles: bool,
    orphan_styled_items: &mut FxHashMap<u32, [f32; 4]>,
    geometry_style_index: &mut FxHashMap<u32, GeometryStyleInfo>,
    deferred_attached_styled_spans: &mut Vec<(usize, usize)>,
) {
    for &(id, start, end) in styled_items {
        let Ok(styled_item) = decoder.decode_at_with_id(id, start, end) else {
            if defer_attached_styles {
                // Undecodable now — let the replay try again later, matching
                // the historic defer behaviour.
                deferred_attached_styled_spans.push((start, end));
            }
            continue;
        };
        if styled_item.get_ref(0).is_none() {
            // Orphan styled item (null Item) = a material appearance (#407).
            // Always resolved up front — even in defer mode — or
            // material-only-styled elements render default-gray (#913 §2c).
            if let Some(info) = extract_style_info_from_styled_item(&styled_item, decoder) {
                orphan_styled_items.insert(id, info.color);
            }
        } else if defer_attached_styles {
            deferred_attached_styled_spans.push((start, end));
        } else {
            collect_geometry_style_info(geometry_style_index, &styled_item, decoder);
        }
    }
}


/// IFC-authored metallic/roughness per styled geometry item (#5582), keyed
/// exactly like the colour index [`resolve_styled_items_into`] builds: the
/// FIRST styled item (file order) that yields a style claims its geometry id,
/// and the finish comes from that same chosen rendering style, so a mesh never
/// pairs one style's colour with another's finish. A claim whose style authors
/// no specular evidence is kept as an empty [`SpecularMaterial`] (it encodes
/// to `[NAN, NAN]`), so a first-wins merge of sharded results cannot take a
/// later item's finish for it. Orphan (null-item) styled items are skipped,
/// as they colour materials, not geometry. Fed to
/// [`crate::prepass::flat_styles_with_finishes`].
///
/// A separate pass instead of a field on `GeometryStyleInfo` / `ResolvedPrepass`
/// so this crate's public structs stay unchanged (semver-additive, #5582).
pub fn resolve_geometry_finishes(
    styled_items: &[Span],
    decoder: &mut EntityDecoder,
) -> FxHashMap<u32, SpecularMaterial> {
    let mut finishes: FxHashMap<u32, SpecularMaterial> = FxHashMap::default();
    let mut claimed_without_finish: rustc_hash::FxHashSet<u32> = Default::default();
    for &(id, start, end) in styled_items {
        let Ok(styled_item) = decoder.decode_at_with_id(id, start, end) else { continue };
        let Some(geometry_id) = styled_item.get_ref(0) else { continue };
        if finishes.contains_key(&geometry_id) || claimed_without_finish.contains(&geometry_id) {
            continue;
        }
        match surface_style_from_styled_item(&styled_item, decoder) {
            Some((style_id, _)) => {
                let finish = crate::style::extract_surface_style_specular(style_id, decoder).unwrap_or_default();
                finishes.insert(geometry_id, finish);
            }
            // A fill-only style claims the colour but has no rendering finish.
            None if extract_style_info_from_styled_item(&styled_item, decoder).is_some() => {
                claimed_without_finish.insert(geometry_id);
            }
            None => {}
        }
    }
    finishes
}

/// [`crate::prepass::flat_styles_rgba8`] with the (dominant) geometry-style
/// source supplied as PRE-MERGED columns instead of a map — the sharded
/// finalize path. `geom_ids` are unique (the host merged shard results
/// first-wins) with `geom_colors` as rgba f32 quads; `resolved` carries the
/// support resolution (indexed colours, materials, element colours) and MUST
/// have an empty `geometry_style_index`. Output is byte-identical to the
/// serial flatten: same precedence (geometry > indexed colour > material >
/// element material), same id-ascending wire order, same rgba8 conversion —
/// without ever building the 4M-entry geometry hashmap.
pub fn flat_styles_rgba8_from_geometry_columns(
    geom_ids: &[u32],
    geom_colors: &[f32],
    resolved: &crate::prepass::ResolvedPrepass,
    decoder: &mut EntityDecoder,
) -> (Vec<u32>, Vec<u8>) {
    debug_assert!(resolved.geometry_style_index.is_empty());
    // Overlay sources in serial precedence order, or_insert among themselves.
    let mut overlay: FxHashMap<u32, [f32; 4]> = FxHashMap::default();
    for (&geometry_id, &color) in &resolved.indexed_colour_index {
        overlay.entry(geometry_id).or_insert(color);
    }
    let material_styles = crate::style::build_material_style_index(
        &resolved.material_def_reprs,
        &resolved.orphan_styled_items,
        decoder,
    );
    for (&mat_id, &color) in crate::style::flatten_material_color_index(&material_styles).iter() {
        overlay.entry(mat_id).or_insert(color);
    }
    for (&element_id, colors) in &resolved.element_material_colors {
        if let Some(&color) = colors.first() {
            overlay.entry(element_id).or_insert(color);
        }
    }

    // Sort both sides by id and merge, geometry winning on ties.
    let mut geom_order: Vec<u32> = (0..geom_ids.len() as u32).collect();
    geom_order.sort_unstable_by_key(|&i| geom_ids[i as usize]);
    let mut overlay_sorted: Vec<(u32, [f32; 4])> = overlay.into_iter().collect();
    overlay_sorted.sort_unstable_by_key(|&(id, _)| id);

    let mut ids: Vec<u32> = Vec::with_capacity(geom_ids.len() + overlay_sorted.len());
    let mut rgba: Vec<u8> = Vec::with_capacity((geom_ids.len() + overlay_sorted.len()) * 4);
    let push = |id: u32, color: [f32; 4], ids: &mut Vec<u32>, rgba: &mut Vec<u8>| {
        ids.push(id);
        rgba.extend_from_slice(&crate::style::Rgba::from_array(color).to_rgba8());
    };
    let mut oi = 0;
    for &gi in &geom_order {
        let id = geom_ids[gi as usize];
        while oi < overlay_sorted.len() && overlay_sorted[oi].0 < id {
            let (oid, oc) = overlay_sorted[oi];
            push(oid, oc, &mut ids, &mut rgba);
            oi += 1;
        }
        if oi < overlay_sorted.len() && overlay_sorted[oi].0 == id {
            oi += 1; // geometry wins the tie, overlay entry dropped
        }
        let c = gi as usize * 4;
        push(
            id,
            [geom_colors[c], geom_colors[c + 1], geom_colors[c + 2], geom_colors[c + 3]],
            &mut ids,
            &mut rgba,
        );
    }
    while oi < overlay_sorted.len() {
        let (oid, oc) = overlay_sorted[oi];
        push(oid, oc, &mut ids, &mut rgba);
        oi += 1;
    }
    (ids, rgba)
}