effects

Overview ¶

Package effects defines post- and pre-render visual filters for 2D drawing operations. These filters operate directly on *image.RGBA buffers, modifying pixel data to simulate optical effects such as shadows, blurs, glow, and color transformations.

This file implements a *drop shadow* effect similar to CSS’s `box-shadow`, applying a blurred, offset shadow below rendered content. The effect uses the existing alpha channel of the layer as a shape mask and tints it with a specified shadow color, spread, and blur radius.

High-level algorithm

1. Extract the alpha channel from the destination buffer (dst) to form a mask representing the visible shape of the layer.
2. Optionally expand (spread) the mask to enlarge the opaque region before blur.
3. Apply a separable box blur to the alpha mask to soften the edges.
4. Tint the blurred alpha mask with the shadow color and multiply it by overall opacity. RGB values are premultiplied by alpha to maintain correct compositing.
5. Render the resulting shadow offset by (x, y) *below* the original content, then composite the source image back over it.

Notes and constraints

• Image format: The function expects *image.RGBA with premultiplied alpha. Alpha blending is handled manually by setting premultiplied RGB values.
• Spread: Expands alpha before blur, similar to CSS `box-shadow spread-radius`.
• Blur: Implemented as a separable two-pass box blur for performance. The result approximates a Gaussian blur with radius `blur`.
• Opacity: The `opacity` parameter multiplies the color alpha and scales the shadow’s final visibility. Range [0..1].
• Composition order: The shadow is drawn first, then the original layer is overlaid using Porter-Duff `draw.Over` blending.
• Performance: O(W*H*blur) complexity. For large radii, consider downsampling.
• Thread-safety: Concurrent writes to the same RGBA buffer are unsafe.

Example usage:

shadow := effects.NewDropShadow(4, 4, 6, 0, color.NRGBA{0, 0, 0, 255}, 0.6)
shadow.Apply(layer)

This produces a smooth, semi-transparent shadow shifted 4px down and right, visually equivalent to CSS `box-shadow: 4px 4px 6px rgba(0,0,0,0.6);`.

Package effects defines interfaces and utilities for 2D image effects that can be applied to rendered layers before or after drawing operations. These effects modify *image.RGBA buffers directly to simulate phenomena like shadows, blur, glow, or color overlays.

This file contains the base Effect interface shared by all post-processing filters, as well as helper functions for working with alpha masks such as extracting or softening alpha channels.

Overview

• The Effect interface provides a unified contract for any visual filter that modifies an RGBA image, including its name and processing phase.
• The helper functions (`extractAlpha`, `featherMask`) operate on alpha masks to facilitate effects that depend on object silhouettes or smooth transparency gradients.

Notes:

• Effects may be either pre-render (IsPre == true) or post-render (IsPre == false). Pre effects modify the layer before content is drawn (e.g., tint, blur base), while post effects process the result afterward (e.g., shadow, glow).
• All effects work in-place on the provided image buffer and must ensure bounds safety themselves.
• Helper functions are CPU-based and not optimized for real-time pipelines, but they are suitable for procedural rendering or offline composition.

Package effects provides post- and pre-render image effects that can be attached to drawable instructions and compositing stages. These effects modify pixel data to simulate optical phenomena such as shadows, lighting, texture overlays, or atmospheric depth. All operations are performed directly on CPU-based *image.RGBA buffers for deterministic, hardware-independent rendering.

The effect implemented in this file simulates a CSS-like *inset box-shadow* (inner shadow). It darkens the interior edges of a rendered shape according to its alpha mask, creating the perception of depth or recessed surfaces.

High-level algorithm

1. Extract the alpha channel of the destination image (dst). The alpha defines the shape mask to which the inner shadow will be applied.
2. Invert the alpha mask so that the area outside the shape becomes opaque. This inverted mask defines the region where the shadow will originate.
3. Offset the inverted mask in the opposite direction of the desired shadow (negative offset) to simulate a light source casting from the given direction. For example, positive offsetX and offsetY produce a lower-right inner shadow.
4. Apply a box blur of radius `blur` to soften the shadow edges. The blur kernel is separable and applied in-place for efficiency.
5. Multiply the blurred mask by the original alpha, ensuring the shadow only affects pixels *inside* the shape’s visible area.
6. Tint destination RGB channels toward the shadow color with opacity-scaled interpolation. The alpha channel remains unmodified to match CSS behavior.

Notes and constraints

• Image format: dst must be *image.RGBA with premultiplied alpha. The effect reads and writes pixel data directly through Pix/PixOffset. Alpha blending is simulated via per-channel linear interpolation in sRGB space.
• Opacity: final opacity equals `effect.opacity * color.A/255`. Setting either to 0 disables the shadow. Opacity values are clamped to [0, 1].
• Coordinate system: offsets use CSS-style semantics. Positive offsetX/offsetY move the *light source* down and right, which pushes the shadow upward/left.
• Performance: the implementation is linear in the number of pixels. For large images, consider parallelization or reusing intermediate buffers.
• Thread-safety: concurrent modification of the same *image.RGBA is unsafe. Guard dst if the effect is applied concurrently across tiles or regions.

Example usage:

shadow := effects.NewInnerShadowEffect(4, 4, 6, patterns.Color{R: 0, G: 0, B: 0, A: 128})
shadow.SetOpacity(0.8)
shadow.Apply(target)

The resulting image will appear as if the drawn shape has a soft, recessed inner shadow consistent with Figma or CSS `box-shadow: inset ...` behavior.

Package effects defines visual post-processing effects for 2D drawing instructions. These effects operate directly on image buffers (*image.RGBA) after or before the main rendering pass, allowing simulation of optical phenomena such as blur, shadows, glow, or texture overlays.

This file implements a *layer blur* effect equivalent to Figma’s “Layer Blur”. Unlike a background blur, this effect acts solely on the content of the current layer — it diffuses the layer’s own pixels without sampling or blending the background underneath.

High-level algorithm

1. Copy the current layer (dst) into a temporary buffer to preserve original data.
2. Apply one or more passes of separable box blur to spread pixel values. - In constant mode, a uniform blur radius is used for the entire image. - In progressive mode, blur radius is linearly interpolated along the Y-axis, producing a gradient blur (useful for atmospheric or focus effects).
3. Optionally multiply all alpha values by `opacity` ∈ [0, 1] to attenuate the blurred result.

Implementation details

• Blur kernel: A three-pass box filter is used to approximate Gaussian blur. Each pass performs horizontal and vertical averaging within ±radius.
• Progressive blur: Implemented by reusing `boxBlurLine` on each row with a per-line radius computed via linear interpolation between `radiusStart` and `radiusEnd`.
• Image format: Operates in sRGB 8-bit space directly. Alpha is blurred along with RGB. The result remains premultiplied-compatible.
• Performance: Complexity is O(W*H*radius). For large images or high radii, consider splitting into tiles or parallelizing.
• Thread-safety: Concurrent writes to the same *image.RGBA are unsafe. Synchronize access when applying effects in parallel.

Example usage:

blur := effects.NewLayerBlurEffect(8).SetOpacity(0.8)
blur.Apply(layer)

// Progressive blur from 4px (top) to 16px (bottom)
blur.SetProgressive(4, 16).Apply(layer)

Both modes produce results visually similar to Figma’s layer blur.

Package effects implements pre- and post-render effects for 2D drawing instructions. This file defines a noise overlay effect similar to Figma’s “Noise” fill. It modifies RGB values of the destination image using random sampling and blending.

Algorithm summary

1. Iterate over all pixels of the target image.
2. For each pixel, with probability equal to `density`, apply a random noise color according to the selected noise type (mono, duo, or multi).
3. Blend the noise color into the pixel’s RGB channels using linear interpolation by `opacity`.

The alpha channel remains unchanged. The effect is post-applied (IsPre() == false).

Parameters:

• noiseType — type of noise pattern (mono/duo/multi).
• density — probability of applying noise at each pixel in [0, 1].
• opacity — blend factor in [0, 1].
• colorA, colorB — base colors for duo mode.
• blendMode — reserved for future blending options.

Notes:

• Non-deterministic: Uses math/rand global RNG. Seed externally if deterministic output is needed.
• Complexity: O(W×H) with very low per-pixel cost.
• Safe for any *image.RGBA buffer. No allocations.

Package effects provides post- and pre-render image effects that can be attached to drawable instructions. The effect in this file simulates Figma-like texture overlay (procedural roughness) by tinting destination pixels with a noisy mask.

High-level algorithm

1. For each destination pixel (x, y) compute a smooth pseudo-random value n in [0, 1] using a sum of sine products (see mathSinNoise). The evaluation domain is scaled by the user-provided `scale` so bigger values produce wider, lower-frequency waves; smaller values produce finer grain.
2. Clamp and scale n by `intensity` in [0, 1]. Intensity = 0 disables the effect; 1 uses the full amplitude of the procedural noise.
3. Linearly interpolate the destination RGB channels toward the effect color using t = n * opacity, while leaving the alpha channel unchanged. Interpolation is performed in 8-bit sRGB space for performance: C_out = Lerp(C_dst, C_tex, t)
4. The effect runs as a post effect (IsPre() == false). It expects that the base content has already been drawn into dst.

Notes and constraints

• Image format: dst must be *image.RGBA. The buffer stores premultiplied alpha, but this effect does not modify A and blends only RGB in-place. This matches a simple "overlay tint" and is fast. If you need accurate alpha-aware compositing, convert to linear space and back.
• Determinism: mathSinNoise includes calls to math/rand for slight phase jitter. Using the package-level RNG makes results depend on the global seed. If you need reproducibility across runs, seed math/rand yourself (e.g., rand.Seed(0)) before applying the effect, or rewrite the noise to be hash-based and seedable per-effect.
• Performance: The implementation iterates pixels and writes directly into dst.Pix via PixOffset to avoid allocations. For very large images consider tiling or parallelization.
• Thread-safety: Package-level functions in math/rand are safe for concurrent use, but modifying the same *image.RGBA from multiple goroutines is not. Guard dst with your own synchronization if you parallelize.