CC Ball Action: add Coloring, Shading, Scatter Motion, Displace and Displace Property (#3197)

After Effects 24.2 reworked CC Ball Action's controls. EffectCraft now lists
them in After Effects' order with its defaults: Grid Spacing (5), Ball Size
(100), Coloring (Medium), Shading (-75), Scatter, Scatter Motion, Displace,
Displace Property (Brightness), Twist Angle, Twist Property, Rotation Axis,
Rotation. Grid Spacing and Ball Size used to default to 4 and 40; saved
projects keep their values.

- Shading scales the balls' light and shine. -75 is the lit sphere as before,
  0 draws flat balls in the layer's colour, larger magnitudes shade more, and
  the sign mirrors the light's direction. The value is clamped to -100..100
  (an assumed range) so huge values stay finite on the GPU. Values other than
  -75 and 0 use a new sprite shape (Shape::Ball), drawn the same way on the
  CPU and the GPU.
- Coloring is an approximation: Crisp takes the nearest pixel, Medium keeps
  EffectCraft's earlier smooth sample (for compatibility), Smooth averages 16
  samples over the ball's cell.
- Scatter Motion is treated as the renamed Instability State, since 24.2
  shows no Instability State. Old projects are upgraded through
  PARAM_ID_ALIASES.
- Displace and Displace Property (Red, Green, Blue, Brightness, Saturation,
  RGB, Radius, Diamond, Spherize) move each ball towards or away from the
  camera. The scale, direction, pivot and range, and what Radius, Diamond and
  Spherize compute, are EffectCraft's own choice pending a comparison with
  After Effects. Displace is clamped to -1000..1000.

With the old Grid Spacing and Ball Size, every CC Ball Action golden hash is
unchanged, so the new controls at their defaults draw what was drawn before.
Only the golden cases that use the default Grid Spacing and Ball Size were
reblessed. CC Ball Action has no .aep mapping yet.

Sources (behaviour and public descriptions only):
- After Effects February 2024 (24.2) feature summary: "Ball Action:
  Rearranged effect controls with new controls, such as Displacement,
  Shading, and Coloring"
  https://helpx.adobe.com/ae_en/after-effects/using/whats-new/2024-2.html
- The After Effects screenshot in #3197: control order and defaults.
- 163.com, "Ae 效果详解:CC Ball Action": option lists, defaults, and that
  Shading 0 is flat
  https://www.163.com/dy/article/JOICG6E10536FE6V.html
- Adobe community, "CC Ball Action is broken in update 24.4": the Coloring
  options Crisp, Medium and Smooth
- Mike Murphy, "How To Use CC Ball Action": Shading 0 with Displace on
  Brightness
  https://mikemurphy.ai/tutorials/ccballaction/

Fixes #3197
This commit is contained in:
vangel76
2026-11-07 12:40:04 +01:00
parent bb2d2005ce
commit 26dc7b3a5e
10 changed files with 347 additions and 35 deletions
+3
View File
@@ -44,6 +44,9 @@ pub const PARAM_ID_ALIASES: &[(&str, &str, &str)] = &[
("ec.key.innerouter", "additionalBackground", "additionalBackground/background1"),
// Generate: Radio Waves' growth speed was called Velocity; Velocity now moves the wave.
("ec.generate.radiowaves", "velocity", "waveMotion/expansion"),
// Simulation: CC Ball Action's Instability State is treated as the control After Effects
// 24.2 calls Scatter Motion (#3197; an assumption: 24.2 shows no Instability State).
("ec.sim.ccballaction", "instabilityState", "scatterMotion"),
];
/// Popup option labels renamed since they were first saved:
+22
View File
@@ -93,6 +93,10 @@ pub enum Shape {
Disc,
/// Lit sphere (upper-left light, specular).
Sphere,
/// CC Ball Action's ball: [`Shape::Sphere`]'s light and shine scaled by `|shade|` (1 is the
/// sphere's look, 0 a flat disc; callers keep it finite, the GPU draws the same); a negative
/// `shade` mirrors the light's direction (lit from the lower right).
Ball { shade: f32 },
/// Disc fading linearly to its rim.
Faded,
/// Thin ring with a highlight.
@@ -277,6 +281,24 @@ fn sprite_shade(s: &Sprite, x: f32, y: f32) -> Option<Px> {
rgb = [rgb[0] * k + spec, rgb[1] * k + spec, rgb[2] * k + spec];
cv
}
Shape::Ball { shade } => {
let d = (dx * dx + dy * dy).sqrt();
let cv = aa(r - d);
if cv <= 0.0 {
return None;
}
let (nx, ny) = (dx / r, dy / r);
let nz = (1.0 - nx * nx - ny * ny).max(0.0).sqrt();
let m = if shade < 0.0 { -1.0 } else { 1.0 };
let (lx, ly, lz) = (-0.48 * m, -0.58 * m, 0.66);
let diff = (nx * lx + ny * ly + nz * lz).max(0.0);
let rz = 2.0 * diff * nz - lz;
let st = shade.abs();
let spec = rz.max(0.0).powi(20) * 0.6 * st;
let k = (1.0 - st * 0.8 * (1.0 - diff)).max(0.0);
rgb = [rgb[0] * k + spec, rgb[1] * k + spec, rgb[2] * k + spec];
cv
}
Shape::Bubble => {
let d = (dx * dx + dy * dy).sqrt() / r;
if d > 1.0 + 1.0 / r {
+113 -5
View File
@@ -4,10 +4,91 @@ use super::{Acc, Buf, EffectCtx, IntoParallelIterator, ParallelIterator, Post, S
// ------------------------------------------------------------------ CC Ball Action
/// CC Ball Action's Coloring: how a ball takes its colour from the layer under its grid cell.
/// An approximation: After Effects' own meaning is not published beyond "how smooth the
/// balls look". Crisp takes the nearest pixel, Medium keeps EffectCraft's earlier smooth
/// sample at the cell centre (for compatibility), Smooth averages 16 samples over the cell.
pub(super) const BALL_COLORING: &[&str] = &["Crisp", "Medium", "Smooth"];
pub(super) const BALL_COLORING_MEDIUM: u32 = 1;
/// CC Ball Action's default Shading: the lit sphere (`Shape::Sphere`); 0 draws flat discs.
pub(super) const BALL_SHADING_DEFAULT: f64 = -75.0;
/// CC Ball Action's Displace Property: what pushes a ball towards (high values) or away from
/// (low values) the camera. The option names come from public descriptions; what Radius,
/// Diamond and Spherize compute here is an assumption pending a comparison with After Effects.
pub(super) const BALL_DISPLACE_PROPERTIES: &[&str] = &["Red", "Green", "Blue", "Brightness", "Saturation", "RGB", "Radius", "Diamond", "Spherize"];
pub(super) const BALL_DISPLACE_BRIGHTNESS: u32 = 3;
pub(super) fn ball_action(ctx: &EffectCtx, b: Buf) -> Buf {
ball_action_plan(ctx, &b).finish(b)
}
/// A parameter's number, or `default` when the instance does not carry it.
fn f_or(ctx: &EffectCtx, id: &str, default: f64) -> f64 {
ctx.params.values.get(id).map(|v| v.as_f64()).unwrap_or(default)
}
/// The layer's straight colour and alpha for the ball of the grid cell centred on (`sx`, `sy`)
/// (buffer pixels, cell `cell` buffer pixels wide), by Coloring `coloring`.
fn ball_color(src: &effectcraft_raster::Image, sx: f64, sy: f64, cell: f64, coloring: u32) -> ([f32; 3], f32) {
match coloring {
// Crisp: the pixel under the cell centre.
0 => unpremul(src.get(sx.floor() as i64, sy.floor() as i64)),
// Smooth: the cell's average (4 × 4 samples, premultiplied).
2 => {
const N: u32 = 4;
let mut acc = [0.0f32; 4];
for j in 0..N {
for i in 0..N {
let ox = (f64::from(i) + 0.5) / f64::from(N) - 0.5;
let oy = (f64::from(j) + 0.5) / f64::from(N) - 0.5;
let p = src.sample_bilinear(sx + ox * cell, sy + oy * cell);
for (a, v) in acc.iter_mut().zip(p) {
*a += v;
}
}
}
let n = (N * N) as f32;
unpremul([acc[0] / n, acc[1] / n, acc[2] / n, acc[3] / n])
}
// Medium: a smooth sample at the cell centre.
_ => unpremul(src.sample_bilinear(sx, sy)),
}
}
/// CC Ball Action's Displace Property `prop` (0..1) for a ball of straight colour `c` at
/// (`gx`, `gy`) on a `lw` × `lh` layer (`maxr`: half its diagonal). Assumed meanings (not
/// compared with After Effects yet): Radius, Diamond and Spherize are shapes that peak at the
/// layer centre.
fn ball_displace_value(prop: u32, c: [f32; 3], gx: f32, gy: f32, lw: f32, lh: f32, maxr: f32) -> f32 {
let (cx, cy) = (lw * 0.5, lh * 0.5);
let v = match prop {
0 => c[0],
1 => c[1],
2 => c[2],
// Brightness: the brightest channel (HSB brightness).
3 => c[0].max(c[1]).max(c[2]),
// Saturation: HSB saturation.
4 => {
let mx = c[0].max(c[1]).max(c[2]);
let mn = c[0].min(c[1]).min(c[2]);
if mx > 0.0 { (mx - mn) / mx } else { 0.0 }
}
// RGB: the channels' mean.
5 => (c[0] + c[1] + c[2]) / 3.0,
// Radius: high at the centre, low at the corners.
6 => 1.0 - (gx - cx).hypot(gy - cy) / maxr.max(1.0),
// Diamond: high at the centre, falling linearly to the edge midpoints' diamond.
7 => 1.0 - ((gx - cx).abs() / cx.max(0.5) + (gy - cy).abs() / cy.max(0.5)) * 0.5,
// Spherize: a hemisphere over the largest centred circle.
_ => {
let rr = cx.min(cy).max(0.5);
let d = (gx - cx).hypot(gy - cy) / rr;
(1.0 - d * d).max(0.0).sqrt()
}
};
if v.is_finite() { v.clamp(0.0, 1.0) } else { 0.0 }
}
/// CC Ball Action's balls (far to near), coloured by the layer's pixels.
fn ball_action_plan(ctx: &EffectCtx, b: &Buf) -> SpritePlan {
let pr = ctx.params;
@@ -18,7 +99,29 @@ fn ball_action_plan(ctx: &EffectCtx, b: &Buf) -> SpritePlan {
let twist = pr.f("twistAngle").to_radians();
let spacing = pr.f("gridSpacing").max(1.0) as f32;
let size = pr.f("ballSize") as f32 / 100.0;
let instab = pr.f("instabilityState").to_radians() as f32;
// Scatter Motion, treated as the renamed Instability State (an assumption: After Effects
// 24.2 shows Scatter Motion and no Instability State): turns each ball's scatter direction.
let instab = pr.f("scatterMotion").to_radians() as f32;
let coloring = pr.values.get("coloring").map(|v| v.as_enum()).unwrap_or(BALL_COLORING_MEDIUM);
let shading = f_or(ctx, "shading", BALL_SHADING_DEFAULT);
// Shading: -75 is the lit sphere as it always was, 0 flat discs; the magnitude scales the
// light and shine (strength 1 at 75) and the sign mirrors the light's direction (positive
// lights the balls from the lower right). How this compares with After Effects' sign
// (described as concave versus convex) is unverified, as is the -100..100 range.
let shape = if shading == BALL_SHADING_DEFAULT || !shading.is_finite() {
Shape::Sphere
} else if shading == 0.0 {
Shape::Disc
} else {
// Clamped: a huge value would reach the GPU as an infinite strength (and NaN colours).
Shape::Ball { shade: (-shading.clamp(-100.0, 100.0) / 75.0) as f32 }
};
// Displace: pushes each ball along z by its Displace Property (high values towards the
// camera, pivoting at the property's middle value); 100 moves the extremes by half the
// layer's diagonal. Scale, direction, pivot and range are EffectCraft's own choice,
// pending a comparison with After Effects. Clamped so huge values stay finite.
let displace = pr.f("displace").clamp(-1000.0, 1000.0) as f32;
let displace_prop = pr.values.get("displaceProperty").map(|v| v.as_enum()).unwrap_or(BALL_DISPLACE_BRIGHTNESS);
let seed = ctx.seed.wrapping_mul(0x2545f491);
let (lw, lh) = (ctx.layer_size[0] as f32, ctx.layer_size[1] as f32);
let s = b.scale as f32;
@@ -43,7 +146,7 @@ fn ball_action_plan(ctx: &EffectCtx, b: &Buf) -> SpritePlan {
let gx = (i % nx) as f32 * spacing + spacing * 0.5;
let gy = (i / nx) as f32 * spacing + spacing * 0.5;
let (sx, sy) = b.to_px([gx as f64, gy as f64]);
let (c, a) = unpremul(src.sample_bilinear(sx, sy));
let (c, a) = ball_color(src, sx, sy, f64::from(spacing * s), coloring);
if a <= 0.0 || size <= 0.0 {
return None;
}
@@ -54,11 +157,16 @@ fn ball_action_plan(ctx: &EffectCtx, b: &Buf) -> SpritePlan {
_ => crate::util::rgb3([c[0], c[1], c[2], 0.0]).iter().sum::<f32>() / 3.0,
} as f64;
let ang = rot + twist * tp;
// Scatter: random 3D offsets whose direction drifts with the instability state.
// Scatter: random 3D offsets whose direction drifts with Scatter Motion.
let ph = h(i, 1, seed) * std::f32::consts::TAU + instab;
let sc = scatter * h(i, 2, seed);
let off = [(sc * ph.cos()) as f64, (sc * ph.sin()) as f64, (scatter * hs(i, 3, seed)) as f64];
let p0 = [gx as f64 - cx + off[0], gy as f64 - cy + off[1], off[2]];
let mut p0 = [gx as f64 - cx + off[0], gy as f64 - cy + off[1], off[2]];
// Only when set, so Displace 0 leaves every depth (and the far-to-near order) as is.
if displace != 0.0 && displace.is_finite() {
let v = ball_displace_value(displace_prop, c, gx, gy, lw, lh, maxr);
p0[2] -= f64::from(displace / 100.0 * (v - 0.5) * 2.0 * maxr);
}
let m = rot_axis(ax, ang);
let q: [f64; 3] = std::array::from_fn(|k| m[k][0] * p0[0] + m[k][1] * p0[1] + m[k][2] * p0[2]);
if d + q[2] <= d * 0.05 {
@@ -67,7 +175,7 @@ fn ball_action_plan(ctx: &EffectCtx, b: &Buf) -> SpritePlan {
let persp = d / (d + q[2]);
let (bx, by) = b.to_px([cx + q[0] * persp, cy + q[1] * persp]);
let r = spacing * 0.5 * size * persp as f32 * s;
Some((q[2], Sprite::new(bx as f32, by as f32, r, [c[0], c[1], c[2], a], Shape::Sphere)))
Some((q[2], Sprite::new(bx as f32, by as f32, r, [c[0], c[1], c[2], a], shape)))
})
.collect();
balls.sort_by(|a, b| b.0.total_cmp(&a.0));
+15 -6
View File
@@ -1,5 +1,7 @@
use super::foam::{FOAM_TEXTURES, foam};
use super::pixels::{ball_action, pixel_polly, scatterize};
use super::pixels::{
BALL_COLORING, BALL_COLORING_MEDIUM, BALL_DISPLACE_BRIGHTNESS, BALL_DISPLACE_PROPERTIES, BALL_SHADING_DEFAULT, ball_action, pixel_polly, scatterize,
};
use super::shatter::{CD_PROPS, CD_SOURCES, SHATTER_PATTERNS, SHATTER_TEXTURE_MODES, card_dance, shatter};
use super::surfaces::{caustics, wave_world};
use super::{EffectSpec, ParamUi, Value, col, num, p, pct, popup, pt, slider, spec};
@@ -80,15 +82,22 @@ pub fn specs() -> Vec<EffectSpec> {
spec(
"ec.sim.ccballaction",
"CC Ball Action",
// After Effects' order and defaults since 24.2 (#3197). Scatter Motion is treated as
// the renamed Instability State (an assumption, `migrate::PARAM_ID_ALIASES`). The
// Shading range is not published; -100..100 is an assumption.
vec![
p("gridSpacing", "Grid Spacing", num(5.0), slider(1.0, 200.0, 1.0, 50.0, 0)),
p("ballSize", "Ball Size", num(100.0), slider(0.0, 400.0, 0.0, 200.0, 1)),
p("coloring", "Coloring", Value::Enum(BALL_COLORING_MEDIUM), popup(BALL_COLORING)),
p("shading", "Shading", num(BALL_SHADING_DEFAULT), slider(-100.0, 100.0, -100.0, 100.0, 1)),
p("scatter", "Scatter", num(0.0), slider(0.0, 2000.0, 0.0, 300.0, 1)),
p("scatterMotion", "Scatter Motion", num(0.0), ParamUi::Angle),
p("displace", "Displace", num(0.0), slider(-1000.0, 1000.0, 0.0, 100.0, 1)),
p("displaceProperty", "Displace Property", Value::Enum(BALL_DISPLACE_BRIGHTNESS), popup(BALL_DISPLACE_PROPERTIES)),
p("twistAngle", "Twist Angle", num(0.0), ParamUi::Angle),
p("twistProperty", "Twist Property", Value::Enum(0), popup(&["X Axis", "Y Axis", "Radius", "Brightness"])),
p("rotationAxis", "Rotation Axis", Value::Enum(0), popup(&["X Axis", "Y Axis", "Z Axis", "XY Axis", "XZ Axis", "YZ Axis", "XYZ Axis"])),
p("rotation", "Rotation", num(0.0), ParamUi::Angle),
p("twistProperty", "Twist Property", Value::Enum(0), popup(&["X Axis", "Y Axis", "Radius", "Brightness"])),
p("twistAngle", "Twist Angle", num(0.0), ParamUi::Angle),
p("gridSpacing", "Grid Spacing", num(4.0), slider(1.0, 200.0, 1.0, 50.0, 0)),
p("ballSize", "Ball Size", num(40.0), slider(0.0, 400.0, 0.0, 200.0, 1)),
p("instabilityState", "Instability State", num(0.0), ParamUi::Angle),
],
ball_action,
),
+132
View File
@@ -46,6 +46,138 @@ fn ball_action_draws_balls() {
assert!(sum_diff(&a, &sc) > 1.0);
}
/// #3197: CC Ball Action has After Effects' controls (since 24.2), in its order, with its
/// defaults: Coloring, Shading, Scatter Motion (formerly Instability State), Displace and
/// Displace Property were missing.
#[test]
fn ball_action_has_after_effects_controls() {
let spec = crate::find("ec.sim.ccballaction").unwrap();
let names: Vec<&str> = spec.params.iter().map(|p| p.name).collect();
assert_eq!(
names,
[
"Grid Spacing",
"Ball Size",
"Coloring",
"Shading",
"Scatter",
"Scatter Motion",
"Displace",
"Displace Property",
"Twist Angle",
"Twist Property",
"Rotation Axis",
"Rotation"
]
);
let sp = |id: &str| spec.params.iter().find(|p| p.id == id).unwrap_or_else(|| panic!("no {id}"));
assert_eq!(sp("gridSpacing").default, num(5.0));
assert_eq!(sp("ballSize").default, num(100.0));
assert_eq!(sp("coloring").default, Value::Enum(1));
assert_eq!(sp("coloring").ui, ParamUi::Popup { options: vec!["Crisp".into(), "Medium".into(), "Smooth".into()] });
assert_eq!(sp("shading").default, num(-75.0));
assert!(matches!(sp("shading").ui, ParamUi::Slider { min, max, .. } if min <= -100.0 && max >= 100.0));
assert_eq!(sp("scatterMotion").default, num(0.0));
assert_eq!(sp("scatterMotion").ui, ParamUi::Angle);
assert_eq!(sp("displace").default, num(0.0));
let ParamUi::Popup { options } = &sp("displaceProperty").ui else { panic!("Displace Property is a popup") };
let Value::Enum(d) = sp("displaceProperty").default else { panic!("Displace Property defaults to an option") };
assert_eq!(options.get(d as usize).map(String::as_str), Some("Brightness"));
// Old projects' Instability State becomes Scatter Motion through `PARAM_ID_ALIASES`; the
// engine test `opening_an_old_project_upgrades_effect_instances` covers every alias.
}
/// #3197: the new controls at After Effects' defaults draw exactly what CC Ball Action drew
/// before (the lit sphere, a smooth colour sample, no displacement).
#[test]
fn ball_action_new_controls_at_defaults_keep_the_render() {
let base = [("ballSize", num(80.0)), ("scatter", num(6.0)), ("rotationAxis", Value::Enum(1)), ("rotation", num(25.0))];
let a = run("ec.sim.ccballaction", &base, ramp(32, 32), 0.0);
let mut explicit = base.to_vec();
explicit.extend([
("coloring", Value::Enum(1)),
("shading", num(-75.0)),
("scatterMotion", num(0.0)),
("displace", num(0.0)),
("displaceProperty", Value::Enum(3)),
]);
assert_eq!(a, run("ec.sim.ccballaction", &explicit, ramp(32, 32), 0.0));
}
/// #3197: Shading 0 removes the built-in light: every ball is the layer's flat colour. The
/// default (-75) shades it; a smaller magnitude shades less, a positive value lights the balls
/// from the other side.
#[test]
fn ball_action_shading_zero_is_flat() {
let c = [0.6, 0.3, 0.2, 1.0];
let shade = |v: f64| run("ec.sim.ccballaction", &[("ballSize", num(100.0)), ("gridSpacing", num(8.0)), ("shading", num(v))], Image::filled(32, 32, c), 0.0);
let flat = shade(0.0);
let covered: Vec<&[f32; 4]> = flat.data.iter().filter(|p| p[3] > 0.999).collect();
assert!(!covered.is_empty(), "balls drawn");
for p in &covered {
for k in 0..3 {
assert!((p[k] / p[3] - c[k]).abs() < 1e-4, "flat colour: {p:?}");
}
}
let lit = shade(-75.0);
assert!(lit.data.iter().any(|p| p[3] > 0.999 && (0..3).any(|k| (p[k] / p[3] - c[k]).abs() > 0.05)), "the default shading lights and darkens the balls");
let soft = shade(-30.0);
assert!(sum_diff(&flat, &soft) > 0.1 && sum_diff(&flat, &soft) < sum_diff(&flat, &lit), "less shading, closer to flat");
assert!(sum_diff(&shade(75.0), &lit) > 1.0, "the sign moves the light");
}
/// #3197: Coloring Crisp takes the pixel under each ball's cell centre; Medium samples
/// smoothly between pixels. Grid Spacing 4 puts the cell centres on pixel corners (with the
/// default 5 they fall on pixel centres, where Medium's sample equals Crisp's).
#[test]
fn ball_action_coloring_crisp_takes_the_pixel() {
let mut src = Image::new(32, 32);
for y in 0..32u32 {
for x in 0..32u32 {
src.set(x, y, [x as f32 / 32.0, y as f32 / 32.0, ((x * 7 + y * 3) % 5) as f32 / 4.0, 1.0]);
}
}
let col = |m: u32| {
let v = [("gridSpacing", num(4.0)), ("ballSize", num(100.0)), ("shading", num(0.0)), ("coloring", Value::Enum(m))];
run("ec.sim.ccballaction", &v, src.clone(), 0.0)
};
let crisp = col(0);
// Flat, opaque balls of radius 2 centred on (4i + 2, 4j + 2): the pixel to the lower right
// of each centre is fully covered by its ball alone.
for j in 0..8i64 {
for i in 0..8i64 {
let (x, y) = (4 * i + 2, 4 * j + 2);
let (got, want) = (crisp.get(x, y), src.get(x, y));
assert!((0..4).all(|k| (got[k] - want[k]).abs() < 1e-5), "ball ({i}, {j}): {got:?} vs the pixel {want:?}");
}
}
assert!(sum_diff(&crisp, &col(1)) > 1.0, "medium blends the pixels");
}
/// #3197: a huge Shading (typed or from an expression) is clamped, so the balls stay finite.
#[test]
fn ball_action_huge_shading_stays_finite() {
for v in [1e45, -1e45, f64::MAX] {
let o = run("ec.sim.ccballaction", &[("gridSpacing", num(8.0)), ("shading", num(v))], ramp(32, 32), 0.0);
assert!(o.data.iter().all(|p| p.iter().all(|c| c.is_finite())), "shading {v}");
assert!(o.data.iter().any(|p| p[3] > 0.0), "shading {v}: balls drawn");
}
}
/// #3197: Displace pushes the balls along z by the chosen property (Radius: the centre comes
/// towards the camera and grows); 0 leaves them in the layer's plane.
#[test]
fn ball_action_displace_moves_balls_in_depth() {
let flat = run("ec.sim.ccballaction", &[("ballSize", num(80.0))], ramp(32, 32), 0.0);
let d = run("ec.sim.ccballaction", &[("ballSize", num(80.0)), ("displace", num(60.0)), ("displaceProperty", Value::Enum(6))], ramp(32, 32), 0.0);
assert_eq!(d, run("ec.sim.ccballaction", &[("ballSize", num(80.0)), ("displace", num(60.0)), ("displaceProperty", Value::Enum(6))], ramp(32, 32), 0.0));
assert!(sum_diff(&flat, &d) > 1.0);
for prop in 0..9 {
let o = run("ec.sim.ccballaction", &[("ballSize", num(80.0)), ("displace", num(400.0)), ("displaceProperty", Value::Enum(prop))], ramp(32, 32), 0.0);
assert!(o.data.iter().all(|p| p.iter().all(|v| v.is_finite())), "property {prop}");
}
}
#[test]
fn pixel_polly_breaks_after_start() {
let v = [("forceCenter", pt(16.0, 16.0)), ("gridSpacing", num(4.0))];
+21 -21
View File
@@ -192,7 +192,7 @@ fn cases() -> Vec<(&'static str, Vec<Set>)> {
vec![
vec![],
vec![("scatter", n(20.0)), ("rotationAxis", e(6)), ("rotation", n(40.0)), ("twistProperty", e(3)), ("twistAngle", n(90.0))],
vec![("gridSpacing", n(2.0)), ("ballSize", n(80.0)), ("instabilityState", n(45.0)), ("twistProperty", e(2)), ("twistAngle", n(30.0))],
vec![("gridSpacing", n(2.0)), ("ballSize", n(80.0)), ("scatterMotion", n(45.0)), ("twistProperty", e(2)), ("twistAngle", n(30.0))],
],
),
(
@@ -538,26 +538,26 @@ const GOLDEN: &[(&str, u64)] = &[
("ec.sim.particleplayground/8/32bpc/t1.5", 0xb5b7f0281f26baad),
("ec.sim.particleplayground/8/32bpc/t0.8", 0x8b6934363ef4dcfd),
("ec.sim.particleplayground/8/32bpc/t2.2", 0x0a31c17e8e34b9f5),
("ec.sim.ccballaction/0/8bpc/t0.5", 0x12698ec8353be38c),
("ec.sim.ccballaction/0/8bpc/t1.5", 0x12698ec8353be38c),
("ec.sim.ccballaction/0/8bpc/t0.8", 0x12698ec8353be38c),
("ec.sim.ccballaction/0/8bpc/t2.2", 0x12698ec8353be38c),
("ec.sim.ccballaction/0/32bpc/t0.5", 0x3fb733487e120261),
("ec.sim.ccballaction/0/32bpc/t1.5", 0x3fb733487e120261),
("ec.sim.ccballaction/0/32bpc/t0.8", 0x3fb733487e120261),
("ec.sim.ccballaction/0/32bpc/t2.2", 0x3fb733487e120261),
("ec.sim.ccballaction/0/8bpc/half/t0.5", 0x4946070917cc0945),
("ec.sim.ccballaction/0/8bpc/half/t1.5", 0x4946070917cc0945),
("ec.sim.ccballaction/0/8bpc/half/t0.8", 0x4946070917cc0945),
("ec.sim.ccballaction/0/8bpc/half/t2.2", 0x4946070917cc0945),
("ec.sim.ccballaction/1/8bpc/t0.5", 0xf34b3be38a4dd468),
("ec.sim.ccballaction/1/8bpc/t1.5", 0xf34b3be38a4dd468),
("ec.sim.ccballaction/1/8bpc/t0.8", 0xf34b3be38a4dd468),
("ec.sim.ccballaction/1/8bpc/t2.2", 0xf34b3be38a4dd468),
("ec.sim.ccballaction/1/32bpc/t0.5", 0x503b7238edf2912c),
("ec.sim.ccballaction/1/32bpc/t1.5", 0x503b7238edf2912c),
("ec.sim.ccballaction/1/32bpc/t0.8", 0x503b7238edf2912c),
("ec.sim.ccballaction/1/32bpc/t2.2", 0x503b7238edf2912c),
("ec.sim.ccballaction/0/8bpc/t0.5", 0x5f7401d3d1e5a513),
("ec.sim.ccballaction/0/8bpc/t1.5", 0x5f7401d3d1e5a513),
("ec.sim.ccballaction/0/8bpc/t0.8", 0x5f7401d3d1e5a513),
("ec.sim.ccballaction/0/8bpc/t2.2", 0x5f7401d3d1e5a513),
("ec.sim.ccballaction/0/32bpc/t0.5", 0x9cf15a7756ab88ed),
("ec.sim.ccballaction/0/32bpc/t1.5", 0x9cf15a7756ab88ed),
("ec.sim.ccballaction/0/32bpc/t0.8", 0x9cf15a7756ab88ed),
("ec.sim.ccballaction/0/32bpc/t2.2", 0x9cf15a7756ab88ed),
("ec.sim.ccballaction/0/8bpc/half/t0.5", 0xe2e3a624434f8e88),
("ec.sim.ccballaction/0/8bpc/half/t1.5", 0xe2e3a624434f8e88),
("ec.sim.ccballaction/0/8bpc/half/t0.8", 0xe2e3a624434f8e88),
("ec.sim.ccballaction/0/8bpc/half/t2.2", 0xe2e3a624434f8e88),
("ec.sim.ccballaction/1/8bpc/t0.5", 0x07382912d068a625),
("ec.sim.ccballaction/1/8bpc/t1.5", 0x07382912d068a625),
("ec.sim.ccballaction/1/8bpc/t0.8", 0x07382912d068a625),
("ec.sim.ccballaction/1/8bpc/t2.2", 0x07382912d068a625),
("ec.sim.ccballaction/1/32bpc/t0.5", 0xa1e843936e72815f),
("ec.sim.ccballaction/1/32bpc/t1.5", 0xa1e843936e72815f),
("ec.sim.ccballaction/1/32bpc/t0.8", 0xa1e843936e72815f),
("ec.sim.ccballaction/1/32bpc/t2.2", 0xa1e843936e72815f),
("ec.sim.ccballaction/2/8bpc/t0.5", 0x0b6bf26753ee4582),
("ec.sim.ccballaction/2/8bpc/t1.5", 0x0b6bf26753ee4582),
("ec.sim.ccballaction/2/8bpc/t0.8", 0x0b6bf26753ee4582),
+2
View File
@@ -228,6 +228,8 @@ pub(crate) fn sprite_layer(e: &mut Enc, src: &GpuImage, plan: &SpritePlan) -> Op
Shape::Square => (6.0, 0.0, 0.0),
Shape::Tri => (7.0, 0.0, 0.0),
Shape::Line { dx, dy } => (8.0, dx, dy),
// The strength rides in the (otherwise unused) first segment slot.
Shape::Ball { shade } => (9.0, shade, 0.0),
};
let mut rec = [kind, s.x, s.y, s.r, s.c[0], s.c[1], s.c[2], s.c[3], s.rot, dx, dy, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0];
match plan.tints.get(i).copied().unwrap_or(Tint::Fixed) {
+21
View File
@@ -145,6 +145,27 @@ fn fxm_sprite(at: u32, x: f32, y: f32) -> FxmShade {
}
cov = fxm_aa(m);
}
// sim::Shape::Ball (CC Ball Action's Shading): the sphere's light and shine scaled by
// |shade| (data[at + 9]), lit from the lower right when shade < 0.
case 9u: {
let d = sqrt(dx * dx + dy * dy);
let cv = fxm_aa(r - d);
if (cv <= 0.0) {
return fxm_none();
}
let shade = data[at + 9u];
let nx = dx / r;
let ny = dy / r;
let nz = sqrt(max(1.0 - nx * nx - ny * ny, 0.0));
let m = select(1.0, -1.0, shade < 0.0);
let diff = max(nx * (-0.48 * m) + ny * (-0.58 * m) + nz * 0.66, 0.0);
let rz = 2.0 * diff * nz - 0.66;
let st = abs(shade);
let spec = powz(max(rz, 0.0), 20.0) * 0.6 * st;
let k = max(1.0 - st * 0.8 * (1.0 - diff), 0.0);
rgb = rgb * k + spec;
cov = cv;
}
default: {
let lx = data[at + 9u];
let ly = data[at + 10u];
+16 -1
View File
@@ -141,7 +141,22 @@ fn ball_action_pixel_polly_scatterize() {
0.0,
0.0,
);
case("ec.sim.ccballaction", &[("gridSpacing", n(2.0)), ("ballSize", n(80.0)), ("instabilityState", n(45.0)), ("twistProperty", e(2))], 0.0, 0.0);
case("ec.sim.ccballaction", &[("gridSpacing", n(2.0)), ("ballSize", n(80.0)), ("scatterMotion", n(45.0)), ("twistProperty", e(2))], 0.0, 0.0);
// #3197: Shading (flat, weaker, stronger, lit from the other side), Coloring, Displace.
for shading in [0.0, -30.0, -100.0, 60.0, 1e45] {
case("ec.sim.ccballaction", &[("ballSize", n(80.0)), ("shading", n(shading))], 0.0, 0.0);
}
for coloring in [0, 2] {
case("ec.sim.ccballaction", &[("ballSize", n(80.0)), ("coloring", e(coloring))], 0.0, 0.0);
}
for prop in [3, 6, 8] {
case(
"ec.sim.ccballaction",
&[("ballSize", n(80.0)), ("rotationAxis", e(1)), ("rotation", n(30.0)), ("displace", n(40.0)), ("displaceProperty", e(prop))],
0.0,
0.0,
);
}
for object in 0..4 {
case("ec.sim.ccpixelpolly", &[("object", e(object)), ("gridSpacing", n(6.0))], 0.6, 0.0);
}
+2 -2
View File
@@ -3,7 +3,7 @@
<!-- Generated from the effect registry (crates/effects/src/catalog.rs); do not edit by hand.
Regenerate: UPDATE_DOCS=1 cargo test -p effectcraft-effects --lib effects_doc_is_current -->
EffectCraft ships 308 effects with 2988 parameters in total, grouped into the same categories as the Effects & Presets panel. Every effect is our own implementation, written from public behaviour descriptions and standard image-processing literature. Parameter names, order, popup options, units, defaults and ranges follow the reference application so that projects, expressions and muscle memory carry over.
EffectCraft ships 308 effects with 2992 parameters in total, grouped into the same categories as the Effects & Presets panel. Every effect is our own implementation, written from public behaviour descriptions and standard image-processing literature. Parameter names, order, popup options, units, defaults and ranges follow the reference application so that projects, expressions and muscle memory carry over.
- **GPU**: 280 effects also run on the GPU compositor with identical results.
- **32**: 308 effects process 32-bit float (HDR, overbright) pixels without clamping.
@@ -319,7 +319,7 @@ Effects are addressed by id (`ec.<category>.<name>`) or display name in commands
| Effect | Id | Params | GPU | 32 | Status |
|---|---|---:|:-:|:-:|---|
| CC Ball Action | `ec.sim.ccballaction` | 8 | GPU | 32 | Implemented |
| CC Ball Action | `ec.sim.ccballaction` | 12 | GPU | 32 | Implemented |
| CC Bubbles | `ec.sim.ccbubbles` | 7 | GPU | 32 | Implemented |
| CC Drizzle | `ec.sim.ccdrizzle` | 14 | GPU | 32 | Implemented |
| CC Hair | `ec.sim.cchair` | 20 | GPU | 32 | Implemented |