fix(blocks): unify block-backed content

Route pictures, table cells, leader content, symbols, and arrows through one dependency and transform graph.\n\nRefs #864

src/entities/insert.rs

@@ -185,6 +185,57 @@ impl crate::entities::traits::FallbackTess for Insert {
         )
     }
 }
+pub(crate) fn insert_attribute_entities(
+    document: &acadrust::CadDocument,
+    insert: &acadrust::entities::Insert,
+    annotation_scale: f32,
+) -> Vec<EntityType> {
+    let visibility = document.header.attribute_visibility;
+    if visibility == 0 || insert.attributes.is_empty() {
+        return Vec::new();
+    }
+    let block_scale = if insert
+        .common
+        .extended_data
+        .get_record("AcAnnotativeData")
+        .is_some()
+    {
+        annotation_scale as f64
+    } else {
+        1.0
+    };
+    let insertion = insert.insert_point;
+    let scale_about = |point: Vector3| {
+        Vector3::new(
+            insertion.x + (point.x - insertion.x) * block_scale,
+            insertion.y + (point.y - insertion.y) * block_scale,
+            insertion.z + (point.z - insertion.z) * block_scale,
+        )
+    };
+    insert
+        .attributes
+        .iter()
+        .filter(|attribute| {
+            let layer_visible = document
+                .layers
+                .get(&attribute.common.layer)
+                .is_none_or(|layer| !layer.flags.off && !layer.flags.frozen);
+            layer_visible
+                && (visibility == 2
+                    || (!attribute.common.invisible && !attribute.flags.invisible))
+        })
+        .map(|attribute| {
+            let mut attribute = attribute.clone();
+            if (block_scale - 1.0).abs() > 1.0e-6 {
+                attribute.height *= block_scale;
+                attribute.insertion_point = scale_about(attribute.insertion_point);
+                attribute.alignment_point = scale_about(attribute.alignment_point);
+            }
+            EntityType::AttributeEntity(attribute)
+        })
+        .collect()
+}
+
 pub(crate) fn append_insert_attribute_wires(
     wires: &mut Vec<WireModel>,
     document: &acadrust::CadDocument,
@@ -202,47 +253,8 @@ pub(crate) fn append_insert_attribute_wires(
     pslt_factor: f32,
     anno_scale: f32,
 ) {
-    if ins.attributes.is_empty() {
-        return;
-    }
-    // ATTMODE (header.attribute_visibility):
-    //   0 = Off    — every attribute hidden
-    //   1 = Normal — honour per-attribute `invisible` flag (default)
-    //   2 = On     — every attribute forced visible, ignoring its flag
-    let attmode = document.header.attribute_visibility;
-    if attmode == 0 {
-        return;
-    }
-    // Attributes inherit the annotative block scale. Pre-scale them here so
-    // text tessellation stays at a neutral scale.
-    let annotative = ins
-        .common
-        .extended_data
-        .get_record("AcAnnotativeData")
-        .is_some();
-    let block_scale = if annotative { anno_scale as f64 } else { 1.0 };
-    let ip = ins.insert_point;
-    let scale_about = |q: acadrust::types::Vector3| {
-        acadrust::types::Vector3::new(
-            ip.x + (q.x - ip.x) * block_scale,
-            ip.y + (q.y - ip.y) * block_scale,
-            ip.z + (q.z - ip.z) * block_scale,
-        )
-    };
-    for attr in &ins.attributes {
-        let per_attr_hidden = attr.common.invisible || attr.flags.invisible;
-        if attmode == 1 && per_attr_hidden {
-            continue;
-        }
-        let attr_entity = EntityType::AttributeEntity({
-            let mut a = attr.clone();
-            if (block_scale - 1.0).abs() > 1e-6 {
-                a.height *= block_scale;
-                a.insertion_point = scale_about(a.insertion_point);
-                a.alignment_point = scale_about(a.alignment_point);
-            }
-            a
-        });
+    for attr_entity in insert_attribute_entities(document, ins, anno_scale) {
+        let attr = attr_entity.common();
         let (sub_color, sub_plen, sub_pat, sub_lw_px, sub_aci) = render::render_style_for_block_sub(
             document,
             &attr_entity,
@@ -258,12 +270,12 @@ pub(crate) fn append_insert_attribute_wires(
         } else {
             sub_color
         };
-        let attr_plottable = if render::is_effective_layer_zero(&attr.common.layer) {
+        let attr_plottable = if render::is_effective_layer_zero(&attr.layer) {
             ins_layer_plottable
         } else {
             document
                 .layers
-                .get(&attr.common.layer)
+                .get(&attr.layer)
                 .map(|layer| layer.is_plottable)
                 .unwrap_or(true)
         };

src/entities/multileader.rs

@@ -2104,11 +2104,19 @@ impl MultiLeaderTess for MultiLeader {
             fill_tris_low: Vec::new(),
         });
 
-        if let Some(insert) = block_content_insert(document, ml) {
+        let host = acadrust::EntityType::MultiLeader(ml.clone());
+        for block_use in crate::scene::render_graph::entity_render_block_uses(document, &host, 1.0)
+            .into_iter()
+            .filter(|block_use| {
+                block_use.active
+                    && block_use.role
+                        == crate::scene::render_graph::BlockRole::MultiLeaderContent
+            })
+        {
             wires.extend(
                 crate::scene::convert::tess::expand_block_object(
                     document,
-                    &insert,
+                    &block_use.insert,
                     handle,
                     selected,
                     active_viewport,

src/entities/table.rs

@@ -963,16 +963,22 @@ pub(crate) fn block_cell_inserts(
                 insert.set_x_scale(scale);
                 insert.set_y_scale(scale);
                 insert.set_z_scale(scale);
-                let transform = insert.get_transform();
                 let local_anchor = if has_block_bounds {
                     (block_min + block_max) * 0.5
                 } else {
-                    record.base_point
+                    crate::scene::render_graph::block_base_point(document, &record.name)
                 };
-                let transformed_base = transform.apply(local_anchor);
-                let transformed_zero = transform.apply(Vector3::ZERO);
+                let transformed_anchor = crate::scene::render_graph::insert_transform(
+                    document,
+                    &insert,
+                )
+                .apply(local_anchor);
                 insert.insert_point = insert.insert_point
-                    - (transformed_base - transformed_zero);
+                    + Vector3::new(
+                        position.x as f64 - transformed_anchor.x,
+                        position.y as f64 - transformed_anchor.y,
+                        position.z as f64 - transformed_anchor.z,
+                    );
                 let attribute_definitions: Vec<_> = record
                     .entity_handles
                     .iter()
@@ -1001,7 +1007,7 @@ pub(crate) fn block_cell_inserts(
                         AttributeEntity::from_definition(definition, Some(attribute.value.clone()));
                     acadrust::Entity::apply_transform(
                         &mut entity,
-                        &insert.get_transform(),
+                        &crate::scene::render_graph::insert_transform(document, &insert),
                     );
                     entity.common.handle = table.common.handle;
                     insert.attributes.push(entity);