The canvas key did not change when a plug-in was installed, replaced or
removed, so the canvas kept showing the frame drawn with the old plug-in,
and a pan by whole pixels copied that frame's pixels next to strips drawn
with the new one.
The key now carries the plug-in revision of the last install or removal
after which the document draws a plug-in effect, in its layers, in a
symbol's or pattern's art, or in a brush's art. The canvas looks through a
document once after each install or removal; a document without a plug-in
effect keeps its key.
Diff took the Image Trace flag of the old version for both sides when it
read each version's first member. Both versions have the same extras
there (same_but_members), so the result was right, but each side now
reads its own node.
The doc of Renderer's three_d_bounds now says what adds an entry, when
entries are swept, and the bound that follows: about twice the live 3D
art plus 1024 entries.
Review of #6290.
- An Image Trace object's hidden source image counts as shown in each
version by that version's own first member: an edit that puts it
first again (undoing Send to Back on a traced shape), or a new source
image in its place, redraws where it shows. Tested with an image
source on screen with the objects' views.
- A shape of an Image Trace object in Outline view is left out by the
rule every object is (node_checks::left_out), so the drawing and the
measure of an edit can't disagree.
- The renderer keeps the brush library's key from its first measure of
3D art until the library changes; the test says so, and that a change
lets it go.
- The test of a 3D effect that builds nothing covers it on a fill and
on a stroke, without effects of the object's own (exactly as without
it) and under a raster effect.
On the commit before, "Canvas: a 3D effect on a fill that builds nothing
draws without it": it needs no effect of the object's own. A 3D effect
on a fill or stroke that builds nothing overflowed the stack on its own
too. With a raster effect, the object now draws from its art, where
without the 3D effect it draws as a path, whose raster effects are
clipped to the path's own geometry, cutting off the item's Roughen
spikes: the new drawing is the one that keeps them.
Review of #6290.
- An edit is measured as the renderer draws: an object it leaves out
(hidden, a template layer or guide the view hides, drawn hidden, the
instance a symbol is edited from) is measured as nothing, by one
predicate the renderer and the measure share (node_checks::left_out,
before culling).
- An Image Trace object's members are compared one by one again, its
hidden source image, which some views draw, counted as shown: moving
the source redraws where it was and is, and recoloring a traced shape
redraws only the shape.
- The renderer checks the brush library between frames only while it
keeps bounds measured with brushed strokes in 3D art.
- Tests: the sweep of 3D art's bounds counted while the art is held,
and Fit to Artwork Bounds' menu answer kept for a revision.
When an edit changes an object, the canvas draws again only the area
the object painted before and after it, measured by its cull bounds.
Type and groups with Extrude & Bevel, Inflate or Rotate were measured by
their letters or members, not by the solid the effect draws, which
reaches well past them. Making the solid shallower or turning it left
pieces of the old solid on the canvas outside that area until the view
was drawn again.
An object with a 3D effect is now measured by the effect's art, as the
renderer draws it: with its geometry effects, each object in it with
the raster effects of its own fills and strokes and the art its brushed
strokes draw, grown by the reach of the object's own raster effects.
One function measures that art for every bounds the renderer and
exports take, where three copies of it disagreed.
- The renderer measures the art it draws. What it makes to measure an
object it holds until the frame ends, with what the art read from
outside the object (fonts, symbols, color settings), and keeps it
with the art it draws if it draws the object while that is
unchanged. Art measured but not drawn (culled, off the view) isn't
kept. It holds at most as much as it keeps for the art it draws
(64 MB); past that, an object is made again to draw it. An object
whose 3D effect builds nothing (Revolve on a group, a solid too
complex) is measured as it is drawn otherwise, as without a renderer.
FrameStats::three_d_built counts the 3D art the renderer makes.
- The canvas measures what an edit changed through the renderer that
drew the frame shown (Renderer::changed). When it draws the part on
its own thread, it draws it with the art it made to measure it; when
the render worker draws the frame, or nothing in view changed, that
art is let go. Under Overprint Preview or Separations Preview, which
draw copies of the objects, the edit is measured afresh. An object
the frame doesn't draw (hidden, in a hidden group or layer, or
hidden by the view) is measured as nothing, before and after, so an
edit to it builds no solid: changed() without a renderer counts it as
nothing too, where it measured it. The canvas measures the edit
before it knows where the frame is drawn: when the worker draws it,
the solids it built to measure it are built again there.
- Fit to Artwork Bounds, the Artboards panel's check for it and
per-artboard SVG export measure every artboard through one renderer
(Renderer::art_bounds_on, Renderer::effect_bounds), which keeps each
object's bounds for the pass, a group holding 3D art or a hidden
member included, so each solid is built once: 30 extruded type
objects over 30 artboards take about 2 ms, where measuring their
letters took under 1 ms and building each solid for each artboard
would take 70 ms. Objects with brushed strokes, which culling leaves
room for and exports don't, are measured on each artboard. The
Artboard tool's canvas menu keeps whether Fit to Artwork Bounds has
art to fit for the document's revision, where it measured it on
every frame it was open.
- Other exports, Object › Rasterize and changed() without a renderer
build the art on each call, as 3D paths and groups already did.
Exports and Rasterize now take the solid of 3D type, where they
cropped it to the letters, and the art its brushed strokes draw, not
the room culling leaves for it. Rasterize on drawn 3D art measures it
once while the art is kept.
- A shadow after a 3D effect, on the object or on a fill after the
fill's own 3D effect, reaches past the solid once; it was counted
twice.
- With Crop Marks or Vector Halftone, which draw other art, the object
is measured by that art, as before.
- Culling leaves room for a 3D object's brushed strokes as for any
object's, and the renderer measures a 3D object again when the brush
library changes: a brush widened past that room would leave the
object culled.
A document's first frame builds the solid of every 3D object, those off
the view too, to know whether it reaches into the view: 200 extruded
words with 150 off the view take about 12 ms, where measuring their
letters took 6 ms.
Type whose object effects leave it as it is (Revolve builds no art from
type) is measured by its own box grown to hold its glyphs, as plain
type is; it was measured by its box alone, which needn't hold them.
The reference check now applies wherever a painted effect's geometry is
used: a result whose swatch or pattern is refused keeps its input instead
of giving its geometry. Pathfinder art of type, reshaped groups, compound
shapes, image fills, the renderer's bounds and Object > Expand look the
references up in the document, and the renderer drops its kept bounds and
geometry when the names of the swatches or patterns change.
With Real-time Drawing and Editing off, each pointer move of a drag ran one
boolean union of a group's members to draw its outline. A group of 256
overlapping ellipses took seconds per move, and at 1,024 overlapping ellipses
the union went over its budget and no outline showed.
A move or handle drag now draws the outline of each visible member of a group
or intertwine, and of each object a blend, envelope, repeat, Pathfinder effect
or object effect evaluates to, without uniting them. A gradient mesh draws its
mesh lines and a symbol instance its bounds, as their selection highlights do.
The limit of 100,000 counts outline points and evaluated objects, so a
selection past it shows its moved bounds.
A compound shape or Pathfinder effect still evaluates its boolean on each move,
and so does a clip group whose clipping path is a group.
A path whose stroke has a gradient along or across it kept its slices under
the node's address, so every nudge made the slices again for the whole path,
although its stroke outline was already reused. The renderer now keeps the key
of a stroke's latest slices under the object's id, the stroke's place and the
tolerance level, and when the object has only moved (same stroke and gradient,
same fill rule, anchors moved by one offset) it draws those slices moved by the
offset, translating only the slices that reach the piece being clipped. Scale,
rotate, an anchor edit or a change to the stroke or its gradient makes the
slices again. The pixels are the same.
The moved-outline key is imported where it is used, and the outline is
stored through one helper, so the change touches fewer lines that other
work on the renderer also changes.
A path object that moves without changing shape drew its stroke by
outlining the whole line again, because the stroke outline cache is
keyed by the node. The renderer now keeps, per object, stroke and
outline width, the latest outline with the line it was made from. When
the new line is that line moved, it draws the kept outline moved by the
same offset, and moves the region a long path was outlined in with it.
Scaling, rotating or editing the path, changing the stroke's width,
join, cap, dashes or profile, a zoom that changes the outline's
tolerance, and a move that takes the view past the outlined region
still outline the stroke again. Only the latest outline of each stroke
keeps its line.
The renderer keeps the path of a path or compound path of 1,024 anchors
or more by object id, with the bounds of its segments and of its miter
spikes in runs of 128 segments. When anchors move and the subpaths and
anchor counts stay the same, the next frame rewrites only the path
elements of the segments that start or end at a moved anchor, and
measures again only the runs that hold them and the runs of the
segments with length before them. Other edits make the path again as
before. The pixels and the cull bounds are the same.
- StrokeLayer::bounds_on is unchanged. The miter tip of one joint
(miter_tip) and the stroke box with given tips (bounds_with_tips) are
new functions beside it, and Appearance::stroked_bounds_by takes the
box of each shaped stroke, so the cull bounds of a kept path use the
kept tips.
- geom::bez::has_length is the predicate reach.rs used for segments
that draw, made public.
Docs: docs/target-app-parity.md.
The renderer sized its worker pool from available_parallelism, which on
Windows counts every processor in the machine, also when the process's
affinity mask allows fewer. A process allowed one core started 8 workers,
and the renderer's flush spun on that core while the workers got no time,
so renders crawled or stalled.
The desktop app and vectorcraft-cli now read the affinity mask at startup
(src/windows_cores.rs, shared) and pass the count to the renderer with
vectorcraft_render::set_usable_cores. With one usable core the renderer
renders on the calling thread.
With undecoded-image marks off, an image in an opacity mask's art that
failed to draw left a hole in the mask. Without Clip, the area outside
the mask art counts as white, so the masked object showed in full.
The renderer now notes an image that fails to draw while mask art is
drawn and leaves the masked object out, as PDF export does since #4765.
This covers images in pattern tiles and in cached effect and shadow
rasters, which remember the failure and report it again when they are
reused. Nested masks pass the failure outward, and View Opacity Mask
shows no coverage for such a mask. An image still waiting to be decoded,
or drawn with the undecoded-image mark, keeps today's behavior.
Effect › Color Effects › Vector Halftone… (addon.color.halftone, also in
Object › Plug-ins › Color Effects) draws its object as the halftone dots
Object › Vector Halftone makes, live: mono (one dot colour, or each dot in
the art's colour under it) or CMYK screens, the five dot shapes,
frequency, angle, invert and clip to the art's outline.
- The screens, dots and caps move to vectorcraft_effects::addons::halftone,
shared by the command (its behaviour and tests unchanged) and the effect.
- The renderer samples the art (vectorcraft_render::addons::halftone) and
keeps the dots by the object's content and what it reads from the
document, so unchanged art isn't sampled again; past 100000 cells per
screen the object draws as it is.
- Expand Appearance turns the object into its dots, and the SVG, PDF, EPS
and AI exporters write them as paths.
- Its dialog reuses the command's fields, without Keep Original.
Deferred: stochastic and radial patterns, a dot-gain curve, per-screen
separation settings, type or symbols as dots.
Frame literals take both the type output transform and main's Separations Preview plate table. The Catalan catalog, now a complete one, gets the Anti-aliasing Method rows.
A layered .ai or Illustrator EPS whose editing data (embedded rasters,
mostly) unpacks past 512 MiB opened as its PDF part or printed page, in
one layer, with "it decompresses to more than 512 MB" (#4628 on 0.17.0
hit the older 256 MiB limit the same way).
The limit is now an eighth of installed memory, from 512 MiB (what every
64-bit build read before) to 2 GiB: 1 GiB on an 8 GiB machine, 2 GiB on
16 GiB or more. Reading takes about as much memory again as the data
(1.1 GB of data with 24 embedded 4096 x 4096 images peaked 1.1 GB above
the start), so the ceiling keeps a small file that unpacks without end
from taking a large machine's memory. 32-bit and web builds keep 256 MiB.
vectorcraft_render::installed_memory exposes the reading the image cache
already sizes itself from.
Brings in 8404fa42, which merges main e2a8280. The history budget keeps reading vectorcraft_render::physical_memory, now backed by main's Windows, macOS and FreeBSD readers.
On screen, placed documents (PDF, .ai and .vectorcraft) draw from
bitmaps made in the background. Each bitmap that became ready changed
a generation in the canvas key, so the canvas rendered the whole frame
again. The bitmaps share a 512 MiB budget, and making one dropped the
least recently drawn others, even those on screen: with more than that
on screen, every frame dropped a bitmap it drew and asked for it again,
without end. A bitmap that could not be made (the file can't be read
and there is no preview) also changed the generation and was asked for
again in every frame.
When a bitmap is ready, placed_document::made_between names its file,
and the canvas renders again only where the objects showing it are
(placed_area), as it does after an edit, when the frame shown was
rendered on the UI thread and that part is at most half the frame.
Art of a symbol, a graph design, a pattern or a brush that shows the
file still renders the whole frame.
Bitmaps drawn or made since a frame began are not dropped to make room
for the ones it asks for. They stay past the budget up to 2 GiB. A
bitmap that would take them past 2 GiB is not kept, and its file draws
exactly at that zoom. A bitmap that can't be made shows the
placeholder, does not change the generation, and is not asked for
again.
Docs: docs/target-app-parity.md.
A PNG, JPEG, GIF or WebP image that takes more than the decode
allowance as RGBA (2 GiB, 512 MiB in the web app), such as a 24000 ×
24000 JPEG, was placed with the warning "too large to draw" and then
drew as a crossed gray box on the canvas and was left out of raster
exports. A 16-bit PNG whose decoded samples were past the allowance
was shown the same way, with the same warning, although its RGBA fits.
The renderer now decodes such an image at the largest size, keeping its
proportions, that fits the allowance as RGBA. Each pixel of the result
is the mean of the image's pixels it covers. A PNG that isn't
interlaced is read a row at a time; other images are decoded whole when
their decoded samples fit the allowance. A 16-bit PNG that isn't
interlaced and whose RGBA fits is read a row at a time at its own size.
An image of more pixels than the allowance has bytes still draws as the
crossed box, and so does one whose decoded samples are past the
allowance, other than a PNG that isn't interlaced. The renderer
decodes an image at reduced size only while the result and the memory
reading it takes (the image decoded whole, or the PNG reader's row
buffers) fit beside the images being painted; otherwise the image is
not decoded on that render (on the canvas it draws as the crossed box)
and is tried again on the next render. The document keeps the whole
file for saving and export. A placed document's saved preview past the
allowance is decoded the same way, at the size it is drawn at or at the
reduced size when that is smaller.
Open, Place and the Links panel say "an image of W × H pixels is shown
at reduced size" for an image drawn smaller. They say nothing for an
image drawn at its own size, and they say "too large to draw" for one
that is not drawn at reduced size.
Docs: docs/mcp.md, docs/target-app-parity.md (the crossed box's line
now names an image over the allowance that can't be drawn at reduced
size).
Each document's undo history drops its oldest steps once they keep more
memory than a budget. The engine read the installed memory only on
Linux, so the budget was 1 GiB on Windows, macOS and FreeBSD, and an
eighth of the memory, at most 1 GiB, on Linux.
The default budget is now a quarter of the installed memory, with no
fixed ceiling and at least 64 MiB, read with the image store's reader,
which vectorcraft-render now exports as physical_memory. It stays
1 GiB where the memory can't be read and 256 MiB in the web build, and
a 32-bit build keeps at most a quarter of its address space.
Docs: docs/target-app-parity.md.
An image whose pixels can't be decoded, such as a PNG cut short by an
interrupted download, drew nothing on the canvas and the status bar
said nothing. Every render decoded it again, so each frame that drew it
paid for a decode that fails.
The renderer now notes such an image by its content and does not decode
it again. Each render still counts it in decode_failures, so an export
reports it as before. An image refused only because the images being
drawn leave it no room within twice the decoding allowance is not
noted, and the next render tries it again.
On the canvas the image draws as a light gray box crossed from corner
to corner, and the status bar says once for each image that it couldn't
be decoded. Exports still draw nothing there.
Docs: docs/target-app-parity.md.
Highlight Substituted Fonts is now a preference in Preferences › Type,
next to Highlight Alternate Glyphs, on by default and saved with the
other preferences (`prefs.set highlightSubstitutedFonts`). The canvas
reads it through `RenderOptions::highlight_substituted_fonts` for every
open document; a document's own setup no longer decides it. File ›
Document Setup no longer shows the checkbox and keeps Highlight
Substituted Glyphs.
A file saved with Document Setup's Highlight Substituted Fonts off now
shows the pink highlight when it opens, while the preference is on.
The file still opens with the stored value, and saving it again keeps
that value.
`document.setup` no longer reports `highlightSubstitutedFonts`. It
ignores the key and adds a `warnings` entry that names `prefs.set` to
its reply, so an older reply passed back still applies its other keys.
The raster cache of type under a raster effect now also redraws when
Highlight Alternate Glyphs changes.
After imageTrace.setView, screenshot and render_preview still drew the
tracing result, because ui.render renders with the export options and only
the canvas turns on trace views. Only the app window showed the view.
ui.render now takes traceViews. With traceViews: true, Image Trace objects
draw in the view set with imageTrace.setView, as on the canvas, both
headless and in the running app. screenshot and render_preview take
traceViews and pass it on; without it they draw the tracing result, as
exports do. The trace-and-style prompt names the argument.
A supersampled render drew Outline view's lines, type outlines and dotted
guides as little as a quarter of an output pixel wide, so they came out
pale gray. The renderer now scales those widths and the guides' dashes by
the supersampling factor in the larger frame, so the lines stay one output
pixel wide.
Docs: docs/mcp.md (render_preview, screenshot), docs/control-protocol.md
(ui.render).
`main` now passes `draw_text_geom` the kept glyph geometry as an `Arc`
and whether `texts` keeps it, so that character stroke outlines are
expanded once. `draw_type_edges` and `draw_type_pixels` pass both on to
their offscreen drawings, so None, Crisp and Strong type with a
character stroke expands the stroke once for both drawings, as Sharp
type does.
The new test `crisp_type_keeps_its_character_stroke_outline` checks
that one outline is kept and that the pixels match a renderer that
keeps no glyph geometry. `a_pan_draws_the_type_from_the_kept_pixels`
now holds `fonts_steady`, as the other tests of what a renderer keeps
between frames do.
The outlines of a run's character stroke are kept with the glyph geometry the renderer keeps for the type, in a byte-limited cache swept by frame, so type that changes in every frame (an animation) frees them within a few frames.
The Image Trace panel had no way to compare a trace with its source
image except changing View and changing it back.
The panel now has an eye button to the right of View, enabled with an
Image Trace object selected. While it is held down, the canvas draws the
selected Image Trace objects with their source image, whatever their
View, and draws their View again on release. The document, its View and
the undo history are unchanged. The renderer takes the objects in
RenderOptions::trace_source, which is also part of the canvas frame key
and the raster-effect cache key.
The renderer kept brush art per node id and stroke. The copies drawn
for symbol instances, inline graphics and repeat copies share their
art's ids, so they replaced each other's brush art and it was made
again in every frame. The pieces were drawn as plain nodes, so brush
art that is a live object, such as an envelope that a scatter brush
places, was evaluated again in every frame, for a path on the page too.
The brush cache now also keys brush art by the stroked path, so each
copy keeps its own. Kept pieces are drawn through the renderer's
caches: their stroke outlines, live-effect geometry and live object
evaluations are kept between frames. Each frame draws what a new
renderer draws. On one thread at 1000 x 1000 pixels, 2,000 paths on
the page whose scatter brush art is an envelope took 400 ms a frame on
main and take 94 ms, and the fastest frames of 2,000 instances of a
symbol whose art is a brushed path went from 16 ms to 12 ms, with the
same pixels.
Docs: docs/target-app-parity.md
CodeRabbit findings #32, #38, #41, #44, #102:
- A frame (and a PDF export) draws symbol instances holding at most 16M objects together
(`vectorcraft_doc::MAX_SYMBOL_NODES`): nested instances multiplied past the depth limits.
- A dotted guide whose control polygon would make more than 100,000 dashes is drawn solid.
- Groups blending with their backdrop, drawn twice each, are drawn isolated past 4 nested.
- An image is decoded only while it and the images paints hold fit twice the decode allowance.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
dotCooCoo