fork/Graphite
1
0
Fork 0
mirror of https://github.com/GraphiteEditor/Graphite.git synced 2026-09-17 15:28:04 +08:00
Code Issues Packages Projects Releases Wiki Activity

Run cargo fmt

Browse Source
This commit is contained in:
Dennis Kobert
2026-08-29 18:40:02 +00:00
parent 97bc10e4c3
commit a955d6b458
16 changed files with 164 additions and 111 deletions
Download Patch File Download Diff File Expand all files Collapse all files

31
node-graph/libraries/core-types/src/record.rs
View File

@@ -1507,11 +1507,7 @@ impl SourcePlan {
.filter(|field| source.offset_of(field.name, field.level).is_none())
.map(|field| (field.offset, default_fill_bytes(field.name, field.size)))
.collect();
Some(SourcePlan {
moves,
fills,
source: source.clone(),
})
Some(SourcePlan { moves, fills, source: source.clone() })
}
/// # Safety
@@ -1887,7 +1883,12 @@ impl ServedRecord {
/// markers. Panics unless the field is declared at `T` and byte-carried;
/// a parked field reads through replay, not the captured bytes.
pub fn field<T: Copy + 'static>(&self, name: &str, level: u8) -> T {
let field = self.layout.fields.iter().find(|field| field.name == name && field.level == level).expect("the layout carries the read field");
let field = self
.layout
.fields
.iter()
.find(|field| field.name == name && field.level == level)
.expect("the layout carries the read field");
assert_eq!(field.type_id, std::any::TypeId::of::<T>(), "the field was declared at this value type");
assert!(field.repark.is_none(), "a parked field reads through replay, not the captured bytes");
// SAFETY: the captured bytes image a record of this layout and the
@@ -2076,7 +2077,11 @@ impl<'e> RunBuilder<'e> {
/// Starts the next lane: moves its element in and default-fills its
/// fields. Returns the lane index; `None` reports arena exhaustion.
pub fn push<T: Send + Sync + dyn_any::StaticTypeSized>(&mut self, element: T) -> Option<usize> {
assert_eq!(std::any::TypeId::of::<T::Static>(), self.layout.element.type_id, "the pushed element must match the layout's element type");
assert_eq!(
std::any::TypeId::of::<T::Static>(),
self.layout.element.type_id,
"the pushed element must match the layout's element type"
);
assert!(self.pushed < self.len, "the builder holds exactly its declared lane count");
let lane = self.pushed;
let stride = self.layout.lane_stride();
@@ -2106,7 +2111,12 @@ impl<'e> RunBuilder<'e> {
A::Value<'static>: 'static,
{
assert!(lane < self.pushed, "attributes write onto pushed lanes");
let field = self.layout.fields.iter().find(|field| field.name == A::NAME && field.level == 0).expect("the layout carries the written marker");
let field = self
.layout
.fields
.iter()
.find(|field| field.name == A::NAME && field.level == 0)
.expect("the layout carries the written marker");
let offset = field.offset;
assert_eq!(field.type_id, std::any::TypeId::of::<A::Value<'static>>(), "the field was declared at the marker's value type");
// SAFETY: the offset comes from the builder's own layout and the value
@@ -2445,7 +2455,10 @@ impl<'a, T: dyn_any::StaticTypeSized> crate::lane::LaneSource for RunView<'a, T>
impl<T: crate::render_complexity::RenderComplexity + dyn_any::StaticTypeSized> crate::render_complexity::RenderComplexity for RunView<'_, T> {
fn render_complexity(&self) -> usize {
use crate::lane::LaneSource;
(0..self.lane_count()).filter_map(|lane| self.element(lane)).map(crate::render_complexity::RenderComplexity::render_complexity).sum()
(0..self.lane_count())
.filter_map(|lane| self.element(lane))
.map(crate::render_complexity::RenderComplexity::render_complexity)
.sum()
}
}

13
node-graph/libraries/graphic-types/src/boundary.rs
View File

@@ -33,13 +33,7 @@ where
LevelStatus::Batch(batch, finality) => {
// SAFETY: a materialized batch's frames are arena-resident.
let item = unsafe { GroupItem::from_resident(batch) };
LevelGroup::Group(
Group {
row: None,
content: item,
},
finality,
)
LevelGroup::Group(Group { row: None, content: item }, finality)
}
LevelStatus::Pending => LevelGroup::Pending,
LevelStatus::Error(error) => LevelGroup::Error(error),
@@ -80,10 +74,7 @@ pub fn batch_to_legacy(layout: &core_types::record::Layout, batch: core_types::n
run_to_legacy_list::<T>(item).map(|list| Box::new(list) as Box<dyn std::any::Any + Send + Sync>)
}
if item.typed_lanes::<Graphic>().is_some() {
let group = Group {
row: None,
content: item,
};
let group = Group { row: None, content: item };
return Some(Box::new(group_to_legacy_list(&group)));
}
fn typed_artboards(item: &GroupItem) -> Option<Box<dyn std::any::Any + Send + Sync>> {

51
node-graph/libraries/graphic-types/src/graphic.rs
View File

@@ -999,13 +999,7 @@ impl VectorRow<'_> {
}
}
fn walk_rows_of_run(
item: &core_types::record::GroupItem,
scale: FlattenScale,
layer_path: Option<&[NodeId]>,
paint: LanePaint<'_>,
visit: &mut dyn FnMut(VectorRow<'_>) -> RowStep,
) -> RowStep {
fn walk_rows_of_run(item: &core_types::record::GroupItem, scale: FlattenScale, layer_path: Option<&[NodeId]>, paint: LanePaint<'_>, visit: &mut dyn FnMut(VectorRow<'_>) -> RowStep) -> RowStep {
let Some(run) = core_types::record::RunView::<Vector>::new(item) else {
return RowStep::Continue;
};
@@ -1548,10 +1542,7 @@ mod run_tests {
let mut builder = RunBuilder::new(&source, element_write_hashed::<Vector>(), &[FieldWrite::of::<Fill>(0)], 1).unwrap();
let lane = builder.push(vector.clone()).unwrap();
builder.attr::<Fill>(lane, Some(&paint));
let group = core_types::record::Group {
row: None,
content: builder.finish(),
};
let group = core_types::record::Group { row: None, content: builder.finish() };
let expected = group_to_legacy_list(&group);
let owned = map_groups_to_owned(&Graphic::Group(group));
drop(source);
@@ -1568,17 +1559,11 @@ mod run_tests {
let source = core_types::arena::Arena::new(1 << 16).unwrap();
let mut builder = RunBuilder::new(&source, element_write_hashed::<Vector>(), &[], 1).unwrap();
builder.push(vector.clone()).unwrap();
let nested = Graphic::Group(core_types::record::Group {
row: None,
content: builder.finish(),
});
let nested = Graphic::Group(core_types::record::Group { row: None, content: builder.finish() });
let mut builder = RunBuilder::new(&source, element_write_hashed::<Graphic>(), &[], 1).unwrap();
builder.push(nested).unwrap();
let group = core_types::record::Group {
row: None,
content: builder.finish(),
};
let group = core_types::record::Group { row: None, content: builder.finish() };
let expected = group_to_legacy_list(&group);
let owned = map_groups_to_owned(&Graphic::Group(group));
drop(source);
@@ -1592,10 +1577,7 @@ mod run_tests {
fn native_group_paint<'a>(vector: &Vector, arena: &'a core_types::arena::Arena) -> List<Graphic<'a>> {
let mut builder = RunBuilder::new(arena, element_write_hashed::<Vector>(), &[], 1).unwrap();
builder.push(vector.clone()).unwrap();
List::new_from_element(Graphic::Group(core_types::record::Group {
row: None,
content: builder.finish(),
}))
List::new_from_element(Graphic::Group(core_types::record::Group { row: None, content: builder.finish() }))
}
#[test]
@@ -1716,10 +1698,7 @@ mod run_tests {
let mut top = List::new();
top.push(Item::new_from_element(Graphic::Graphic(painted)));
top.push(Item::new_from_element(Graphic::Graphic(nested)));
top.push(Item::new_from_element(Graphic::Group(core_types::record::Group {
row: None,
content: inner_item,
})));
top.push(Item::new_from_element(Graphic::Group(core_types::record::Group { row: None, content: inner_item })));
top.push(Item::new_from_element(Graphic::Color(Color::BLACK)));
top.push(Item::new_from_element(Graphic::Vector(unit_square_at(DVec2::new(6., 0.)))));
top.set_attribute(core_types::ATTR_TRANSFORM, 0, DAffine2::from_translation(DVec2::new(5., 5.)));
@@ -1743,14 +1722,26 @@ mod run_tests {
let native = flatten_vector_rows(GraphicLevel::Legacy(&top));
assert_eq!(native.len(), legacy.len());
for row in 0..native.len() {
assert_eq!(native.attribute::<DAffine2>(core_types::ATTR_TRANSFORM, row), legacy.attribute::<DAffine2>(core_types::ATTR_TRANSFORM, row), "transform, row {row}");
assert_eq!(native.attribute::<f64>(core_types::ATTR_OPACITY, row), legacy.attribute::<f64>(core_types::ATTR_OPACITY, row), "opacity, row {row}");
assert_eq!(
native.attribute::<DAffine2>(core_types::ATTR_TRANSFORM, row),
legacy.attribute::<DAffine2>(core_types::ATTR_TRANSFORM, row),
"transform, row {row}"
);
assert_eq!(
native.attribute::<f64>(core_types::ATTR_OPACITY, row),
legacy.attribute::<f64>(core_types::ATTR_OPACITY, row),
"opacity, row {row}"
);
assert_eq!(
native.attribute::<Vec<core_types::uuid::NodeId>>(core_types::ATTR_EDITOR_LAYER_PATH, row),
legacy.attribute::<Vec<core_types::uuid::NodeId>>(core_types::ATTR_EDITOR_LAYER_PATH, row),
"layer path, row {row}"
);
assert_eq!(native.attribute::<Option<List<Graphic>>>(ATTR_FILL, row), legacy.attribute::<Option<List<Graphic>>>(ATTR_FILL, row), "fill, row {row}");
assert_eq!(
native.attribute::<Option<List<Graphic>>>(ATTR_FILL, row),
legacy.attribute::<Option<List<Graphic>>>(ATTR_FILL, row),
"fill, row {row}"
);
}
assert_eq!(native, legacy);
}

24
node-graph/libraries/rendering/src/renderer.rs
View File

@@ -11,10 +11,10 @@ use core_types::bounds::RenderBoundingBox;
use core_types::color::Color;
use core_types::color::SRGBA8;
use core_types::lane::LaneSource;
use core_types::list::{Item, List};
use core_types::lane::{LeafLane, Single};
use core_types::record::{Group, RunView};
use core_types::list::{Item, List};
use core_types::math::quad::Quad;
use core_types::record::{Group, RunView};
use core_types::render_complexity::RenderComplexity;
use core_types::transform::Footprint;
use core_types::uuid::{NodeId, generate_uuid};
@@ -1043,7 +1043,14 @@ fn render_graphic_vello<'e, S: LaneSource<Element = Graphic<'e>>>(source: &S, sc
render_graphic_vello_with(source, PaintReach::NONE, scene, transform, context, render_params)
}
fn render_graphic_vello_with<'a, 'e, S: LaneSource<Element = Graphic<'e>>>(source: &'a S, inherited: PaintReach<'a>, scene: &mut Scene, transform: DAffine2, context: &mut RenderContext, render_params: &RenderParams) {
fn render_graphic_vello_with<'a, 'e, S: LaneSource<Element = Graphic<'e>>>(
source: &'a S,
inherited: PaintReach<'a>,
scene: &mut Scene,
transform: DAffine2,
context: &mut RenderContext,
render_params: &RenderParams,
) {
let paint_columns = PaintColumns::new(source);
let mut mask_element_and_transform = None;
@@ -1127,7 +1134,13 @@ fn collect_graphic_metadata<'e, S: LaneSource<Element = Graphic<'e>>>(source: &S
collect_graphic_metadata_with(source, PaintReach::NONE, metadata, footprint, element_id)
}
fn collect_graphic_metadata_with<'a, 'e, S: LaneSource<Element = Graphic<'e>>>(source: &'a S, inherited: PaintReach<'a>, metadata: &mut RenderMetadata, footprint: Footprint, element_id: Option<NodeId>) {
fn collect_graphic_metadata_with<'a, 'e, S: LaneSource<Element = Graphic<'e>>>(
source: &'a S,
inherited: PaintReach<'a>,
metadata: &mut RenderMetadata,
footprint: Footprint,
element_id: Option<NodeId>,
) {
let paint_columns = PaintColumns::new(source);
for index in 0..source.lane_count() {
let item_transform: DAffine2 = source.attr::<Transform>(index);
@@ -1520,8 +1533,7 @@ fn render_vector_vello<S: LaneSource<Element = Vector>>(source: &S, scene: &mut
// the function ignores the arg for Center align) and the `SrcIn`/`SrcOut` aligned-stroke branch further down.
let stroke = element.stroke.as_ref();
let stroke_fully_transparent = stroke_graphic_list.is_none_or(|l| l.element(0).is_none_or(|g| g.is_fully_transparent()));
let can_draw_aligned_stroke =
!stroke_fully_transparent && stroke.is_some_and(|s| s.has_renderable_stroke() && s.align.is_not_centered()) && element.stroke_bezier_paths().all(|p| p.closed());
let can_draw_aligned_stroke = !stroke_fully_transparent && stroke.is_some_and(|s| s.has_renderable_stroke() && s.align.is_not_centered()) && element.stroke_bezier_paths().all(|p| p.closed());
let opacity = (opacity_attr * if render_params.for_mask { 1. } else { opacity_fill_attr }) as f32;
if opacity < 1. || blend_mode_attr != BlendMode::default() {