Scenario Blender Grease Pencil

Grease Pencil (v3, Blender 5.2)

Expert Grease Pencil work keeps every drawing editable and redrawable, puts meaning in the structure (which object, which layer, which key) and judges the result in motion. The agent draws through the data API (drawings are curves with attributes), builds characters the way 2D studios rig them, and reviews rendered frames instead of a viewport it cannot flip. If a sibling skill named here is missing from your available skills, ask the user to install it (npx skills add scenario-labs/skills --skill <name>); unattended, proceed from tool schemas and flag the gap.

REQUIRED BACKGROUND: scenario-blender-expert (execution channel, review loop, 5.2 API changes). Shot planning, boards and animatics: scenario-blender-previs-storyboard. Mesh animation principles: scenario-blender-animation.

Toolkit: scripts/bx_gp.py (tested on 5.2.1). import sys; sys.path.append("<this skill>/scripts"); import bx_gp as G.

Stance (the expert delta)

• Tom Viguier (Andarta, Ewilan's Quest): the rig must never block redrawing. One GP object per physical element (about 60 for a lead character), parented, mostly FK by object transforms; layers inside each element by graphic logic (line above color); sculpting as the deformer; no armature weight painting on drawings, because every redraw would need new weights.
• Tom: interpolate only "sculpted" pairs. Two keys interpolate cleanly only with the same number, order and color of strokes and the same points. Otherwise redraw, or "clip" to the nearest drawing instead of accepting distortion. Native interpolation ignores object animation: key transforms separately.
• Falk David (GP module lead): fill is geometry, not material. A stroke fills when fill_id != 0; strokes sharing an id fill together with even-odd holes; hide_stroke hides the outline. Material fill toggles are deprecated and holdout "eraser fills" (Grant Abbitt's 4.4 method) are obsolete.
• Grant Abbitt: the layer stack carries meaning and materials are paint buckets. Lines on top, a shadow layer (Multiply, lowered opacity, masked by the fills) in between, fills at the bottom. Editing a material recolors every stroke using it. Lock what you are not editing: erasers and sculpt act on all unlocked layers.
• Elijah Sheffield: predictable color first. Standard view transform, flat unlit shading, white world. Verified trap: new layers have use_lights=True, and lit layers take their ambient from World.color (default 0.05), not from the world node tree, so a flat palette renders at about a quarter of its value.
• Tom: multiplane discipline and layout first. Every 2D element parallel to the camera, a camera that never changes axis, 3D only where it saves time; camera, cuts and parallax are settled in layout, not discovered in compositing. Between objects, depth decides who draws on top.
• Michael Weigl: motion reveals the surface. A painterly still breaks once it moves; judge 2.5D as a sequence. Sort groups of strokes (mesh islands), never individual strokes, and bake procedural output back to editable strokes.
• Pablo Fournier (Blender Studio): design the shadows. Replace blobby 3D shading with blocky, drawn light and shadow shapes (a light and a shadow material per part). Fills are flat: use many small fills on curved surfaces, not one big fill pushed forward.

Establish first

Workflow

1. Stage and layout. cam = G.scene_2d(res, fps, frame_range, ortho_scale) (ortho camera at -Y, Standard, background). Plan the multiplane: which elements are separate objects and their depth order. Compute px = G.px_size(); line width in pixels is 2 * radius / px. GATE: a test render shows the frame; planned line widths are at least 1.5 px [added].
2. Structure. G.new_object(name, layers=("Fills", "Shadow", "Lines")) per element (bottom to top, unlit), parent parts, place origins at joints. G.material(ob, name, stroke=hex, fill=hex) once per bucket. GATE: [l.name for l in ob.data.layers] matches intent; G.draw_order(objs) lists front to back as designed.
3. Draw. Keys first: d = G.key(ob, "Lines", frame). Lines: G.add_stroke(d, G.smooth_path(control_pts), radius, pressure=G.taper(n), brush="INK_PEN", material=i); overlap then trim rather than landing ends exactly (Grant). Fills: G.add_shape(d, outline, holes=[...], material=i) on the Fills layer, outline on Lines. Bulk: G.add_strokes(d, specs) (3000 strokes in 0.04 s). Fix shapes with G.grab, G.dissolve, G.edit_op(ob, "stroke_smooth", ...). GATE: G.verdict(G.report(ob)) is clean and a full-resolution G.render_frame shows no gaps, leaks or overhangs.
4. Color and shadow. Shadow layer: blend_mode='MULTIPLY', opacity lowered, use_masks=True, mask_layers.add(fills); paint the shadow shape past the edge and let the mask clip it; design it blocky (Pablo). Lit look: use_lights=True plus World.color as ambient plus lamps (verified: a sun only scales value on a flat drawing, a point light gives a gradient). GATE: sampled pixels match the palette under Standard.
5. Animate. Replacement key G.key(..., mode="blank"), additive mode="copy", hold or cycle mode="instance" / G.cycle(...), end an exposure with G.end_exposure. Every visible layer needs a key at or before frame_start (Elijah). Cutout motion: key object transforms (FK). In-betweens: check G.match(dA, dB), then G.interpolate(ob, layer, frame, step=2, type, easing) (native, segment around frame) or G.inbetween(ob, layer, a, b, frames, spacing=[...] or ease=...) for the animator's own spacing, clip=True when the pair is different. GATE: G.exposures(ob, layer) per layer, G.render_strip(path, frames) read left to right for timing and pops, G.onion(path, frame, before, after) for arcs and spacing.
6. 2.5D (optional). Outlines: G.lineart(source, radius=width_m) (the modifier radius is the line width). Strokes on meshes: G.project_to_surface(pts, mesh) and discard strokes with missed or occluder-captured points (Pablo's failure modes). Relight: G.relight(ob, canvas, light_dir, shadow, light). Procedural strokes: Geometry Nodes Curves to Grease Pencil with Instances as Layers off and a fill_id attribute, then apply to bake (procedures P7). Depth reorder without changing the image: G.push_depth(ob, delta). GATE: a moving render (strip or playblast) where the surface does not read as 3D (Weigl) and fills do not poke through (Pablo).
7. Deliver. Render frames or video with the scene camera; keep the .blend editable (no applied procedural stage the animator still needs). GATE: every object's verdict clean, strip and final frames looked at, list what was not verified.