zaniah 0.8.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0e4185eb60f475f07fb3deee4bf07f0e7e16240771ee9199f9783d3fe13130cb
-  data.tar.gz: 05cafb090e57d8552cda0826d8db0ff1fa980107eab05ab9841824d6a18187c6
+  metadata.gz: cc06ae1720a8d05abbc0da78849a355f7c36565c62b3907f941c80dd066594c5
+  data.tar.gz: fd00f6d9bd08c097a5ffa35ce079a83f949c07874d6ff7c76cdc802f7ddd8129
 SHA512:
-  metadata.gz: e5da9a69b48d186dcb04cf71cf48922d9e72fd019ff54919451f028cc211262fd8c49ecf85eb6dbbfd8b48213ad324ab98aefc9079473ace7d8a289401079ae4
-  data.tar.gz: f2b7ada32c16d932143db6cf68a9c2073e085ef0cda762aa7ed2f07ae7fdee5b9d5b1f5c3a5289b5fc54930fab9dbef1c0720e8035656c8ac700a2904012f431
+  metadata.gz: 769bfa73b348d773f2139eb34039a7250f6878986375bdd25c361c3922b16d61ab68a3d14c59f8ef7f3cfd68e04a43d868286b624d1996d2fc2afdb92b23f861
+  data.tar.gz: a9642fa580bd9595e15c48903e698b95dfc5a6f876ca0d71438e488899522e2855351cef18a124e005dae5636e53b500aa46e90e101575c12796fc4e9ae80992

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## 0.9.0 — 2026-09-24
+
+- Add semantic vector recording for UI scenes, including text, images, and raster fallbacks for unsupported drawing.
+- Render shadows analytically across backends; their edge appearance changes from earlier releases.
+- Add shared multi-stop and conic gradient ramps across Software, OpenGL, Metal, and Vulkan rendering.
+- Support SVG gradients, dashed strokes, and alpha and luminance masks.
+
 ## 0.8.0 — 2026-09-24
 
 - Add native macOS and Windows menus, declarative context menus, and platform-aware shortcut labels.

data/docs/adr/005-instance-layout.md

@@ -26,10 +26,10 @@ fields for source UVs. Triangle vertices reuse rect and radii fields.
 | 32–37 | affine transform (`a,b,c,d,tx,ty`) | affine transform |
 | 38–39 | reserved shadow spread / inset or border flags | unused |
 
-Opacity is multiplied into both fill and border alpha before packing. Linear
-and radial gradients use exactly two stops; a future multi-stop implementation
-may use a 1D texture without another stride change. Shadows are expanded into
-ordinary quad instances, so the reserved shadow fields remain available.
+Opacity is multiplied into both fill and border alpha before packing. The
+original two-stop and expanded-quad behavior has since been extended without
+changing this layout: see [ADR 017](017-analytic-shadows.md) for the shadow
+fields and [ADR 018](018-gradient-ramps.md) for multistop ramps and conic fills.
 
 Metal, OpenGL, and Vulkan consume the layout directly, Software consumes the
 equivalent 40-float quad layout, and cached text sprite batches use the same

data/docs/adr/016-semantic-vector-recording.md

@@ -0,0 +1,33 @@
+# ADR 016: Record semantic drawing alongside the GPU scene
+
+- Status: Proposed
+- Date: 2026-09-24
+
+## Context
+
+The GPU scene contains packed quads and atlas sprites. Paths have already been
+rasterized and text has lost its font, glyph IDs, and source clusters by the
+time a renderer consumes those commands. Exporters need this information to
+produce searchable text and scalable artwork. Reconstructing it from packed
+GPU instances is impossible; maintaining a second application-specific layout
+for export makes screen and export drift.
+
+Two viable boundaries were considered: make the GPU scene itself semantic, or
+keep its fast packed representation and optionally observe the drawing calls.
+
+## Decision
+
+Keep the GPU scene unchanged and attach an optional vector sink to `Scene`.
+Emit semantic commands before paths and text are flattened. When a source has
+no supported vector form, preserve its pixels as a raster command instead.
+The sink is absent by default, so normal frames do not allocate vector data.
+Page assembly and document formats remain outside Zaniah.
+
+## Consequences
+
+Exporters can reuse the same element tree and retain font and outline data
+without adding a dependency on a PDF library. The optional path incurs a
+nil check when unused and stores additional frame data when enabled. Raster
+fallbacks keep output complete but cannot scale as cleanly as true vectors.
+This choice should be revisited if packed GPU commands become a lossless
+semantic representation or a common display list can serve both consumers.

data/docs/adr/017-analytic-shadows.md

@@ -0,0 +1,31 @@
+# ADR 017: Draw each shadow as one analytic instance
+
+- Status: Accepted
+- Date: 2026-09-24
+
+## Context
+
+The previous shadow approximation layered eight rounded quads. It produced
+visible bands and made a scene with 100 shadows submit 800 instances.
+
+## Decision
+
+Keep the 40-float instance layout from ADR 005. Primitive kind `4` in field 31
+is a shadow; field 30 is blur sigma, field 38 is spread, and field 39 is the
+inset flag. Bounds 0–3 are expanded by `spread + 3 * blur + 1` for outer
+shadows. Inset shadows retain the original bounds. Corner radii occupy 12–15.
+
+Software and all three GPU fragment shaders evaluate the signed distance to
+the original rounded rectangle. A Gaussian edge is approximated by
+`0.5 - 0.5 * erf((distance - spread) / (sqrt(2) * blur))`, using the same bounded
+exponential approximation of `erf` in every backend. Zero blur uses direct
+coverage. Inset shadows multiply interior coverage by the inverted transition.
+The existing clipping, transforms, and alpha blending remain unchanged.
+
+## Consequences
+
+Shadow appearance intentionally changes; the golden images and changelog must
+record this. `bench/shadow.rb` compares 100 shadows against the old eight-quad
+approximation and requires the analytic Software path to be faster. GPU native
+capture tests remain platform-dependent; `script/compile_shaders` regenerates
+the bundled Vulkan SPIR-V from the checked-in GLSL.

data/docs/adr/018-gradient-ramps.md

@@ -0,0 +1,30 @@
+# ADR 018: Use bounded ramps for multistop gradients
+
+- Status: Accepted
+- Date: 2026-09-24
+
+## Context
+
+The shared instance format carries only two inline stop colors. Extending its
+stride would affect every renderer and text/sprite packing.
+
+## Decision
+
+Two-stop linear and radial gradients retain their inline color path. Two-stop
+conic gradients use kind `3` and the same interpolation path. Three or more
+stops use kinds `4` (linear), `5` (radial), or `6` (conic), and one row of a
+256-by-256 RGBA8 atlas baked from the ordered stops. Field 8 stores the row
+index; all renderers sample that row at the calculated gradient position. A
+`Scene` caches rows by immutable `Gradient` value in an LRU capped at 256
+entries. Rows used in the current frame cannot be evicted; if a frame exceeds
+256 distinct ramps, it uses reusable overflow atlases for the remainder of
+that frame. Normal quads continue to use packed-byte fast paths; only ramp
+quads need texture-aware batching.
+
+## Consequences
+
+No instance layout migration is required. Sampling precision is limited to
+256 positions. Adjacent ramps on the shared atlas batch together, while
+overflows can add batches. SVG gradient fills use the same ordered-stop
+interpolation semantics and fall back to a raster snapshot in vector recording
+because a `Vector::Path` currently stores solid fills only.

data/docs/vector.md

@@ -0,0 +1,60 @@
+# Vector recording
+
+Zaniah records the drawing it already performs without taking ownership of PDF
+pages, paper sizes, or export dialogs. Require `zaniah/vector` and render a normal
+element tree offscreen:
+
+```ruby
+document = Zaniah::Vector.record(width: 960, height: 540,
+  theme: Zaniah::Theme.light) { slide }
+document.commands.each { |command| export_command(command) }
+```
+
+To inspect a displayed frame, attach a recorder before rendering. `Scene#clear`
+resets its commands each frame; save `recorder.document` before the next frame.
+
+```ruby
+recorder = Zaniah::Vector::Recorder.new
+window.scene.vector_sink = recorder
+window.tick
+document = recorder.document
+window.scene.vector_sink = nil
+```
+
+`Document#width` and `#height` are logical pixels. A `Recorder` attached to a
+window receives that window's content size; a recorder attached to a bare
+`Scene` may instead be initialized with `width:` and `height:`. Coordinates use
+a top-left origin and downward y axis; colors are sRGB. Every command carries
+its transform, clip, opacity, layer, and sequence. `Document#commands` is sorted
+by layer and then sequence, matching `Scene#each_command`.
+
+| Command | Export information |
+|---|---|
+| `Quad` | Bounds, fill color or gradient, corner radii, border widths/color/style |
+| `Shadow` | Bounds, corner radii, color, blur, spread, inset |
+| `Path` | Alhena outline, fill, stroke, stroke width, fill rule and stroke cap/join |
+| `GlyphRun` | Alhena font, size, `[glyph_id, x, baseline_y]` triples, original text and UTF-8 byte clusters |
+| `Image` | Decoded `Zaniah::Image`, bounds and source rectangle, plus a frozen pixel snapshot |
+| `Underline` | Position, thickness and wave flag |
+| `Raster` | Frozen source texture bytes, pixel dimensions/format, tint and source rectangle |
+
+Ordinary sprites and packed sprite batches become `Raster`; bitmap-color text
+uses that fallback for the whole line. Simple SVG fills and strokes become
+`Path` commands. SVG clipping, gradients, dash arrays, masks, group opacity,
+and references use a `Raster`
+fallback, so they are not silently omitted. The `Raster` bytes are a snapshot
+at recording time, even if the source texture changes later. The converter must
+crop to `source`, apply `color` and `opacity`, then respect `transform` and
+`clip`. It may rasterize a `Path` or `GlyphRun` when its output format lacks
+an equivalent vector primitive.
+
+The headless offscreen API works on every OS and does not require a GPU.
+Attaching a recorder to macOS, Windows, X11, or Wayland uses the same `Scene`
+path. The TUI backend captures its terminal cells as a single `Raster` fallback
+at an 8-by-20 cell grid, using a bundled font approximation; terminal font
+appearance is outside Zaniah's control. Use the offscreen API when scalable
+text is required.
+
+See [ADR 016](adr/016-semantic-vector-recording.md) for why this is separate
+from the GPU command stream. [Vector and list](vector_and_list.md) documents
+the SVG input subset.

data/docs/vector_and_list.md

@@ -13,15 +13,24 @@ icon = Zaniah::SVG.parse(
 ```
 
 The renderer supports SVG paths, basic shapes, groups, transforms, view boxes,
-inherited fill and stroke, `currentColor`, opacity, local `defs`/`use`, and
-user-space clip paths. It is intended for static icons, not arbitrary web SVG.
+inherited fill and stroke, `currentColor`, opacity, local `defs`/`use`,
+user-space clip paths, linear/radial gradients, stroke dash arrays and offsets,
+and local alpha/luminance masks. It is intended for static icons, not arbitrary
+web SVG.
 
-Scripts, external references, CSS stylesheets, gradients, filters, masks, images,
-text, markers, dash arrays, nested viewports, and object-bounding-box clips are
+Scripts, external references, CSS stylesheets, filters, images,
+text, markers, nested viewports, and object-bounding-box clips are
 unsupported and raise `ArgumentError`. Input is bounded to 2 MiB, 10,000 XML
 nodes, 64 levels, and 100,000 path operations; each output texture is limited to
 one megapixel.
 
+SVG gradients support ordered stops, local references, `objectBoundingBox` and
+`userSpaceOnUse` coordinates, and the default pad spread. Other spread methods
+and external references remain unsupported. Masks rasterize within the same
+one-megapixel output limit. Gradient, dashed, and masked shapes are represented
+as a `Vector::Raster` fallback when recording; simple solid outlines remain
+`Vector::Path` commands.
+
 ## Variable-height lists
 
 ```ruby

data/examples/metal_effect_check.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "../lib/zaniah"
+abort "This check needs macOS and a graphical login" unless RUBY_PLATFORM.include?("darwin")
+
+window = Zaniah::Platform.open_window(backend: :mac, gpu: :metal, width: 96, height: 72,
+  title: "Metal effect check")
+begin
+  scene = Zaniah::Scene.new
+  scene.quad(4, 4, 30, 24, color: Zaniah::Gradient.linear(angle: 0,
+    stops: [[0, "#f00"], [0.5, "#0f0"], [1, "#00f"]]))
+  scene.quad(38, 4, 30, 24, color: Zaniah::Gradient.conic(stops: [[0, "#f00"], [1, "#00f"]]))
+  scene.shadow(28, 40, 32, 18, color: "#000", blur: 3, spread: 1, radius: 4)
+  expected = Zaniah::GPU::Software.new(96, 72).render(scene, clear: "#fff")
+  window.device.render(scene, clear: "#fff")
+  actual = window.device.pixels
+  scale = window.scale_factor
+  pixel_width = (96 * scale).round
+  samples = [[6, 15], [18, 15], [31, 15], [60, 16], [22, 49], [28, 49], [44, 49], [75, 49]]
+  samples.each do |x, y|
+    index = (y * 96 + x) * 4
+    native_index = (((y + 0.5) * scale).floor * pixel_width + ((x + 0.5) * scale).floor) * 4
+    left, right = expected.byteslice(index, 4).bytes, actual.byteslice(native_index, 4).bytes
+    raise "effect mismatch at #{x},#{y}: #{right.inspect} != #{left.inspect}" unless
+      left.zip(right).all? { |a, b| (a - b).abs <= 8 }
+  end
+  puts "Metal analytic shadow and gradient check: #{samples.length} samples passed"
+ensure
+  window.close
+end

data/lib/zaniah/gpu/instance_packing.rb

@@ -17,6 +17,7 @@ module Zaniah
           case kind
           when :quad
             q, i = scene.quads, offset
+            texture = scene.quad_texture(offset)
             data.push(q[i], q[i+1], q[i+2], q[i+3], q[i+4], q[i+5], q[i+6], q[i+7],
               q[i+8], q[i+9], q[i+10], q[i+11], q[i+12], q[i+13], q[i+14], q[i+15],
               q[i+16], q[i+17], q[i+18], q[i+19], q[i+20], q[i+21], q[i+22], q[i+23],
@@ -64,6 +65,7 @@ module Zaniah
         expected = 0
         scene.each_command do |kind, offset, clip|
           return unless kind == :quad && offset == expected
+          return if scene.quad_texture(offset)
           if batches.empty? || batches.last[0][2] != clip
             batches << [[:quad, nil, clip], expected / STRIDE, 1]
           else

data/lib/zaniah/gpu/metal.rb

@@ -20,7 +20,7 @@ module Zaniah
         using namespace metal;
         struct Vertex { float4 position [[position]]; float2 local; float2 size;
           float4 color; float4 secondary; float4 radii; float4 border; float4 widths;
-          float4 gradient; float4 center_kind; float2 uv; float dash; };
+          float4 gradient; float4 center_kind; float2 uv; float dash; float spread; };
         vertex Vertex zaniah_vertex(uint v [[vertex_id]], uint instance [[instance_id]],
             const device float *data [[buffer(0)]], constant float2 &viewport [[buffer(1)]]) {
           const device float *p = data + instance * 40;
@@ -37,17 +37,26 @@ module Zaniah
           out.radii = float4(p[12],p[13],p[14],p[15]); out.border = float4(p[16],p[17],p[18],p[19]);
           out.widths = float4(p[20],p[21],p[22],p[23]); out.gradient = float4(p[24],p[25],p[26],p[27]);
           out.center_kind = float4(p[28],p[29],p[30],p[31]);
-          out.uv = float2(p[20],p[21]) + corner * float2(p[22],p[23]); out.dash = p[39]; return out;
+          out.uv = float2(p[20],p[21]) + corner * float2(p[22],p[23]); out.dash = p[39]; out.spread = p[38]; return out;
+        }
+        float approx_erf(float value) {
+          float square = value * value;
+          return sign(value) * sqrt(1.0f - exp(-square * (1.27323954474f + 0.147f * square) / (1.0f + 0.147f * square)));
         }
         fragment float4 zaniah_fragment(Vertex in [[stage_in]], texture2d<float> atlas [[texture(0)]]) {
           float4 color = in.color;
           if (in.center_kind.w == 0) {
             if (in.gradient.x > 0) {
               float2 normalized = in.local / in.size;
-              float raw = in.gradient.x == 1
+              float raw = in.gradient.x == 1 || in.gradient.x == 4
                 ? dot(normalized - 0.5f, float2(cos(in.gradient.w * 0.01745329252f), sin(in.gradient.w * 0.01745329252f))) + 0.5f
-                : length(normalized - in.center_kind.xy) / in.center_kind.z;
-              color = mix(in.color, in.secondary, clamp((raw - in.gradient.y) / max(in.gradient.z - in.gradient.y, 0.000001f), 0.0f, 1.0f));
+                : in.gradient.x == 2 || in.gradient.x == 5 ? length(normalized - in.center_kind.xy) / in.center_kind.z
+                : fract((atan2(normalized.y - in.center_kind.y, normalized.x - in.center_kind.x) - in.gradient.w * 0.01745329252f) / 6.28318530718f + 1.0f);
+              float amount = clamp((raw - in.gradient.y) / max(in.gradient.z - in.gradient.y, 0.000001f), 0.0f, 1.0f);
+              constexpr sampler gradient_sampler(coord::normalized, address::clamp_to_edge, filter::nearest);
+              float2 ramp_uv = float2((floor(amount * 255.0f + 0.5f) + 0.5f) / 256.0f, (in.secondary.x + 0.5f) / 256.0f);
+              color = in.gradient.x >= 4 ? atlas.sample(gradient_sampler, ramp_uv) * float4(1.0f,1.0f,1.0f,in.color.a)
+                : mix(in.color, in.secondary, amount);
             }
             float radius = in.local.y < in.size.y/2 ? (in.local.x < in.size.x/2 ? in.radii.x : in.radii.y) : (in.local.x < in.size.x/2 ? in.radii.w : in.radii.z);
             radius = clamp(radius, 0.0f, min(in.size.x,in.size.y)/2);
@@ -60,6 +69,19 @@ module Zaniah
             float coordinate = edge == edge_distance.x || edge == edge_distance.z ? in.local.x : in.local.y;
             if (border_width > 0 && distance >= -border_width && !(in.dash == 1 && fmod(coordinate,6.0f) >= 3.0f)) color = in.border;
             color.a *= coverage;
+          } else if (in.center_kind.w == 4) {
+            float margin = in.dash == 1 ? 0.0f : in.spread + in.center_kind.z * 3.0f + 1.0f;
+            float2 original_size = in.size - 2.0f * margin;
+            float2 p = in.local - margin;
+            float radius = p.y < original_size.y/2.0f ? (p.x < original_size.x/2.0f ? in.radii.x : in.radii.y) : (p.x < original_size.x/2.0f ? in.radii.w : in.radii.z);
+            radius = clamp(radius, 0.0f, min(original_size.x,original_size.y)/2.0f);
+            float2 q = abs(p - original_size/2.0f) - original_size/2.0f + radius;
+            float distance = length(max(q,0.0f)) + min(max(q.x,q.y),0.0f) - radius;
+            float sigma = in.center_kind.z;
+            float coverage = in.dash == 1
+              ? clamp(0.5f - distance, 0.0f, 1.0f) * (sigma == 0.0f ? clamp(distance + in.spread + 0.5f, 0.0f, 1.0f) : 0.5f + 0.5f * approx_erf((distance + in.spread) / (sigma * 1.41421356237f)))
+              : sigma == 0.0f ? clamp(0.5f - distance + in.spread, 0.0f, 1.0f) : 0.5f - 0.5f * approx_erf((distance - in.spread) / (sigma * 1.41421356237f));
+            color.a *= coverage;
           } else if (in.center_kind.w == 1 || in.center_kind.w == 2) {
             constexpr sampler texture_sampler(coord::normalized, address::clamp_to_edge, filter::nearest);
             float4 sample = atlas.sample(texture_sampler,in.uv);

data/lib/zaniah/gpu/open_gl.rb

@@ -23,7 +23,7 @@ module Zaniah
         uniform vec2 viewport;
         out vec2 local_position; out vec2 size; out vec4 color; out vec4 radii;
         out vec4 secondary; out vec4 border; out vec4 widths; out vec4 gradient;
-        out vec4 center_kind; out vec2 uv; out float dash;
+        out vec4 center_kind; out vec2 uv; out float dash; out float spread;
         void main() {
           vec2 vertices[4] = vec2[4](vec2(0,0),vec2(1,0),vec2(0,1),vec2(1,1));
           vec2 corner = vertices[gl_VertexID];
@@ -35,25 +35,35 @@ module Zaniah
           local_position = corner * rect.zw; size = rect.zw; color = tint;
           secondary = tint2; radii = corners; border = border_color; widths = edges_source;
           gradient = gradient_data; center_kind = gradient_center_kind;
-          uv = edges_source.xy + corner * edges_source.zw; dash = translation_flags.w;
+          uv = edges_source.xy + corner * edges_source.zw; dash = translation_flags.w; spread = translation_flags.z;
         }
       GLSL
       FRAGMENT = <<~GLSL.freeze
         #version 330 core
         in vec2 local_position; in vec2 size; in vec4 color; in vec4 radii;
         in vec4 secondary; in vec4 border; in vec4 widths; in vec4 gradient;
-        in vec4 center_kind; in vec2 uv; in float dash;
+        in vec4 center_kind; in vec2 uv; in float dash; in float spread;
         uniform sampler2D atlas;
         out vec4 output_color;
+        float approx_erf(float value) {
+          float square = value * value;
+          return sign(value) * sqrt(1 - exp(-square * (1.27323954474 + 0.147 * square) / (1 + 0.147 * square)));
+        }
         void main() {
           vec4 result = color;
           if (center_kind.w == 0) {
             if (gradient.x > 0) {
               vec2 normalized = local_position / size;
-              float raw = gradient.x == 1
+              float raw = gradient.x == 1 || gradient.x == 4
                 ? dot(normalized - 0.5, vec2(cos(radians(gradient.w)), sin(radians(gradient.w)))) + 0.5
-                : length(normalized - center_kind.xy) / center_kind.z;
-              result = mix(color, secondary, clamp((raw - gradient.y) / max(gradient.z - gradient.y, 0.000001), 0, 1));
+                : gradient.x == 2 || gradient.x == 5 ? length(normalized - center_kind.xy) / center_kind.z
+                : fract((atan(normalized.y - center_kind.y, normalized.x - center_kind.x) - radians(gradient.w)) / 6.28318530718 + 1.0);
+              float amount = clamp((raw - gradient.y) / max(gradient.z - gradient.y, 0.000001), 0, 1);
+              if (gradient.x >= 4) {
+                vec2 ramp_uv = vec2((floor(amount * 255.0 + 0.5) + 0.5) / 256.0, (secondary.x + 0.5) / 256.0);
+                vec4 sample_color = texture(atlas, ramp_uv);
+                result = vec4(sample_color.rgb, sample_color.a * color.a);
+              } else result = mix(color, secondary, amount);
             }
             float radius = local_position.y < size.y/2 ? (local_position.x < size.x/2 ? radii.x : radii.y) : (local_position.x < size.x/2 ? radii.w : radii.z);
             radius = clamp(radius, 0, min(size.x,size.y)/2);
@@ -66,6 +76,19 @@ module Zaniah
             float coordinate = edge == edge_distance.x || edge == edge_distance.z ? local_position.x : local_position.y;
             if (border_width > 0 && distance >= -border_width && !(dash == 1 && mod(coordinate,6) >= 3)) result = border;
             result.a *= coverage;
+          } else if (center_kind.w == 4) {
+            float margin = dash == 1 ? 0 : spread + center_kind.z * 3 + 1;
+            vec2 original_size = size - 2 * margin;
+            vec2 p = local_position - margin;
+            float radius = p.y < original_size.y/2 ? (p.x < original_size.x/2 ? radii.x : radii.y) : (p.x < original_size.x/2 ? radii.w : radii.z);
+            radius = clamp(radius, 0, min(original_size.x,original_size.y)/2);
+            vec2 q = abs(p - original_size/2) - original_size/2 + radius;
+            float distance = length(max(q,0)) + min(max(q.x,q.y),0) - radius;
+            float sigma = center_kind.z;
+            float coverage = dash == 1
+              ? clamp(0.5 - distance, 0, 1) * (sigma == 0 ? clamp(distance + spread + 0.5, 0, 1) : 0.5 + 0.5 * approx_erf((distance + spread) / (sigma * 1.41421356237)))
+              : sigma == 0 ? clamp(0.5 - distance + spread, 0, 1) : 0.5 - 0.5 * approx_erf((distance - spread) / (sigma * 1.41421356237));
+            result.a *= coverage;
           } else if (center_kind.w == 1 || center_kind.w == 2) {
             vec4 sample_color = texture(atlas,uv);
             if (center_kind.w == 1) result.a *= sample_color.r; else result *= sample_color;

data/lib/zaniah/gpu/software.rb

@@ -27,7 +27,7 @@ module Zaniah
         scene.each_command do |kind, offset, clip|
           bounds = clip ? @viewport.intersect(clip) : @viewport
           case kind
-          when :quad then draw_quad(scene.quads, offset, bounds)
+          when :quad then draw_quad(scene, offset, bounds)
           when :sprite then draw_sprite(scene, offset, bounds)
           when :sprite_batch
             first, count = scene.expand_sprite_batch(offset)
@@ -43,8 +43,9 @@ module Zaniah
 
       private
 
-      def draw_quad(data, offset, clip)
-        values = data.slice(offset, Scene::QUAD_STRIDE)
+      def draw_quad(scene, offset, clip)
+        values = scene.quads.slice(offset, Scene::QUAD_STRIDE)
+        return draw_shadow(values, clip) if values[31] == 4
         x, y, width, height = values.first(4)
         color, secondary = values[4, 4], values[8, 4]
         radii, border_color, borders = values[12, 4], values[16, 4], values[20, 4]
@@ -59,12 +60,13 @@ module Zaniah
         end
         gradient = gradient_parameters(gradient)
         if matrix == Transform.identity && borders.all?(&:zero?) && radii.all?(&:zero?) &&
-            color[3] == 1 && secondary[3] == 1 && gradient[0].positive? &&
+            color[3] == 1 && secondary[3] == 1 && (1..2).cover?(gradient[0]) &&
             [x, y, width, height].all? { |value| value == value.to_i }
           fill_cached_gradient(bounds, x.to_i, y.to_i, width.to_i, height.to_i, color, secondary, gradient)
           return
         end
         inverse = matrix.inverse
+        ramp_data = scene.quad_texture(offset)&.data
         top, bottom = [bounds.y.floor, 0].max, [bounds.bottom.ceil, @height].min
         left, right = [bounds.x.floor, 0].max, [bounds.right.ceil, @width].min
         pixel_y = top
@@ -80,7 +82,14 @@ module Zaniah
             distance = Math.sqrt([quad_x, 0].max**2 + [quad_y, 0].max**2) + [[quad_x, quad_y].max, 0].min - radius
             coverage = (0.5 - distance).clamp(0, 1)
             if coverage.positive?
-              fill = gradient[0].zero? ? color : mix(color, secondary, gradient_offset(gradient, local_x, local_y, width, height))
+              fill = if gradient[0].zero?
+                color
+              elsif ramp_data
+                ramp_index = (secondary[0].to_i * 256 + (gradient_offset(gradient, local_x, local_y, width, height) * 255).round) * 4
+                4.times.map { |index| ramp_data.getbyte(ramp_index + index) / 255.0 }.tap { |sample| sample[3] *= color[3] }
+              else
+                mix(color, secondary, gradient_offset(gradient, local_x, local_y, width, height))
+              end
               edge = [local_y, width - local_x, height - local_y, local_x].each_with_index.min_by(&:first).last
               border = borders[edge]
               dashed = values[39] == 1 && ((edge.odd? ? local_y : local_x) % 6) >= 3
@@ -93,6 +102,45 @@ module Zaniah
         end
       end
 
+      def draw_shadow(values, clip)
+        x, y, width, height = values.first(4)
+        color, radii = values[4, 4], values[12, 4]
+        blur, spread, inset = values[30], values[38], values[39] == 1
+        return if inset && blur.zero? && spread.zero?
+        matrix = Transform.new(*values[32, 6])
+        inverse = matrix.inverse
+        bounds = transformed_bounds(x, y, width, height, matrix).intersect(clip)
+        margin = inset ? 0 : spread + blur * 3 + 1
+        origin_x, origin_y = x + margin, y + margin
+        content_width, content_height = width - margin * 2, height - margin * 2
+        top, bottom = [bounds.y.floor, 0].max, [bounds.bottom.ceil, @height].min
+        left, right = [bounds.x.floor, 0].max, [bounds.right.ceil, @width].min
+        (top...bottom).each do |pixel_y|
+          (left...right).each do |pixel_x|
+            point = inverse.apply(Point.new(pixel_x + 0.5, pixel_y + 0.5))
+            local_x, local_y = point.x - origin_x, point.y - origin_y
+            radius = local_y < content_height / 2.0 ? (local_x < content_width / 2.0 ? radii[0] : radii[1]) : (local_x < content_width / 2.0 ? radii[3] : radii[2])
+            radius = radius.clamp(0, [content_width, content_height].min / 2.0)
+            qx = (local_x - content_width / 2.0).abs - content_width / 2.0 + radius
+            qy = (local_y - content_height / 2.0).abs - content_height / 2.0 + radius
+            distance = Math.hypot([qx, 0].max, [qy, 0].max) + [[qx, qy].max, 0].min - radius
+            coverage = if inset
+              inside = (0.5 - distance).clamp(0, 1)
+              inside * (blur.zero? ? (distance + spread + 0.5).clamp(0, 1) : (0.5 + 0.5 * erf_approx((distance + spread) / (blur * Math.sqrt(2)))))
+            else
+              blur.zero? ? (0.5 - distance + spread).clamp(0, 1) : (0.5 - 0.5 * erf_approx((distance - spread) / (blur * Math.sqrt(2))))
+            end
+            blend(pixel_x, pixel_y, *color.first(3), color[3] * coverage) if coverage.positive?
+          end
+        end
+      end
+
+      def erf_approx(value)
+        sign = value.negative? ? -1 : 1
+        square = value * value
+        sign * Math.sqrt(1 - Math.exp(-square * (4.0 / Math::PI + 0.147 * square) / (1 + 0.147 * square)))
+      end
+
       def fill_rect(bounds, red, green, blue)
         left, right = [bounds.x.to_i, 0].max, [bounds.right.to_i, @width].min
         top, bottom = [bounds.y.to_i, 0].max, [bounds.bottom.to_i, @height].min
@@ -216,7 +264,11 @@ module Zaniah
       def gradient_offset(gradient, x, y, width, height)
         kind, first, scale, cosine, sine, center_x, center_y, radius = gradient
         nx, ny = x / width, y / height
-        raw = kind == 1 ? (nx - 0.5) * cosine + (ny - 0.5) * sine + 0.5 : Math.hypot(nx - center_x, ny - center_y) / radius
+        raw = case kind
+        when 1, 4 then (nx - 0.5) * cosine + (ny - 0.5) * sine + 0.5
+        when 2, 5 then Math.hypot(nx - center_x, ny - center_y) / radius
+        else ((Math.atan2(ny - center_y, nx - center_x) - Math.atan2(sine, cosine)) / (2 * Math::PI)) % 1
+        end
         ((raw - first) * scale).clamp(0, 1)
       end
 

data/lib/zaniah/gpu/vulkan/scene.frag

@@ -10,20 +10,29 @@ layout(location = 6) in vec4 widths;
 layout(location = 7) in vec4 gradient;
 layout(location = 8) in vec4 center_kind;
 layout(location = 9) in float dash;
+layout(location = 10) in float spread;
 
 layout(set = 0, binding = 0) uniform sampler2D atlas;
 layout(location = 0) out vec4 fragment_color;
 
+float approx_erf(float value) {
+  float square = value * value;
+  return sign(value) * sqrt(1.0 - exp(-square * (1.27323954474 + 0.147 * square) / (1.0 + 0.147 * square)));
+}
+
 void main() {
   vec4 fill = color;
   if (center_kind.w == 0.0) {
     if (gradient.x > 0.0) {
       vec2 normalized = local_position / primitive_size;
-      float raw = gradient.x == 1.0
+      float raw = gradient.x == 1.0 || gradient.x == 4.0
         ? dot(normalized - 0.5, vec2(cos(radians(gradient.w)), sin(radians(gradient.w)))) + 0.5
-        : length(normalized - center_kind.xy) / center_kind.z;
-      fill = mix(color, secondary,
-        clamp((raw - gradient.y) / max(gradient.z - gradient.y, 0.000001), 0.0, 1.0));
+        : gradient.x == 2.0 || gradient.x == 5.0 ? length(normalized - center_kind.xy) / center_kind.z
+        : fract((atan(normalized.y - center_kind.y, normalized.x - center_kind.x) - radians(gradient.w)) / 6.28318530718 + 1.0);
+      float amount = clamp((raw - gradient.y) / max(gradient.z - gradient.y, 0.000001), 0.0, 1.0);
+      vec2 ramp_uv = vec2((floor(amount * 255.0 + 0.5) + 0.5) / 256.0, (secondary.x + 0.5) / 256.0);
+      fill = gradient.x >= 4.0 ? texture(atlas, ramp_uv) * vec4(1.0,1.0,1.0,color.a)
+        : mix(color, secondary, amount);
     }
     float radius = local_position.y < primitive_size.y / 2.0
       ? (local_position.x < primitive_size.x / 2.0 ? radii.x : radii.y)
@@ -41,6 +50,19 @@ void main() {
     if (border_width > 0.0 && distance >= -border_width &&
         !(dash == 1.0 && mod(coordinate, 6.0) >= 3.0)) fill = border;
     fill.a *= coverage;
+  } else if (center_kind.w == 4.0) {
+    float margin = dash == 1.0 ? 0.0 : spread + center_kind.z * 3.0 + 1.0;
+    vec2 original_size = primitive_size - 2.0 * margin;
+    vec2 p = local_position - margin;
+    float radius = p.y < original_size.y/2.0 ? (p.x < original_size.x/2.0 ? radii.x : radii.y) : (p.x < original_size.x/2.0 ? radii.w : radii.z);
+    radius = clamp(radius, 0.0, min(original_size.x,original_size.y)/2.0);
+    vec2 q = abs(p - original_size/2.0) - original_size/2.0 + radius;
+    float distance = length(max(q,0.0)) + min(max(q.x,q.y),0.0) - radius;
+    float sigma = center_kind.z;
+    float coverage = dash == 1.0
+      ? clamp(0.5 - distance, 0.0, 1.0) * (sigma == 0.0 ? clamp(distance + spread + 0.5, 0.0, 1.0) : 0.5 + 0.5 * approx_erf((distance + spread) / (sigma * 1.41421356237)))
+      : sigma == 0.0 ? clamp(0.5 - distance + spread, 0.0, 1.0) : 0.5 - 0.5 * approx_erf((distance - spread) / (sigma * 1.41421356237));
+    fill.a *= coverage;
   } else if (center_kind.w == 1.0 || center_kind.w == 2.0) {
     vec2 uv = widths.xy + local_position / primitive_size * widths.zw;
     vec4 sample_color = texture(atlas, uv);

data/lib/zaniah/gpu/vulkan/scene.vert

@@ -23,6 +23,7 @@ layout(location = 6) out vec4 widths;
 layout(location = 7) out vec4 gradient;
 layout(location = 8) out vec4 center_kind;
 layout(location = 9) out float dash;
+layout(location = 10) out float spread;
 
 void main() {
   vec2 corners[4] = vec2[4](vec2(0, 0), vec2(1, 0), vec2(0, 1), vec2(1, 1));
@@ -47,4 +48,5 @@ void main() {
   gradient = instance_gradient;
   center_kind = instance_center_kind;
   dash = instance_translation.w;
+  spread = instance_translation.z;
 }

data/lib/zaniah/image.rb

@@ -25,14 +25,14 @@ module Zaniah
       @texture = GPU::Texture.new(width, height, data: pixels)
     end
 
-    attr_reader :frames
+    attr_reader :frames, :texture
 
     def request_layout(_cx)
       @layout_node = Layout::Node.new(style: @style, measure: ->(_width, _height) { [@texture.width, @texture.height] })
     end
 
     def paint(bounds, _state, _prepaint, cx)
-      cx.scene.sprite(bounds.x, bounds.y, bounds.width, bounds.height, texture: @texture)
+      cx.scene.image(bounds.x, bounds.y, bounds.width, bounds.height, image: self, texture: @texture)
     end
 
     private

data/lib/zaniah/platform/headless/window.rb

@@ -291,6 +291,7 @@ module Zaniah
           frame_started = MONOTONIC_CLOCK.call
           @text_system.scale_factor = @scale_factor if @text_system.respond_to?(:scale_factor=)
           @scene.clear
+          @scene.vector_sink.size = @content_size if @scene.vector_sink&.respond_to?(:size=)
           @text_runs.clear
           @text_system.start_frame if @text_system.respond_to?(:start_frame)
           @used_state.clear