oak-team/oak-editor
3
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

nodes: OpenFX-Misc cleanroom GPU ports, grouped and collapsible in the library

Browse Source 
21 built-in effects reimplemented as native GPU nodes from the
OpenFX-Misc algorithm references (cleanroom, docs in
docs/zh/plans/ofx-misc-gpu-cleanroom.md):
- Color: Color Correct, Gamma, Saturation, Invert, Clamp, Grade
- Matrix/morphology: Color Matrix, Edge Detect, Dilate, Erode
- Blur: Directional Blur, Sharpen (unsharp mask)
- Merge: Dissolve, Key Mix, Premultiply, Unpremultiply
- Geometry/generators: Position, Mirror, Checkerboard, Color Bars, Ramp

Every node carries unit tests plus GPU pixel tests (28 cases over five
ofxmisc_* suites). The effect library groups built-ins by category
(color/filter/distort/keying/generator/math/general) with collapsible
group headers persisted to the config; the inspector's add menu groups
the same way. Registration wiring and the factory smoke table land with
the adjustment/transition wave sharing the same files.
This commit is contained in:
Mike-Solar
2026-09-10 22:02:38 +08:00
parent 5f8db8e31c
commit a7916aa93d
29 changed files with 9358 additions and 36 deletions
Download Patch File Download Diff File Expand all files Collapse all files
crates/oak-app/src/panels/effect_library.rs
+342 -28
View File
@@ -15,10 +15,13 @@
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//! The effect library panel (效果库): every effect type the engine can add
//! to a clip's chain, as a flat list. Double-clicking an entry appends the
//! effect to the selected clip's effect chain (the undoable
//! to a clip's chain, as a grouped list. Double-clicking an entry appends
//! the effect to the selected clip's effect chain (the undoable
//! [`AppEngine::add_effect`]; the insertion index is clamped to the chain
//! end by the backend).
//! end by the backend). Every group header collapses and expands its
//! entries; the collapsed set is persisted across sessions.
use std::collections::HashSet;
use gpui::colors::DefaultColors;
use gpui::dock::{DockPanel, PanelEvent};
@@ -30,16 +33,26 @@ use gpui_elements::editable_text::{EditableTextState, StringStorage, TextChanged
use crate::oakui::component::text_input;
use crate::i18n;
use crate::oakui::effectchain::group_label;
use crate::oakui::engine::EffectEntry;
use crate::oakui::AppEngine;
use crate::panels::commands::PanelCommandHandler;
use crate::panels::ids::EFFECT_LIBRARY;
/// The config key the collapsed groups are persisted under (a comma
/// separated list of group keys — the keys [`EffectEntry::group`] holds,
/// not the display labels).
const COLLAPSED_CONFIG_KEY: &str = "EffectLibraryCollapsed";
/// The effect library panel.
pub struct EffectLibraryPanel<E: AppEngine> {
engine: Entity<E>,
/// The search box state: live-filters the list by name / type id
/// (case-insensitive substring).
search: Entity<EditableTextState>,
/// The group keys whose entries are collapsed away. The headers stay
/// rendered (and clickable) so a collapsed group can be reopened.
collapsed: HashSet<String>,
}
impl<E: AppEngine> EffectLibraryPanel<E> {
@@ -53,10 +66,81 @@ impl<E: AppEngine> EffectLibraryPanel<E> {
cx.notify();
})
.detach();
Self { engine, search }
Self {
engine,
search,
collapsed: load_collapsed(),
}
}
}
/// Reads the persisted collapsed groups (a missing or malformed value
/// simply starts with every group expanded).
fn load_collapsed() -> HashSet<String> {
parse_collapsed(
&oak_core::configstore::ConfigStore::instance()
.get(None, COLLAPSED_CONFIG_KEY)
.unwrap_or_default(),
)
}
/// Parses the persisted comma separated key list; blanks and padding
/// drop, so a hand-edited value cannot produce a phantom group.
fn parse_collapsed(raw: &str) -> HashSet<String> {
raw.split(',')
.map(str::trim)
.filter(|key| !key.is_empty())
.map(str::to_string)
.collect()
}
/// Serializes the collapsed set for the config: sorted and comma
/// separated, so an unchanged set persists an unchanged string.
fn format_collapsed(collapsed: &HashSet<String>) -> String {
let mut keys: Vec<&str> = collapsed.iter().map(String::as_str).collect();
keys.sort_unstable();
keys.join(",")
}
/// Writes the collapsed set back to the config (the `UseProxyMedia`
/// pattern: the config store is the source of truth, read once at panel
/// construction).
fn store_collapsed(collapsed: &HashSet<String>) {
oak_core::configstore::ConfigStore::instance().set(
None,
COLLAPSED_CONFIG_KEY,
&format_collapsed(collapsed),
);
}
/// Flips the collapsed state of `group_key`, returning the new state
/// (`true` = collapsed).
fn toggle_collapsed(collapsed: &mut HashSet<String>, group_key: &str) -> bool {
if collapsed.remove(group_key) {
false
} else {
collapsed.insert(group_key.to_string());
true
}
}
/// Whether `entry` matches the trimmed, lowercased search query.
fn matches_query(entry: &EffectEntry, query: &str) -> bool {
query.is_empty()
|| entry.name.to_lowercase().contains(query)
|| entry.type_id.to_lowercase().contains(query)
}
/// Whether `entry`'s row is collapsed away. The collapse only narrows the
/// unfiltered list: a search looks through every group, collapsed or not.
fn hidden_by_collapse(entry: &EffectEntry, query: &str, collapsed: &HashSet<String>) -> bool {
query.is_empty()
&& entry
.group
.as_deref()
.is_some_and(|group| collapsed.contains(group))
}
/// The effect library implements no focused-panel commands: everything
/// falls through to the shell's global handler.
impl<E: AppEngine> PanelCommandHandler for EffectLibraryPanel<E> {}
@@ -77,28 +161,45 @@ impl<E: AppEngine> Render for EffectLibraryPanel<E> {
.p_2()
.overflow_y_scroll();
// Built-in effects render flat under a Built-in header; OpenFX
// plugin entries are grouped under their sub-category header
// (Filter / Generator / Transition / General — the C++
// `factorymenu` OpenFX branch). The engine table arrives sorted
// (built-ins first, then groups and names alphabetically); the
// search box live-filters by name / type id.
// Built-in effects group by their category (color / filter /
// distort / keying / generator / math / general, see
// `effectchain::category_group_key`); OpenFX plugin entries group
// by their sub-category (Filter / Generator / Transition /
// General — the C++ `factorymenu` OpenFX branch). The engine table
// arrives sorted (built-ins first, then groups and names
// alphabetically); the search box live-filters by name / type id
// and always searches collapsed groups too.
let mut last_group: Option<Option<String>> = None;
for entry in &effects {
if !query.is_empty()
&& !entry.name.to_lowercase().contains(&query)
&& !entry.type_id.to_lowercase().contains(&query)
{
if !matches_query(entry, &query) {
continue;
}
let group_key = entry.group.clone();
if last_group.as_ref() != Some(&group_key) {
last_group = Some(group_key);
last_group = Some(group_key.clone());
let key = group_key.clone().unwrap_or_default();
let label = match &entry.group {
Some(group) => group.clone(),
Some(group) => group_label(group),
None => i18n::tr("effect_library.group.builtin").to_string(),
};
list = list.child(group_header(&colors, &label));
let collapsed = self.collapsed.contains(&key);
list = list.child(group_header(
&colors,
&key,
&label,
collapsed,
cx.listener({
let key = key.clone();
move |this, _event: &ClickEvent, _window, cx| {
toggle_collapsed(&mut this.collapsed, &key);
store_collapsed(&this.collapsed);
cx.notify();
}
}),
));
}
if hidden_by_collapse(entry, &query, &self.collapsed) {
continue;
}
let engine = self.engine.clone();
let row_id = entry.type_id.clone();
@@ -183,18 +284,37 @@ impl<E: AppEngine> Render for EffectLibraryPanel<E> {
}
}
/// The sub-category header row of the OpenFX group (a muted, all-caps
/// line above the plugin entries).
fn group_header(colors: &gpui::colors::Colors, group: &str) -> impl IntoElement {
/// The header row of a group: a muted semibold line with a ▶ / ▼ marker
/// that collapses and expands the group's entries. `group_key` is the raw
/// key ([`EffectEntry::group`], also the element id suffix); `label` is
/// its display string.
fn group_header(
colors: &gpui::colors::Colors,
group_key: &str,
label: &str,
collapsed: bool,
on_toggle: impl Fn(&ClickEvent, &mut Window, &mut App) + 'static,
) -> impl IntoElement {
div()
.id(SharedString::from(format!("effect-library-group-{group}")))
.id(SharedString::from(format!("effect-library-group-{group_key}")))
.debug_selector({
let key = group_key.to_string();
move || format!("effect-library-group-row-{key}")
})
.cursor_pointer()
.pt_2()
.pb_1()
.px_2()
.flex()
.items_center()
.gap_1()
.text_xs()
.font_weight(gpui::FontWeight(600.0))
.text_color(colors.disabled)
.child(group.to_string())
.hover(|style| style.text_color(colors.text))
.child(if collapsed { "▶" } else { "▼" })
.child(label.to_string())
.on_click(on_toggle)
}
/// The drag ghost shown under the pointer while an effect is dragged out
@@ -241,12 +361,99 @@ impl<E: AppEngine> DockPanel for EffectLibraryPanel<E> {
mod tests {
use super::*;
use crate::oakui::MockEngine;
use gpui::{px, size, TestAppContext, VisualTestContext};
use gpui::{px, size, Modifiers, Point, TestAppContext, VisualTestContext};
/// Serializes the tests that read or write the process-global
/// collapsed-group key, and starts them from a clean value (a
/// developer's own persisted choice would otherwise hide rows from
/// the render tests).
fn collapsed_config_lock() -> std::sync::MutexGuard<'static, ()> {
static LOCK: std::sync::Mutex<()> = std::sync::Mutex::new(());
let guard = LOCK.lock().unwrap_or_else(|e| e.into_inner());
store_collapsed(&HashSet::new());
guard
}
/// A one-entry table row for the pure collapse logic.
fn entry(group: Option<&str>) -> EffectEntry {
EffectEntry {
type_id: "oak:testeffect".to_string(),
name: "Test Effect".to_string(),
group: group.map(str::to_string),
}
}
/// The row selector `debug_bounds` looks up (leaked: it needs a
/// `&'static str` and tests are process-lifetime).
fn row_selector(type_id: &str) -> &'static str {
Box::leak(format!("effect-library-row-{type_id}").into_boxed_str())
}
/// The collapse toggle and the collapsed-row predicate — a collapsed
/// group hides its rows, but a search still looks inside it.
#[test]
fn collapsed_rows_toggle_and_stay_searchable() {
let color = entry(Some("color"));
let mut collapsed = HashSet::new();
assert!(!hidden_by_collapse(&color, "", &collapsed));
assert!(toggle_collapsed(&mut collapsed, "color"), "first toggle collapses");
assert!(hidden_by_collapse(&color, "", &collapsed));
assert!(
!hidden_by_collapse(&color, "blur", &collapsed),
"a search looks through collapsed groups"
);
assert!(
!hidden_by_collapse(&color, "", &HashSet::new()),
"an unlisted group stays open"
);
assert!(!toggle_collapsed(&mut collapsed, "color"), "second toggle expands");
assert!(collapsed.is_empty());
}
/// The search predicate: name or type id, case-folded substring.
#[test]
fn query_matches_name_and_type_id() {
let color = entry(Some("color"));
assert!(matches_query(&color, ""));
assert!(matches_query(&color, "test"));
assert!(matches_query(&color, "oak:test"));
assert!(!matches_query(&color, "blur"));
}
/// The persisted form round-trips: sorted comma separated keys, with
/// padding and blank entries dropped.
#[test]
fn collapsed_list_round_trips() {
let collapsed: HashSet<String> =
["keying", "color"].iter().map(|k| k.to_string()).collect();
let raw = format_collapsed(&collapsed);
assert_eq!(raw, "color,keying");
assert_eq!(parse_collapsed(&raw), collapsed);
assert_eq!(parse_collapsed(&format!(" {raw} , ")), collapsed);
assert!(parse_collapsed("").is_empty());
assert!(parse_collapsed(" , ").is_empty());
}
/// The panel's storage path: the collapsed set survives a store/load
/// cycle through the process config store.
#[test]
fn collapsed_state_persists_in_the_config() {
let _guard = collapsed_config_lock();
assert!(load_collapsed().is_empty(), "the lock starts from a clear key");
let collapsed: HashSet<String> =
["distort", "general"].iter().map(|k| k.to_string()).collect();
store_collapsed(&collapsed);
assert_eq!(load_collapsed(), collapsed);
store_collapsed(&HashSet::new());
assert!(load_collapsed().is_empty());
}
/// The panel renders one row per addable effect of the engine (the
/// mock exposes the real factory's video-effect table).
#[gpui::test]
async fn lists_every_addable_effect(cx: &mut TestAppContext) {
let _guard = collapsed_config_lock();
cx.update(|cx| cx.init_colors());
let window = cx.open_window(size(px(400.0), px(600.0)), |window, cx| {
let engine = cx.new(|cx| MockEngine::demo(cx));
@@ -259,14 +466,121 @@ mod tests {
assert!(!expected.is_empty());
for entry in &expected {
let type_id = &entry.type_id;
// `debug_bounds` takes a &'static selector; the per-row selector is
// dynamic, so the test leaks it (process-lifetime, test-only).
let selector: &'static str =
Box::leak(format!("effect-library-row-{type_id}").into_boxed_str());
assert!(
cx.debug_bounds(selector).is_some(),
cx.debug_bounds(row_selector(type_id)).is_some(),
"effect row {type_id} rendered"
);
}
}
/// A collapsed group keeps its header (so it can be reopened) but
/// renders none of its rows; the groups below it are unaffected.
#[gpui::test]
async fn collapsing_a_group_hides_its_rows(cx: &mut TestAppContext) {
let _guard = collapsed_config_lock();
let entries = crate::oakui::effectchain::addable_effects();
let group = entries
.first()
.and_then(|entry| entry.group.clone())
.expect("the engine's table is grouped");
let other = entries
.iter()
.find(|entry| entry.group.as_deref() != Some(group.as_str()))
.expect("the table spreads over more than one group")
.clone();
cx.update(|cx| cx.init_colors());
let window = cx.open_window(size(px(400.0), px(600.0)), |window, cx| {
let engine = cx.new(|cx| MockEngine::demo(cx));
let mut panel = EffectLibraryPanel::new(engine, window, cx);
// The state the toggle writes (and the config reloads on the
// next start), without touching the process-global key.
panel.collapsed.insert(group.clone());
panel
});
cx.run_until_parked();
let cx = VisualTestContext::from_window(window.into(), cx).into_mut();
assert!(
cx.debug_bounds(Box::leak(
format!("effect-library-group-row-{group}").into_boxed_str()
))
.is_some(),
"the collapsed group keeps its header"
);
for entry in entries
.iter()
.filter(|entry| entry.group.as_deref() == Some(group.as_str()))
{
assert!(
cx.debug_bounds(row_selector(&entry.type_id)).is_none(),
"collapsed row {} is hidden",
entry.type_id
);
}
assert!(
cx.debug_bounds(row_selector(&other.type_id)).is_some(),
"the next group still renders its rows"
);
}
/// Clicking a group header is what writes the state: the group's rows
/// leave the render and the collapsed key lands in the persisted
/// config.
#[gpui::test]
async fn clicking_a_group_header_collapses_and_persists_it(cx: &mut TestAppContext) {
let _guard = collapsed_config_lock();
let entries = crate::oakui::effectchain::addable_effects();
let group = entries
.first()
.and_then(|entry| entry.group.clone())
.expect("the engine's table is grouped");
let row = entries
.iter()
.find(|entry| entry.group.as_deref() == Some(group.as_str()))
.expect("the group has rows")
.type_id
.clone();
cx.update(|cx| cx.init_colors());
let window = cx.open_window(size(px(400.0), px(600.0)), |window, cx| {
let engine = cx.new(|cx| MockEngine::demo(cx));
EffectLibraryPanel::new(engine, window, cx)
});
cx.run_until_parked();
let mut visual = VisualTestContext::from_window(window.into(), cx).into_mut();
visual.update(|window, cx| {
window.draw(cx).clear();
});
let header = visual
.debug_bounds(Box::leak(
format!("effect-library-group-row-{group}").into_boxed_str(),
))
.expect("the group header is painted");
let center = Point::new(
header.origin.x + header.size.width * 0.5,
header.origin.y + header.size.height * 0.5,
);
assert!(
visual.debug_bounds(row_selector(&row)).is_some(),
"the row starts visible"
);
visual.simulate_click(center, Modifiers::default());
visual.update(|window, cx| {
window.draw(cx).clear();
});
assert!(
visual.debug_bounds(row_selector(&row)).is_none(),
"the clicked group collapsed"
);
assert!(
load_collapsed().contains(&group),
"the collapse was persisted under {COLLAPSED_CONFIG_KEY}"
);
}
}
crates/oak-app/src/panels/inspector.rs
+127 -8
View File
@@ -29,6 +29,8 @@ use gpui::{
use crate::oakui::component::menu::{Menu, MenuItem};
use crate::oakui::component::menu::{ContextMenuHandle, ContextMenuTriggered};
use crate::oakui::effectchain::group_label;
use crate::oakui::engine::EffectEntry;
use crate::oakui::AppEngine;
use crate::panels::commands::PanelCommandHandler;
use crate::panels::ids::INSPECTOR;
@@ -141,13 +143,13 @@ impl<E: AppEngine> InspectorPanel<E> {
}
}
/// The "add effect" menu: one clickable row per addable effect of the
/// engine. Selecting a row inserts that effect at the recorded stack
/// index; the ✕ in the pinned header closes the menu without adding.
/// The list is height-capped and scrollable (with the OFX plugins
/// registered it runs to 150+ rows — an uncapped list pushed the
/// dismiss affordance far off-screen, making the menu impossible to
/// close).
/// The "add effect" menu: a group header row per resolved effect group,
/// each followed by that group's effect rows. Selecting an effect row
/// inserts it at the recorded stack index; the ✕ in the pinned header
/// closes the menu without adding. The list is height-capped and
/// scrollable (with the OFX plugins registered it runs to 150+ rows — an
/// uncapped list pushed the dismiss affordance far off-screen, making the
/// menu impossible to close).
fn render_add_menu(
&mut self,
index: usize,
@@ -165,7 +167,26 @@ impl<E: AppEngine> InspectorPanel<E> {
.px_2()
.py_1();
for entry in &effects {
for row in add_menu_rows(&effects) {
let entry = match row {
AddMenuRow::Header { key, label } => {
let key = key.unwrap_or_default().to_string();
list = list.child(
div()
.id(SharedString::from(format!("add-effect-group-{key}")))
.debug_selector(move || format!("add-effect-group-row-{key}").into())
.pt_2()
.pb_1()
.px_2()
.text_xs()
.font_weight(gpui::FontWeight(600.0))
.text_color(colors.disabled)
.child(label),
);
continue;
}
AddMenuRow::Effect(entry) => entry,
};
let engine = self.engine.clone();
let type_id = entry.type_id.clone();
let name = entry.name.clone();
@@ -236,6 +257,51 @@ impl<E: AppEngine> InspectorPanel<E> {
}
}
// ---------------------------------------------------------------------------
// Add-effect menu rows — the engine's addable-effect table (already grouped
// and sorted) flattened into one non-clickable header per group followed by
// the group's entries. The labels come from the same
// `effectchain::group_label` resolution the effect library uses, so both
// surfaces name a group alike.
// ---------------------------------------------------------------------------
/// One row of the add-effect menu.
enum AddMenuRow<'a> {
/// A group's header: the raw group key (`None` for an entry without a
/// group, i.e. a built-in from before the category grouping) and its
/// display label.
Header {
/// The group key, the same value [`EffectEntry::group`] holds.
key: Option<&'a str>,
/// The localized label.
label: String,
},
/// One addable effect.
Effect(&'a EffectEntry),
}
/// Flattens `entries` — in the order the engine yields them, groups
/// contiguous and sorted — into header + entry rows.
fn add_menu_rows(entries: &[EffectEntry]) -> Vec<AddMenuRow<'_>> {
let mut rows = Vec::with_capacity(entries.len() + 8);
let mut last: Option<Option<&str>> = None;
for entry in entries {
let group = entry.group.as_deref();
if last != Some(group) {
last = Some(group);
rows.push(AddMenuRow::Header {
key: group,
label: match group {
Some(group) => group_label(group),
None => crate::i18n::tr("effect_library.group.builtin").to_string(),
},
});
}
rows.push(AddMenuRow::Effect(entry));
}
rows
}
/// The inspector implements no focused-panel commands: everything falls
/// through to the shell's global handler.
impl<E: AppEngine> PanelCommandHandler for InspectorPanel<E> {}
@@ -378,4 +444,57 @@ mod tests {
}
}
}
/// The add menu flattens the engine's table into one header per group,
/// labelled through the same resolution the effect library uses, with
/// the entries keeping the engine's (grouped, sorted) order.
#[test]
fn add_menu_rows_emit_one_header_per_group() {
let entries = vec![
EffectEntry {
type_id: "oak:first".to_string(),
name: "First".to_string(),
group: Some("color".to_string()),
},
EffectEntry {
type_id: "oak:second".to_string(),
name: "Second".to_string(),
group: Some("color".to_string()),
},
EffectEntry {
type_id: "ofx:plugin".to_string(),
name: "Plugin".to_string(),
group: Some("Filter".to_string()),
},
EffectEntry {
type_id: "oak:ungrouped".to_string(),
name: "Ungrouped".to_string(),
group: None,
},
];
let shape: Vec<String> = add_menu_rows(&entries)
.iter()
.map(|row| match row {
AddMenuRow::Header { key, label } => {
format!("header:{}:{label}", key.unwrap_or("-"))
}
AddMenuRow::Effect(entry) => format!("effect:{}", entry.type_id),
})
.collect();
assert_eq!(
shape,
vec![
format!("header:color:{}", group_label("color")),
"effect:oak:first".to_string(),
"effect:oak:second".to_string(),
format!("header:Filter:{}", group_label("Filter")),
"effect:ofx:plugin".to_string(),
format!(
"header:-:{}",
crate::i18n::tr("effect_library.group.builtin")
),
"effect:oak:ungrouped".to_string(),
]
);
}
}
crates/oak-node/src/nodes/checkerboard.rs
+410
View File
@@ -0,0 +1,410 @@
// Oak Video Editor - Non-Linear Video Editor
// Copyright (C) 2026 Oak Team
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//! Checkerboard generator: clean-room reimplementation of the
//! OpenFX-Misc `CheckerBoard` plugin's parameter semantics (upstream
//! github.com/cgvirus/OpenFX-Misc, GPL2; read for behavior only, no
//! upstream code copied).
//!
//! Deviations from the upstream plugin: it offers four checker colors
//! (`color0`..`color3`, the second pair for a two-cell pattern), a line
//! color/width pair and a centerline color/width pair; this node renders
//! the plain two-color checkerboard only (`color1_in`/`color2_in`, the
//! upstream `color1`/`color2`).
use crate::factory::NodeMeta;
use crate::jobs::ShaderJobPayload;
use crate::node::{Category, NodeBehavior, NodeCore};
/// Base texture input id (the shared generator-with-merge base). Type:
/// texture; flags: not-keyframable; this is the generator's effect input.
pub const BASE_INPUT: &str = super::generatorwithmerge::BASE_INPUT;
/// Box size input id (upstream `kParamBoxSize` "Box Size"). Type: vec2;
/// default `[64.0, 64.0]`; properties: `min = [0.0, 0.0]`; units: pixels
/// of `resolution_in`.
pub const SIZE_INPUT: &str = "size_in";
/// First checker color input id (upstream `kParamColor1`, the color of
/// the top-left box). Type: color; default `[0.1, 0.1, 0.1, 1.0]`;
/// properties: `view = color`.
pub const COLOR1_INPUT: &str = "color1_in";
/// Second checker color input id (upstream `kParamColor2`). Type: color;
/// default `[0.5, 0.5, 0.5, 1.0]`; properties: `view = color`.
pub const COLOR2_INPUT: &str = "color2_in";
/// Checkerboard generator node.
pub struct CheckerBoardNode;
/// Fragment shader for the `"checkerboard"` shader id.
///
/// Pixel space: `ove_texcoord * resolution_in - resolution_in * 0.5`,
/// i.e. the center-origin pixel coordinates used by
/// [`super::transformdistortnode`]. The upstream plugin anchors the
/// pattern origin at the center of the image (its `color0` hint names
/// "the top-left of the image center"), so the cell index is
/// `floor(px / box_size)` and the pattern's parity is the sum of the cell
/// indices — the shaded cells alternate like a checkerboard. Sizes below
/// one pixel would divide by zero, so the box size is clamped to
/// `>= 1.0`.
const SHADER_FRAG: &str = r#"uniform vec2 resolution_in;
uniform vec2 size_in;
uniform vec4 color1_in;
uniform vec4 color2_in;
in vec2 ove_texcoord;
out vec4 frag_color;
void main(void) {
vec2 px = ove_texcoord * resolution_in - resolution_in * 0.5;
vec2 box = max(size_in, vec2(1.0));
vec2 cell = floor(px / box);
// Parity of the cell index sum, valid for negative cell indices too
// (`mod` in GLSL is `x - y * floor(x / y)`).
float s = cell.x + cell.y;
float parity = s - 2.0 * floor(s * 0.5);
if (parity < 0.5) {
frag_color = color1_in;
} else {
frag_color = color2_in;
}
}
"#;
impl CheckerBoardNode {
/// Fragment shader for the `"checkerboard"` request.
fn shader_frag() -> &'static str {
SHADER_FRAG
}
}
impl NodeBehavior for CheckerBoardNode {
/// Human-readable name.
fn name(&self) -> &str {
"Checkerboard"
}
/// Stable type id.
fn type_id(&self) -> &str {
"org.olivevideoeditor.Olive.checkerboard"
}
/// Categories.
fn categories(&self) -> &[Category] {
&[Category::Generator]
}
/// Description.
fn description(&self) -> &str {
"Generate a checkerboard pattern."
}
/// Localized input names: the merge base's `base_in` -> "Base" plus
/// `size_in` -> "Box Size", `color1_in` -> "Color 1", `color2_in` ->
/// "Color 2".
fn input_name<'a>(&self, id: &'a str) -> &'a str {
match id {
BASE_INPUT => "Base",
SIZE_INPUT => "Box Size",
COLOR1_INPUT => "Color 1",
COLOR2_INPUT => "Color 2",
_ => id,
}
}
/// Evaluate outputs: a `"checkerboard"` shader job over the value row,
/// pushed through `push_mergable_job` — merged alpha-over `base_in`
/// when a base texture is connected, pushed bare otherwise (matching
/// the shared generator-with-merge wiring).
///
/// The params row carries `size_in` and the two colors; `resolution_in`
/// is filled by the runner from the render target size, so it is not
/// part of the params here.
fn value(
&self,
core: &NodeCore,
inputs: &crate::value::NodeValueRow,
time: oak_core::Rational,
table: &mut crate::value::NodeValueTable,
) {
let mut params = inputs.clone();
// The inputs are part of the row in the traverser flow (the bare
// key is always inserted for an unconnected input); fall back to
// the node's own values for direct `value()` calls.
for id in [SIZE_INPUT, COLOR1_INPUT, COLOR2_INPUT] {
if !params.contains_key(id) {
params.insert(id.to_string(), core.value_at_time(id, -1, time));
}
}
let job = crate::handle::make_owned(ShaderJobPayload {
node_id: crate::id::NodeId::INVALID,
time,
iterations: 1,
type_id: self.type_id().to_string(),
shader_id: "checkerboard".to_string(),
effect_input: core.effect_input.clone(),
params,
iterative_input: String::new(),
});
super::generatorwithmerge::GeneratorWithMerge::push_mergable_job(inputs, job, table);
}
/// Shader code request: `"checkerboard"` returns this node's shader;
/// the `"mrg"` request returns the shared alpha-over merge shader;
/// anything else is unsupported.
fn shader_code(&self, request: &str) -> Option<String> {
match request {
"checkerboard" => Some(Self::shader_frag().to_string()),
"mrg" => Some(super::generatorwithmerge::merge_shader_frag().to_string()),
_ => None,
}
}
/// Deep copy.
fn duplicate(&self, _core: &NodeCore) -> Option<Box<dyn NodeBehavior>> {
Some(Box::new(CheckerBoardNode))
}
}
/// Constructor: adds `base_in` (not-keyframable), `size_in`, `color1_in`
/// and `color2_in` with the defaults and properties documented on the
/// constants, sets the video-effect flag and makes `base_in` the effect
/// input (the `GeneratorWithMerge` constructor side effects).
pub fn create() -> (NodeCore, Box<dyn NodeBehavior>) {
let mut core = NodeCore::new();
let mut base = crate::input::Input::new(
BASE_INPUT,
crate::value::ValueType::Texture,
crate::value::NodeValue::None,
);
base.flags |= crate::input::flags::NOT_KEYFRAMABLE;
core.add_input(base);
let mut size = crate::input::Input::new(
SIZE_INPUT,
crate::value::ValueType::Vec2,
crate::value::NodeValue::Vec2([64.0, 64.0]),
);
size.properties = vec![("min".to_string(), crate::value::NodeValue::Vec2([0.0, 0.0]))];
core.add_input(size);
let mut color1 = crate::input::Input::new(
COLOR1_INPUT,
crate::value::ValueType::Color,
crate::value::NodeValue::Color([0.1, 0.1, 0.1, 1.0]),
);
color1.properties = vec![(
"view".to_string(),
crate::value::NodeValue::Text("color".into()),
)];
core.add_input(color1);
let mut color2 = crate::input::Input::new(
COLOR2_INPUT,
crate::value::ValueType::Color,
crate::value::NodeValue::Color([0.5, 0.5, 0.5, 1.0]),
);
color2.properties = vec![(
"view".to_string(),
crate::value::NodeValue::Text("color".into()),
)];
core.add_input(color2);
core.flags |= crate::node::flags::VIDEO_EFFECT;
core.effect_input = BASE_INPUT.to_string();
(core, Box::new(CheckerBoardNode))
}
#[cfg(test)]
mod tests {
use super::*;
use crate::node::NodeBehavior;
use crate::value::{NodeValue, NodeValueRow, NodeValueTable, ValueType};
use oak_core::Rational;
#[test]
fn input_names() {
let n = CheckerBoardNode;
assert_eq!(n.input_name(SIZE_INPUT), "Box Size");
assert_eq!(n.input_name(COLOR1_INPUT), "Color 1");
assert_eq!(n.input_name(COLOR2_INPUT), "Color 2");
assert_eq!(
n.input_name(super::super::generatorwithmerge::BASE_INPUT),
"Base"
);
}
#[test]
fn create_wires_inputs_and_flags() {
let (core, behavior) = create();
assert_eq!(behavior.type_id(), "org.olivevideoeditor.Olive.checkerboard");
assert_eq!(
core.get_input(SIZE_INPUT).unwrap().default,
NodeValue::Vec2([64.0, 64.0])
);
assert_eq!(
core.get_input(COLOR1_INPUT).unwrap().default,
NodeValue::Color([0.1, 0.1, 0.1, 1.0])
);
assert_eq!(
core.get_input(COLOR2_INPUT).unwrap().default,
NodeValue::Color([0.5, 0.5, 0.5, 1.0])
);
assert!(core.get_input(COLOR1_INPUT).unwrap().properties.iter().any(
|(k, v)| k == "view" && *v == NodeValue::Text("color".into())
));
assert_eq!(core.effect_input, BASE_INPUT);
assert_ne!(core.flags & crate::node::flags::VIDEO_EFFECT, 0);
}
#[test]
fn value_pushes_generator_job() {
let (core, behavior) = create();
let mut table = NodeValueTable::default();
behavior.value(
&core,
&NodeValueRow::default(),
Rational::new(0, 1),
&mut table,
);
let handle = match table.get(ValueType::Texture) {
Some(NodeValue::Texture(h)) => *h,
_ => panic!("texture expected"),
};
let payload = unsafe { crate::handle::get_checked::<ShaderJobPayload>(&handle) }
.expect("shader job payload expected");
assert_eq!(payload.type_id, "org.olivevideoeditor.Olive.checkerboard");
assert_eq!(payload.shader_id, "checkerboard");
assert_eq!(payload.iterations, 1);
assert_eq!(payload.effect_input, BASE_INPUT);
assert_eq!(payload.iterative_input, "");
// The unconnected inputs resolve from the node defaults.
assert_eq!(
payload.params.get(SIZE_INPUT),
Some(&NodeValue::Vec2([64.0, 64.0]))
);
assert_eq!(
payload.params.get(COLOR1_INPUT),
Some(&NodeValue::Color([0.1, 0.1, 0.1, 1.0]))
);
assert_eq!(
payload.params.get(COLOR2_INPUT),
Some(&NodeValue::Color([0.5, 0.5, 0.5, 1.0]))
);
}
#[test]
fn value_row_values_win_over_the_node_defaults() {
let (core, behavior) = create();
let inputs = NodeValueRow::from([
(SIZE_INPUT.to_string(), NodeValue::Vec2([4.0, 4.0])),
(COLOR1_INPUT.to_string(), NodeValue::Color([1.0, 0.0, 0.0, 1.0])),
]);
let mut table = NodeValueTable::default();
behavior.value(&core, &inputs, Rational::new(0, 1), &mut table);
let handle = match table.get(ValueType::Texture) {
Some(NodeValue::Texture(h)) => *h,
_ => panic!("texture expected"),
};
let payload = unsafe { crate::handle::get_checked::<ShaderJobPayload>(&handle) }
.expect("shader job payload expected");
assert_eq!(
payload.params.get(SIZE_INPUT),
Some(&NodeValue::Vec2([4.0, 4.0]))
);
assert_eq!(
payload.params.get(COLOR1_INPUT),
Some(&NodeValue::Color([1.0, 0.0, 0.0, 1.0]))
);
}
#[test]
fn value_with_base_merges_nested_job() {
let (core, behavior) = create();
let inputs = NodeValueRow::from([(
BASE_INPUT.to_string(),
NodeValue::Texture(crate::handle::CHandle::null()),
)]);
let mut table = NodeValueTable::default();
behavior.value(&core, &inputs, Rational::new(0, 1), &mut table);
let handle = match table.get(ValueType::Texture) {
Some(NodeValue::Texture(h)) => *h,
_ => panic!("texture expected"),
};
let merge = unsafe { crate::handle::get_checked::<ShaderJobPayload>(&handle) }
.expect("merge job payload expected");
assert_eq!(merge.shader_id, "mrg");
assert_eq!(merge.iterations, 1);
assert_eq!(merge.effect_input, BASE_INPUT);
assert!(merge.params.contains_key(BASE_INPUT));
// The generator's own parameters travel with the nested job; the
// merge payload carries only the base and the blend input.
assert!(!merge.params.contains_key(COLOR1_INPUT));
// The checkerboard job is nested as the merge's blend texture.
match merge.params.get(crate::nodes::merge::BLEND_INPUT) {
Some(NodeValue::Texture(blend)) => {
let nested = unsafe { crate::handle::get_checked::<ShaderJobPayload>(blend) }
.expect("nested job payload boxed");
assert_eq!(nested.shader_id, "checkerboard");
assert_eq!(
nested.params.get(COLOR1_INPUT),
Some(&NodeValue::Color([0.1, 0.1, 0.1, 1.0]))
);
}
_ => panic!("nested blend job expected"),
}
}
#[test]
fn shader_code_dispatches() {
let n = CheckerBoardNode;
let code = n.shader_code("checkerboard").unwrap();
assert!(code.contains("uniform vec2 size_in;"));
assert!(code.contains("uniform vec4 color1_in;"));
assert!(code.contains("uniform vec4 color2_in;"));
assert!(code.contains("uniform vec2 resolution_in;"));
assert!(code.contains("float parity = s - 2.0 * floor(s * 0.5);"));
assert!(!code.contains("switch"));
assert!(n
.shader_code("mrg")
.unwrap()
.contains("base_col *= 1.0 - blend_col.a;"));
assert!(n.shader_code("other").is_none());
}
#[test]
fn duplicate_clones() {
let (core, behavior) = create();
let dup = behavior.duplicate(&core).unwrap();
assert_eq!(dup.name(), "Checkerboard");
}
}
/// Register this node type.
pub fn register(meta: &mut Vec<NodeMeta>) {
meta.push(NodeMeta {
type_id: "org.olivevideoeditor.Olive.checkerboard",
name: "Checkerboard",
categories: &[Category::Generator],
create,
});
}
crates/oak-node/src/nodes/clamp.rs
+331
View File
@@ -0,0 +1,331 @@
// Oak Video Editor - Non-Linear Video Editor
// Copyright (C) 2026 Oak Team
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//! Clamp effect — a clean-room reimplementation of the OpenFX-Misc
//! `Clamp` plugin's parameter semantics (upstream
//! `github.com/cgvirus/OpenFX-Misc`, GPL2; read for behavior only, no
//! upstream code copied).
//!
//! Two scalars, one lower and one upper bound, applied to every
//! channel:
//!
//! ```text
//! lo = min(min_in, max_in)
//! hi = max(min_in, max_in)
//! x = min(max(x, lo), hi)
//! ```
//!
//! The min bound is applied first and the max bound second, so when
//! `max_in` is below `min_in` the result is `max_in` (the max wins the
//! conflicting range). The reference clamps all four components —
//! `processA` defaults to `true` — so alpha is clamped as well, which
//! differs from the color-only nodes in this group.
//!
//! The reference clamps with an explicit low/high `vec4` built from its
//! two parameters; the shader here does the equivalent with `min`/
//! `max` over `vec4` operands (the scalar-operand `clamp` overloads are
//! avoided on purpose — one less overload for the WGSL emitter to
//! resolve).
use crate::factory::NodeMeta;
use crate::jobs::ShaderJobPayload;
use crate::node::{Category, NodeBehavior, NodeCore};
/// Texture input id. Type: texture; flags: not-keyframable; this is
/// the node's effect input.
pub const TEXTURE_INPUT: &str = "tex_in";
/// Lower bound input id. Type: float; default `0.0`. Values below it
/// are raised to it.
pub const MIN_INPUT: &str = "min_in";
/// Upper bound input id. Type: float; default `1.0`. Values above it
/// are lowered to it.
pub const MAX_INPUT: &str = "max_in";
/// Clamp node. The reference class holds no state beyond its parameter
/// pointers, so this is a unit-like struct.
pub struct ClampNode;
/// Fragment shader (clean-room GLSL for the reference's
/// `ClampPlugin::render` chain). The uniforms are named after the node
/// inputs: the renderer binds uniforms by matching the declared name
/// against the job's parameter row.
const SHADER_FRAG: &str = r#"// Inputs
uniform sampler2D tex_in;
uniform float min_in;
uniform float max_in;
// Input texture coordinate
in vec2 ove_texcoord;
out vec4 frag_color;
void main() {
vec4 c = texture(tex_in, ove_texcoord);
// Lower bound first, upper bound second: when max_in < min_in the
// upper bound wins.
vec4 lo = vec4(min_in, min_in, min_in, min_in);
vec4 hi = vec4(max_in, max_in, max_in, max_in);
c = min(max(c, lo), hi);
frag_color = c;
}
"#;
impl NodeBehavior for ClampNode {
/// Human-readable name.
fn name(&self) -> &str {
"Clamp"
}
/// Stable type id.
fn type_id(&self) -> &str {
"org.olivevideoeditor.Olive.clamp"
}
/// Categories.
fn categories(&self) -> &[Category] {
&[Category::Color]
}
/// Description.
fn description(&self) -> &str {
"Clamp every channel to a lower and an upper bound."
}
/// Localized input names: `tex_in` -> "Input", `min_in` -> "Min",
/// `max_in` -> "Max".
fn input_name<'a>(&self, id: &'a str) -> &'a str {
match id {
TEXTURE_INPUT => "Input",
MIN_INPUT => "Min",
MAX_INPUT => "Max",
_ => id,
}
}
/// Evaluate outputs: no texture on `tex_in` -> push nothing;
/// texture present -> push a shader job over the input row with
/// both bounds resolved (so the renderer always finds a value for
/// each uniform, whether the row carried the input or the node's own
/// default/keyframe supplied it).
fn value(
&self,
core: &NodeCore,
inputs: &crate::value::NodeValueRow,
time: oak_core::Rational,
table: &mut crate::value::NodeValueTable,
) {
if !matches!(
inputs.get(TEXTURE_INPUT),
Some(crate::value::NodeValue::Texture(_))
) {
return;
}
let resolve = |id: &str| match inputs.get(id) {
Some(v) => v.clone(),
None => core.value_at_time(id, -1, time),
};
let mut params = inputs.clone();
params.insert(MIN_INPUT.to_string(), resolve(MIN_INPUT));
params.insert(MAX_INPUT.to_string(), resolve(MAX_INPUT));
table.push(
crate::value::ValueType::Texture,
crate::value::NodeValue::Texture(crate::handle::make_owned(ShaderJobPayload {
node_id: crate::id::NodeId::INVALID,
time,
iterations: 1,
type_id: self.type_id().to_string(),
shader_id: String::new(),
effect_input: core.effect_input.clone(),
params,
iterative_input: String::new(),
})),
None,
);
}
/// Shader code request: the request id is ignored; always returns
/// [`SHADER_FRAG`].
fn shader_code(&self, _request: &str) -> Option<String> {
Some(SHADER_FRAG.to_string())
}
/// Deep copy.
fn duplicate(&self, _core: &NodeCore) -> Option<Box<dyn NodeBehavior>> {
Some(Box::new(ClampNode))
}
}
/// Constructor: adds `tex_in` (texture, effect input) and the two
/// bounds with the defaults documented on the constants, and sets the
/// video-effect flag.
pub fn create() -> (NodeCore, Box<dyn NodeBehavior>) {
let mut core = NodeCore::new();
let mut tex = crate::input::Input::new(
TEXTURE_INPUT,
crate::value::ValueType::Texture,
crate::value::NodeValue::None,
);
tex.flags |= crate::input::flags::NOT_KEYFRAMABLE;
core.add_input(tex);
add_float_input(&mut core, MIN_INPUT, 0.0);
add_float_input(&mut core, MAX_INPUT, 1.0);
core.flags |= crate::node::flags::VIDEO_EFFECT;
core.effect_input = TEXTURE_INPUT.to_string();
(core, Box::new(ClampNode))
}
/// Add a float input with its default. The bounds themselves are
/// unbounded (the reference parameter has no range), so no `min`/`max`
/// properties are attached.
fn add_float_input(core: &mut NodeCore, id: &str, default: f64) {
core.add_input(crate::input::Input::new(
id,
crate::value::ValueType::Float,
crate::value::NodeValue::Float(default),
));
}
/// Register this node type.
pub fn register(meta: &mut Vec<NodeMeta>) {
meta.push(NodeMeta {
type_id: "org.olivevideoeditor.Olive.clamp",
name: "Clamp",
categories: &[Category::Color],
create,
});
}
#[cfg(test)]
mod tests {
use super::*;
use crate::value::{NodeValue, NodeValueTable, ValueType};
use oak_core::Rational;
#[test]
fn input_names() {
let n = ClampNode;
assert_eq!(n.input_name(TEXTURE_INPUT), "Input");
assert_eq!(n.input_name(MIN_INPUT), "Min");
assert_eq!(n.input_name(MAX_INPUT), "Max");
assert_eq!(n.input_name("other_in"), "other_in");
}
#[test]
fn create_wires_inputs_and_flags() {
let (core, behavior) = create();
assert_eq!(behavior.type_id(), "org.olivevideoeditor.Olive.clamp");
assert_eq!(behavior.name(), "Clamp");
assert_eq!(behavior.categories(), &[Category::Color]);
let tex = core.get_input(TEXTURE_INPUT).unwrap();
assert_ne!(tex.flags & crate::input::flags::NOT_KEYFRAMABLE, 0);
assert_eq!(
core.get_input(MIN_INPUT).unwrap().default,
NodeValue::Float(0.0)
);
assert_eq!(
core.get_input(MAX_INPUT).unwrap().default,
NodeValue::Float(1.0)
);
assert_eq!(core.effect_input, TEXTURE_INPUT);
assert_ne!(core.flags & crate::node::flags::VIDEO_EFFECT, 0);
}
#[test]
fn value_no_texture_pushes_nothing() {
let (core, behavior) = create();
let mut table = NodeValueTable::default();
behavior.value(
&core,
&crate::value::NodeValueRow::default(),
Rational::new(0, 1),
&mut table,
);
assert!(table.is_empty());
}
#[test]
fn value_with_texture_pushes_shader_job_with_resolved_params() {
let (core, behavior) = create();
let inputs = crate::value::NodeValueRow::from([(
TEXTURE_INPUT.to_string(),
NodeValue::Texture(crate::handle::CHandle::null()),
)]);
let mut table = NodeValueTable::default();
behavior.value(&core, &inputs, Rational::new(0, 1), &mut table);
let Some(NodeValue::Texture(handle)) = table.get(ValueType::Texture) else {
panic!("expected a texture-typed value");
};
let payload =
unsafe { crate::handle::get_checked::<crate::jobs::ShaderJobPayload>(handle) }
.expect("shader job pushed");
assert_eq!(payload.type_id, "org.olivevideoeditor.Olive.clamp");
assert_eq!(payload.effect_input, TEXTURE_INPUT);
assert_eq!(payload.params.get(MIN_INPUT), Some(&NodeValue::Float(0.0)));
assert_eq!(payload.params.get(MAX_INPUT), Some(&NodeValue::Float(1.0)));
}
#[test]
fn value_row_values_win_over_defaults() {
let (mut core, behavior) = create();
core.set_standard_value(MAX_INPUT, -1, NodeValue::Float(1.0));
let inputs = crate::value::NodeValueRow::from([
(
TEXTURE_INPUT.to_string(),
NodeValue::Texture(crate::handle::CHandle::null()),
),
(MAX_INPUT.to_string(), NodeValue::Float(0.5)),
]);
let mut table = NodeValueTable::default();
behavior.value(&core, &inputs, Rational::new(0, 1), &mut table);
let Some(NodeValue::Texture(handle)) = table.get(ValueType::Texture) else {
panic!("expected a texture-typed value");
};
let payload =
unsafe { crate::handle::get_checked::<crate::jobs::ShaderJobPayload>(handle) }
.expect("shader job pushed");
assert_eq!(payload.params.get(MAX_INPUT), Some(&NodeValue::Float(0.5)));
}
#[test]
fn shader_declares_uniforms_and_avoids_switch() {
let code = ClampNode.shader_code("").unwrap();
for uniform in ["tex_in", MIN_INPUT, MAX_INPUT] {
assert!(code.contains(uniform), "uniform {uniform} declared");
}
assert!(code.contains("ove_texcoord"));
assert!(code.contains("frag_color"));
assert!(!code.contains("switch"), "naga rejects GLSL switch");
}
#[test]
fn duplicate_clones() {
let (core, behavior) = create();
let dup = behavior.duplicate(&core).unwrap();
assert_eq!(dup.name(), "Clamp");
assert_eq!(dup.type_id(), "org.olivevideoeditor.Olive.clamp");
}
}
crates/oak-node/src/nodes/colorbars.rs
+395
View File
@@ -0,0 +1,395 @@
// Oak Video Editor - Non-Linear Video Editor
// Copyright (C) 2026 Oak Team
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//! SMPTE color bars generator: clean-room reimplementation of the
//! OpenFX-Misc `ColorBars` plugin's parameter semantics (upstream
//! github.com/cgvirus/OpenFX-Misc, GPL2; read for behavior only, no
//! upstream code copied).
//!
//! Deviations from the upstream plugin: it lays the pattern out on an
//! IRE-scale grid driven by `barIntensity` (0..100 IRE, default 75) and
//! `outputIRE`, with the bar heights in IRE units; this node renders the
//! standard SMPTE ECR layout instead — a 75% 7-bar top field (two thirds
//! of the frame), the mid strip of blue/black/magenta/black/cyan/black/
//! white, and the reverse-grayscale bottom field with the PLUGE on the
//! right — and exposes the upstream intensity choice as a two-way
//! `standard_in` combo (75% / 100%).
use crate::factory::NodeMeta;
use crate::jobs::ShaderJobPayload;
use crate::node::{Category, NodeBehavior, NodeCore};
/// Base texture input id (the shared generator-with-merge base). Type:
/// texture; flags: not-keyframable; this is the generator's effect input.
pub const BASE_INPUT: &str = super::generatorwithmerge::BASE_INPUT;
/// Standard input id (upstream `kParamBarIntensity` "Bar intensity",
/// default 75 IRE). Type: combo; default 0; combo strings: 0 = "SMPTE
/// 75%", 1 = "Full 100%". The 100% setting scales the chromatic bars and
/// the reverse-grayscale ramp to full amplitude.
pub const STANDARD_INPUT: &str = "standard_in";
/// SMPTE color bars generator node.
pub struct ColorBarsNode;
/// Fragment shader for the `"colorbars"` shader id.
///
/// The frame is split in normalized coordinates: the top field (`v <
/// 2/3`) holds the seven bars (white, yellow, cyan, green, magenta, red,
/// blue), the mid strip (`v < 3/4`) the blue/black/magenta/black/cyan/
/// black/white row, and the bottom field the reverse-grayscale ramp
/// (left-to-right decreasing) ending in the three-step PLUGE (below
/// black / black / above black). `ove_texcoord.y` runs downward — frame
/// row 0 is the top of the image — so the first branch is the top field.
///
/// `level` is the bar amplitude: 0.75 for the 75% standard, 1.0 for the
/// 100% one. The branch chain is spelled with if/else (a `switch` would
/// be rejected by the shader translator).
const SHADER_FRAG: &str = r#"uniform vec2 resolution_in;
uniform int standard_in;
in vec2 ove_texcoord;
out vec4 frag_color;
void main(void) {
float level = 0.75;
if (standard_in == 1) {
level = 1.0;
}
float column = floor(ove_texcoord.x * 7.0);
vec3 col = vec3(0.0);
if (ove_texcoord.y < 2.0 / 3.0) {
// Top field: white, yellow, cyan, green, magenta, red, blue.
if (column < 0.5) {
col = vec3(level);
} else if (column < 1.5) {
col = vec3(level, level, 0.0);
} else if (column < 2.5) {
col = vec3(0.0, level, level);
} else if (column < 3.5) {
col = vec3(0.0, level, 0.0);
} else if (column < 4.5) {
col = vec3(level, 0.0, level);
} else if (column < 5.5) {
col = vec3(level, 0.0, 0.0);
} else {
col = vec3(0.0, 0.0, level);
}
} else if (ove_texcoord.y < 3.0 / 4.0) {
// Mid strip: blue, black, magenta, black, cyan, black, white.
if (column < 0.5) {
col = vec3(0.0, 0.0, level);
} else if (column < 1.5) {
col = vec3(0.0);
} else if (column < 2.5) {
col = vec3(level, 0.0, level);
} else if (column < 3.5) {
col = vec3(0.0);
} else if (column < 4.5) {
col = vec3(0.0, level, level);
} else if (column < 5.5) {
col = vec3(0.0);
} else {
col = vec3(level);
}
} else {
// Bottom field: reverse grayscale ramp, then the PLUGE steps
// (below black / black / above black) in the last bar.
float g = level * (5.0 - column) / 5.0;
if (column > 5.5) {
float sub = floor((ove_texcoord.x * 7.0 - 6.0) * 3.0);
if (sub < 0.5) {
g = -0.04;
} else if (sub < 1.5) {
g = 0.0;
} else {
g = 0.04;
}
}
col = vec3(g);
}
frag_color = vec4(col, 1.0);
}
"#;
impl ColorBarsNode {
/// Fragment shader for the `"colorbars"` request.
fn shader_frag() -> &'static str {
SHADER_FRAG
}
}
impl NodeBehavior for ColorBarsNode {
/// Human-readable name.
fn name(&self) -> &str {
"Color Bars"
}
/// Stable type id.
fn type_id(&self) -> &str {
"org.olivevideoeditor.Olive.colorbars"
}
/// Categories.
fn categories(&self) -> &[Category] {
&[Category::Generator]
}
/// Description.
fn description(&self) -> &str {
"Generate SMPTE color bars."
}
/// Localized input names: the merge base's `base_in` -> "Base" plus
/// `standard_in` -> "Standard".
fn input_name<'a>(&self, id: &'a str) -> &'a str {
match id {
BASE_INPUT => "Base",
STANDARD_INPUT => "Standard",
_ => id,
}
}
/// Combo input option labels: `standard_in` -> "SMPTE 75%",
/// "Full 100%".
fn input_combo_strings(&self, id: &str) -> Vec<&'static str> {
match id {
STANDARD_INPUT => vec!["SMPTE 75%", "Full 100%"],
_ => Vec::new(),
}
}
/// Evaluate outputs: a `"colorbars"` shader job over the value row,
/// pushed through `push_mergable_job` — merged alpha-over `base_in`
/// when a base texture is connected, pushed bare otherwise.
///
/// The params row carries `standard_in`; `resolution_in` is filled by
/// the runner from the render target size, so it is not part of the
/// params here.
fn value(
&self,
core: &NodeCore,
inputs: &crate::value::NodeValueRow,
time: oak_core::Rational,
table: &mut crate::value::NodeValueTable,
) {
let mut params = inputs.clone();
// The input is part of the row in the traverser flow (the bare key
// is always inserted for an unconnected input); fall back to the
// node's own value for direct `value()` calls.
if !params.contains_key(STANDARD_INPUT) {
params.insert(
STANDARD_INPUT.to_string(),
core.value_at_time(STANDARD_INPUT, -1, time),
);
}
let job = crate::handle::make_owned(ShaderJobPayload {
node_id: crate::id::NodeId::INVALID,
time,
iterations: 1,
type_id: self.type_id().to_string(),
shader_id: "colorbars".to_string(),
effect_input: core.effect_input.clone(),
params,
iterative_input: String::new(),
});
super::generatorwithmerge::GeneratorWithMerge::push_mergable_job(inputs, job, table);
}
/// Shader code request: `"colorbars"` returns this node's shader; the
/// `"mrg"` request returns the shared alpha-over merge shader;
/// anything else is unsupported.
fn shader_code(&self, request: &str) -> Option<String> {
match request {
"colorbars" => Some(Self::shader_frag().to_string()),
"mrg" => Some(super::generatorwithmerge::merge_shader_frag().to_string()),
_ => None,
}
}
/// Deep copy.
fn duplicate(&self, _core: &NodeCore) -> Option<Box<dyn NodeBehavior>> {
Some(Box::new(ColorBarsNode))
}
}
/// Constructor: adds `base_in` (not-keyframable) and `standard_in` with
/// the defaults documented on the constants, sets the video-effect flag
/// and makes `base_in` the effect input (the `GeneratorWithMerge`
/// constructor side effects).
pub fn create() -> (NodeCore, Box<dyn NodeBehavior>) {
let mut core = NodeCore::new();
let mut base = crate::input::Input::new(
BASE_INPUT,
crate::value::ValueType::Texture,
crate::value::NodeValue::None,
);
base.flags |= crate::input::flags::NOT_KEYFRAMABLE;
core.add_input(base);
core.add_input(crate::input::Input::new(
STANDARD_INPUT,
crate::value::ValueType::Combo,
crate::value::NodeValue::Combo(0),
));
core.flags |= crate::node::flags::VIDEO_EFFECT;
core.effect_input = BASE_INPUT.to_string();
(core, Box::new(ColorBarsNode))
}
#[cfg(test)]
mod tests {
use super::*;
use crate::node::NodeBehavior;
use crate::value::{NodeValue, NodeValueRow, NodeValueTable, ValueType};
use oak_core::Rational;
#[test]
fn input_names_and_combo_strings() {
let n = ColorBarsNode;
assert_eq!(n.input_name(STANDARD_INPUT), "Standard");
assert_eq!(
n.input_name(super::super::generatorwithmerge::BASE_INPUT),
"Base"
);
assert_eq!(n.input_combo_strings(STANDARD_INPUT), vec!["SMPTE 75%", "Full 100%"]);
assert!(n.input_combo_strings("other_in").is_empty());
}
#[test]
fn create_wires_inputs_and_flags() {
let (core, behavior) = create();
assert_eq!(behavior.type_id(), "org.olivevideoeditor.Olive.colorbars");
assert_eq!(
core.get_input(STANDARD_INPUT).unwrap().default,
NodeValue::Combo(0)
);
assert_eq!(behavior.input_combo_strings(STANDARD_INPUT).len(), 2);
assert_eq!(core.effect_input, BASE_INPUT);
assert_ne!(core.flags & crate::node::flags::VIDEO_EFFECT, 0);
}
#[test]
fn value_pushes_generator_job() {
let (core, behavior) = create();
let mut table = NodeValueTable::default();
behavior.value(
&core,
&NodeValueRow::default(),
Rational::new(0, 1),
&mut table,
);
let handle = match table.get(ValueType::Texture) {
Some(NodeValue::Texture(h)) => *h,
_ => panic!("texture expected"),
};
let payload = unsafe { crate::handle::get_checked::<ShaderJobPayload>(&handle) }
.expect("shader job payload expected");
assert_eq!(payload.type_id, "org.olivevideoeditor.Olive.colorbars");
assert_eq!(payload.shader_id, "colorbars");
assert_eq!(payload.iterations, 1);
assert_eq!(payload.effect_input, BASE_INPUT);
assert_eq!(payload.iterative_input, "");
assert_eq!(
payload.params.get(STANDARD_INPUT),
Some(&NodeValue::Combo(0))
);
}
#[test]
fn value_row_standard_wins_over_the_node_default() {
let (core, behavior) = create();
let inputs = NodeValueRow::from([(STANDARD_INPUT.to_string(), NodeValue::Combo(1))]);
let mut table = NodeValueTable::default();
behavior.value(&core, &inputs, Rational::new(0, 1), &mut table);
let handle = match table.get(ValueType::Texture) {
Some(NodeValue::Texture(h)) => *h,
_ => panic!("texture expected"),
};
let payload = unsafe { crate::handle::get_checked::<ShaderJobPayload>(&handle) }
.expect("shader job payload expected");
assert_eq!(
payload.params.get(STANDARD_INPUT),
Some(&NodeValue::Combo(1))
);
}
#[test]
fn value_with_base_merges_nested_job() {
let (core, behavior) = create();
let inputs = NodeValueRow::from([(
BASE_INPUT.to_string(),
NodeValue::Texture(crate::handle::CHandle::null()),
)]);
let mut table = NodeValueTable::default();
behavior.value(&core, &inputs, Rational::new(0, 1), &mut table);
let handle = match table.get(ValueType::Texture) {
Some(NodeValue::Texture(h)) => *h,
_ => panic!("texture expected"),
};
let merge = unsafe { crate::handle::get_checked::<ShaderJobPayload>(&handle) }
.expect("merge job payload expected");
assert_eq!(merge.shader_id, "mrg");
assert_eq!(merge.effect_input, BASE_INPUT);
match merge.params.get(crate::nodes::merge::BLEND_INPUT) {
Some(NodeValue::Texture(blend)) => {
let nested = unsafe { crate::handle::get_checked::<ShaderJobPayload>(blend) }
.expect("nested job payload boxed");
assert_eq!(nested.shader_id, "colorbars");
}
_ => panic!("nested blend job expected"),
}
}
#[test]
fn shader_code_dispatches() {
let n = ColorBarsNode;
let code = n.shader_code("colorbars").unwrap();
assert!(code.contains("uniform int standard_in;"));
assert!(code.contains("uniform vec2 resolution_in;"));
assert!(code.contains("float level = 0.75;"));
assert!(!code.contains("switch"));
assert!(n
.shader_code("mrg")
.unwrap()
.contains("base_col *= 1.0 - blend_col.a;"));
assert!(n.shader_code("other").is_none());
}
#[test]
fn duplicate_clones() {
let (core, behavior) = create();
let dup = behavior.duplicate(&core).unwrap();
assert_eq!(dup.name(), "Color Bars");
}
}
/// Register this node type.
pub fn register(meta: &mut Vec<NodeMeta>) {
meta.push(NodeMeta {
type_id: "org.olivevideoeditor.Olive.colorbars",
name: "Color Bars",
categories: &[Category::Generator],
create,
});
}
crates/oak-node/src/nodes/colorcorrect.rs
+455
View File
@@ -0,0 +1,455 @@
// Oak Video Editor - Non-Linear Video Editor
// Copyright (C) 2026 Oak Team
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//! Color Correct effect — a clean-room reimplementation of the
//! OpenFX-Misc `ColorCorrect` plugin's parameter semantics (upstream
//! `github.com/cgvirus/OpenFX-Misc`, GPL2; read for behavior only, no
//! upstream code copied).
//!
//! The reference ships five color controls (saturation, contrast,
//! gamma, gain, offset) per tone group (master/shadows/midtones/
//! highlights) plus per-component enable booleans; this node keeps the
//! master group's global controls only — one float per control, applied
//! to all three color channels. Alpha is never touched (the reference
//! leaves `processA` off by default).
//!
//! Formula, applied per pixel in this order (per color channel `x`):
//!
//! ```text
//! luma = 0.2126*r + 0.7152*g + 0.0722*b (Rec. 709)
//! x = (1 - saturation) * luma + saturation * x
//! x = (x > 0) ? pow(x / 0.18, contrast) * 0.18 : x
//! x = (x > 0) ? pow(x, 1 / gamma) : x
//! x = x * gain + offset
//! ```
//!
//! with `contrast` applied only when it differs from `1.0` and `gamma`
//! only when it differs from `1.0`. Contrast pivots on the 0.18 mid
//! gray of the reference (a photographic gray card in sRGB), and the
//! gamma is the reciprocal exponent of the reference's gamma pass.
use crate::factory::NodeMeta;
use crate::jobs::ShaderJobPayload;
use crate::node::{Category, NodeBehavior, NodeCore};
/// Texture input id. Type: texture; flags: not-keyframable; this is
/// the node's effect input.
pub const TEXTURE_INPUT: &str = "tex_in";
/// Saturation input id. Type: float; default `1.0`; properties:
/// `min = 0.0`, `max = 4.0`. Lerps every channel toward the pixel's
/// Rec. 709 luma (`0.0` = fully desaturated, `1.0` = unchanged).
pub const SATURATION_INPUT: &str = "saturation_in";
/// Contrast input id. Type: float; default `1.0`; properties:
/// `min = 0.0`, `max = 4.0`. Power curve around the 0.18 mid gray.
pub const CONTRAST_INPUT: &str = "contrast_in";
/// Gamma input id. Type: float; default `1.0`; properties:
/// `min = 0.2`, `max = 5.0`. Reciprocal exponent (`pow(x, 1/gamma)`).
pub const GAMMA_INPUT: &str = "gamma_in";
/// Gain input id. Type: float; default `1.0`; properties:
/// `min = 0.0`, `max = 4.0`. Multiplies the color channels.
pub const GAIN_INPUT: &str = "gain_in";
/// Offset input id. Type: float; default `0.0`; properties:
/// `min = -1.0`, `max = 1.0`. Added to the color channels after gain.
pub const OFFSET_INPUT: &str = "offset_in";
/// Color correct node. The reference class holds no state beyond its
/// parameter pointers, so this is a unit-like struct.
pub struct ColorCorrectNode;
/// Fragment shader (clean-room GLSL for the reference's
/// `ColorCorrecter::process` chain). The uniforms are named after the
/// node inputs: the renderer binds uniforms by matching the declared
/// name against the job's parameter row.
const SHADER_FRAG: &str = r#"// Inputs
uniform sampler2D tex_in;
uniform float saturation_in;
uniform float contrast_in;
uniform float gamma_in;
uniform float gain_in;
uniform float offset_in;
// Input texture coordinate
in vec2 ove_texcoord;
out vec4 frag_color;
void main() {
vec4 c = texture(tex_in, ove_texcoord);
// Saturation: lerp each channel toward the pixel's Rec. 709 luma.
float luma = dot(c.rgb, vec3(0.2126, 0.7152, 0.0722));
c.rgb = (1.0 - saturation_in) * luma + saturation_in * c.rgb;
// Contrast: power curve pivoting on 0.18 mid gray. Non-positive
// values pass through unchanged (a negative base has no real power).
if (contrast_in != 1.0) {
if (c.r > 0.0) {
c.r = pow(c.r / 0.18, contrast_in) * 0.18;
}
if (c.g > 0.0) {
c.g = pow(c.g / 0.18, contrast_in) * 0.18;
}
if (c.b > 0.0) {
c.b = pow(c.b / 0.18, contrast_in) * 0.18;
}
}
// Gamma: reciprocal exponent, positive values only. A non-positive
// gamma would divide by zero, so it is clamped to a tiny minimum.
if (gamma_in != 1.0) {
float g = max(gamma_in, 1.0e-8);
if (c.r > 0.0) {
c.r = pow(c.r, 1.0 / g);
}
if (c.g > 0.0) {
c.g = pow(c.g, 1.0 / g);
}
if (c.b > 0.0) {
c.b = pow(c.b, 1.0 / g);
}
}
// Gain, then offset.
c.rgb = c.rgb * gain_in + offset_in;
frag_color = c;
}
"#;
impl NodeBehavior for ColorCorrectNode {
/// Human-readable name.
fn name(&self) -> &str {
"Color Correct"
}
/// Stable type id.
fn type_id(&self) -> &str {
"org.olivevideoeditor.Olive.colorcorrect"
}
/// Categories.
fn categories(&self) -> &[Category] {
&[Category::Color]
}
/// Description.
fn description(&self) -> &str {
"Adjust color using saturation, contrast, gamma, gain, and offset."
}
/// Localized input names: `tex_in` -> "Input", `saturation_in` ->
/// "Saturation", `contrast_in` -> "Contrast", `gamma_in` ->
/// "Gamma", `gain_in` -> "Gain", `offset_in` -> "Offset".
fn input_name<'a>(&self, id: &'a str) -> &'a str {
match id {
TEXTURE_INPUT => "Input",
SATURATION_INPUT => "Saturation",
CONTRAST_INPUT => "Contrast",
GAMMA_INPUT => "Gamma",
GAIN_INPUT => "Gain",
OFFSET_INPUT => "Offset",
_ => id,
}
}
/// Evaluate outputs: no texture on `tex_in` -> push nothing;
/// texture present -> push a shader job over the input row with
/// every control resolved (so the renderer always finds a value for
/// each uniform, whether the row carried the input or the node's
/// own default/keyframe supplied it).
fn value(
&self,
core: &NodeCore,
inputs: &crate::value::NodeValueRow,
time: oak_core::Rational,
table: &mut crate::value::NodeValueTable,
) {
if !matches!(
inputs.get(TEXTURE_INPUT),
Some(crate::value::NodeValue::Texture(_))
) {
return;
}
let resolve = |id: &str| match inputs.get(id) {
Some(v) => v.clone(),
None => core.value_at_time(id, -1, time),
};
let mut params = inputs.clone();
for id in [
SATURATION_INPUT,
CONTRAST_INPUT,
GAMMA_INPUT,
GAIN_INPUT,
OFFSET_INPUT,
] {
params.insert(id.to_string(), resolve(id));
}
table.push(
crate::value::ValueType::Texture,
crate::value::NodeValue::Texture(crate::handle::make_owned(ShaderJobPayload {
node_id: crate::id::NodeId::INVALID,
time,
iterations: 1,
type_id: self.type_id().to_string(),
shader_id: String::new(),
effect_input: core.effect_input.clone(),
params,
iterative_input: String::new(),
})),
None,
);
}
/// Shader code request: the request id is ignored; always returns
/// [`SHADER_FRAG`].
fn shader_code(&self, _request: &str) -> Option<String> {
Some(SHADER_FRAG.to_string())
}
/// Deep copy.
fn duplicate(&self, _core: &NodeCore) -> Option<Box<dyn NodeBehavior>> {
Some(Box::new(ColorCorrectNode))
}
}
/// Constructor: adds `tex_in` (texture, effect input) and the five
/// controls with the defaults and ranges documented on the constants,
/// and sets the video-effect flag.
pub fn create() -> (NodeCore, Box<dyn NodeBehavior>) {
let mut core = NodeCore::new();
let mut tex = crate::input::Input::new(
TEXTURE_INPUT,
crate::value::ValueType::Texture,
crate::value::NodeValue::None,
);
tex.flags |= crate::input::flags::NOT_KEYFRAMABLE;
core.add_input(tex);
add_float_input(&mut core, SATURATION_INPUT, 1.0, 0.0, 4.0);
add_float_input(&mut core, CONTRAST_INPUT, 1.0, 0.0, 4.0);
add_float_input(&mut core, GAMMA_INPUT, 1.0, 0.2, 5.0);
add_float_input(&mut core, GAIN_INPUT, 1.0, 0.0, 4.0);
add_float_input(&mut core, OFFSET_INPUT, 0.0, -1.0, 1.0);
core.flags |= crate::node::flags::VIDEO_EFFECT;
core.effect_input = TEXTURE_INPUT.to_string();
(core, Box::new(ColorCorrectNode))
}
/// Add a float input with its default and `min`/`max`/`view`
/// properties.
fn add_float_input(core: &mut NodeCore, id: &str, default: f64, min: f64, max: f64) {
let mut input = crate::input::Input::new(
id,
crate::value::ValueType::Float,
crate::value::NodeValue::Float(default),
);
input.properties = vec![
("min".to_string(), crate::value::NodeValue::Float(min)),
("max".to_string(), crate::value::NodeValue::Float(max)),
(
"view".to_string(),
crate::value::NodeValue::Text("normal".into()),
),
];
core.add_input(input);
}
/// Register this node type.
pub fn register(meta: &mut Vec<NodeMeta>) {
meta.push(NodeMeta {
type_id: "org.olivevideoeditor.Olive.colorcorrect",
name: "Color Correct",
categories: &[Category::Color],
create,
});
}
#[cfg(test)]
mod tests {
use super::*;
use crate::value::{NodeValue, NodeValueTable, ValueType};
use oak_core::Rational;
#[test]
fn input_names() {
let n = ColorCorrectNode;
assert_eq!(n.input_name(TEXTURE_INPUT), "Input");
assert_eq!(n.input_name(SATURATION_INPUT), "Saturation");
assert_eq!(n.input_name(CONTRAST_INPUT), "Contrast");
assert_eq!(n.input_name(GAMMA_INPUT), "Gamma");
assert_eq!(n.input_name(GAIN_INPUT), "Gain");
assert_eq!(n.input_name(OFFSET_INPUT), "Offset");
assert_eq!(n.input_name("other_in"), "other_in");
}
#[test]
fn create_wires_inputs_and_flags() {
let (core, behavior) = create();
assert_eq!(
behavior.type_id(),
"org.olivevideoeditor.Olive.colorcorrect"
);
assert_eq!(behavior.name(), "Color Correct");
assert_eq!(behavior.categories(), &[Category::Color]);
let tex = core.get_input(TEXTURE_INPUT).unwrap();
assert_ne!(tex.flags & crate::input::flags::NOT_KEYFRAMABLE, 0);
assert_eq!(
core.get_input(SATURATION_INPUT).unwrap().default,
NodeValue::Float(1.0)
);
assert_eq!(
core.get_input(CONTRAST_INPUT).unwrap().default,
NodeValue::Float(1.0)
);
assert_eq!(
core.get_input(GAMMA_INPUT).unwrap().default,
NodeValue::Float(1.0)
);
assert_eq!(
core.get_input(GAIN_INPUT).unwrap().default,
NodeValue::Float(1.0)
);
assert_eq!(
core.get_input(OFFSET_INPUT).unwrap().default,
NodeValue::Float(0.0)
);
assert_eq!(core.effect_input, TEXTURE_INPUT);
assert_ne!(core.flags & crate::node::flags::VIDEO_EFFECT, 0);
}
#[test]
fn create_sets_control_ranges() {
let (core, _) = create();
let gamma = core.get_input(GAMMA_INPUT).unwrap();
assert_eq!(gamma.properties[0].1, NodeValue::Float(0.2));
assert_eq!(gamma.properties[1].1, NodeValue::Float(5.0));
let offset = core.get_input(OFFSET_INPUT).unwrap();
assert_eq!(offset.properties[0].1, NodeValue::Float(-1.0));
assert_eq!(offset.properties[1].1, NodeValue::Float(1.0));
}
#[test]
fn value_no_texture_pushes_nothing() {
let (core, behavior) = create();
let mut table = NodeValueTable::default();
behavior.value(
&core,
&crate::value::NodeValueRow::default(),
Rational::new(0, 1),
&mut table,
);
assert!(table.is_empty());
}
#[test]
fn value_with_texture_pushes_shader_job_with_resolved_params() {
let (core, behavior) = create();
let inputs = crate::value::NodeValueRow::from([(
TEXTURE_INPUT.to_string(),
NodeValue::Texture(crate::handle::CHandle::null()),
)]);
let mut table = NodeValueTable::default();
behavior.value(&core, &inputs, Rational::new(0, 1), &mut table);
let Some(NodeValue::Texture(handle)) = table.get(ValueType::Texture) else {
panic!("expected a texture-typed value");
};
let payload =
unsafe { crate::handle::get_checked::<crate::jobs::ShaderJobPayload>(handle) }
.expect("shader job pushed");
assert_eq!(payload.type_id, "org.olivevideoeditor.Olive.colorcorrect");
assert_eq!(payload.shader_id, "");
assert_eq!(payload.iterations, 1);
assert_eq!(payload.effect_input, TEXTURE_INPUT);
// Every control is resolved into the row, so the renderer finds
// a value for each uniform even when the row omitted the input.
assert_eq!(
payload.params.get(SATURATION_INPUT),
Some(&NodeValue::Float(1.0))
);
assert_eq!(
payload.params.get(CONTRAST_INPUT),
Some(&NodeValue::Float(1.0))
);
assert_eq!(payload.params.get(GAMMA_INPUT), Some(&NodeValue::Float(1.0)));
assert_eq!(payload.params.get(GAIN_INPUT), Some(&NodeValue::Float(1.0)));
assert_eq!(
payload.params.get(OFFSET_INPUT),
Some(&NodeValue::Float(0.0))
);
}
#[test]
fn value_row_values_win_over_defaults() {
let (mut core, behavior) = create();
core.set_standard_value(CONTRAST_INPUT, -1, NodeValue::Float(1.5));
let inputs = crate::value::NodeValueRow::from([
(
TEXTURE_INPUT.to_string(),
NodeValue::Texture(crate::handle::CHandle::null()),
),
(CONTRAST_INPUT.to_string(), NodeValue::Float(2.0)),
]);
let mut table = NodeValueTable::default();
behavior.value(&core, &inputs, Rational::new(0, 1), &mut table);
let Some(NodeValue::Texture(handle)) = table.get(ValueType::Texture) else {
panic!("expected a texture-typed value");
};
let payload =
unsafe { crate::handle::get_checked::<crate::jobs::ShaderJobPayload>(handle) }
.expect("shader job pushed");
assert_eq!(
payload.params.get(CONTRAST_INPUT),
Some(&NodeValue::Float(2.0))
);
}
#[test]
fn shader_declares_uniforms_and_avoids_switch() {
let code = ColorCorrectNode.shader_code("").unwrap();
for uniform in [
"tex_in",
SATURATION_INPUT,
CONTRAST_INPUT,
GAMMA_INPUT,
GAIN_INPUT,
OFFSET_INPUT,
] {
assert!(code.contains(uniform), "uniform {uniform} declared");
}
assert!(code.contains("ove_texcoord"));
assert!(code.contains("frag_color"));
assert!(!code.contains("switch"), "naga rejects GLSL switch");
}
#[test]
fn duplicate_clones() {
let (core, behavior) = create();
let dup = behavior.duplicate(&core).unwrap();
assert_eq!(dup.name(), "Color Correct");
assert_eq!(dup.type_id(), "org.olivevideoeditor.Olive.colorcorrect");
}
}
crates/oak-node/src/nodes/colormatrix.rs
+341
View File
@@ -0,0 +1,341 @@
// Oak Video Editor - Non-Linear Video Editor
// Copyright (C) 2026 Oak Team
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//! Color matrix filter (clean-room reimplementation of OpenFX
//! `net.sf.openfx.ColorMatrixPlugin`; `ofx-misc` used for parameter
//! semantics only, no code copied).
use crate::factory::NodeMeta;
use crate::jobs::ShaderJobPayload;
use crate::node::{Category, NodeBehavior, NodeCore};
/// Texture input id. Type: texture; flags: not-keyframable; this is the
/// node's effect input.
pub const TEXTURE_INPUT: &str = "tex_in";
/// The sixteen matrix input ids (C++ OFX exposes one matrix parameter;
/// Olive has no matrix input widget, so the 4x4 matrix arrives as
/// sixteen scalar inputs). Row-major: `m0..m3` are the weights feeding
/// the output red channel from the input R, G, B, A; `m4..m7` the green
/// channel; `m8..m11` blue; `m12..m15` alpha. Typed as pairs of indices
/// by [`MATRIX_LABELS`].
pub const MATRIX_INPUTS: [&str; 16] = [
"m0", "m1", "m2", "m3", "m4", "m5", "m6", "m7", "m8", "m9", "m10", "m11", "m12", "m13",
"m14", "m15",
];
/// Human-readable label per [`MATRIX_INPUTS`] entry: the output channel
/// before the arrow, the input channel after it. The diagonal (m0, m5,
/// m10, m15) is `1.0`, every other element `0.0` — the identity matrix.
pub const MATRIX_LABELS: [&str; 16] = [
"R <- R", "R <- G", "R <- B", "R <- A", "G <- R", "G <- G", "G <- B", "G <- A", "B <- R",
"B <- G", "B <- B", "B <- A", "A <- R", "A <- G", "A <- B", "A <- A",
];
/// Matrix uniform name. Not a node input: the `value()` hook inserts the
/// packed matrix into the job params row under this key (the
/// `transform_in` precedent in `transformdistortnode.rs`). `resolution_in`
/// is unused — the filter is coordinate-independent.
pub const MATRIX_UNIFORM: &str = "matrix_in";
/// Color matrix filter node. Multiplies the RGBA vector by a 4x4 matrix.
pub struct ColorMatrixNode;
/// Fragment shader: `NodeValue::Matrix` is row-major and the runner
/// transposes it into GLSL's column-major layout, so `matrix_in * color`
/// is the row-major matrix times the column vector — output channel `c`
/// is `sum_j m[c * 4 + j] * color[j]`.
const SHADER_FRAG: &str = r#"uniform sampler2D tex_in;
uniform mat4 matrix_in;
in vec2 ove_texcoord;
out vec4 frag_color;
void main() {
frag_color = matrix_in * texture(tex_in, ove_texcoord);
}
"#;
impl ColorMatrixNode {
/// Fragment shader for any request (this node has a single variant).
fn shader_frag() -> &'static str {
SHADER_FRAG
}
}
impl NodeBehavior for ColorMatrixNode {
/// Human-readable name.
fn name(&self) -> &str {
"Color Matrix"
}
/// Stable type id.
fn type_id(&self) -> &str {
"org.olivevideoeditor.Olive.colormatrix"
}
/// Categories.
fn categories(&self) -> &[Category] {
&[Category::Color]
}
/// Description.
fn description(&self) -> &str {
"Multiply a video's RGBA channels by a 4x4 matrix."
}
/// Localized input names: `tex_in` -> "Input", `mN` ->
/// "OUT <- IN" (see [`MATRIX_LABELS`]).
fn input_name<'a>(&self, id: &'a str) -> &'a str {
if id == TEXTURE_INPUT {
return "Input";
}
MATRIX_INPUTS
.iter()
.position(|m| *m == id)
.map(|i| MATRIX_LABELS[i])
.unwrap_or(id)
}
/// Evaluate outputs: no texture -> push nothing; otherwise push a
/// shader job carrying the matrix as the `matrix_in` uniform. Unlike
/// the identity cases elsewhere there is no pass-through shortcut:
/// the identity matrix is what the shader computes anyway, and a
/// shortcut would skip the (tested) GPU pass.
fn value(
&self,
core: &NodeCore,
inputs: &crate::value::NodeValueRow,
time: oak_core::Rational,
table: &mut crate::value::NodeValueTable,
) {
use crate::value::{NodeValue, ValueType};
match inputs.get(TEXTURE_INPUT) {
Some(NodeValue::Texture(_)) => {}
_ => return,
}
let mut matrix = [0.0f64; 16];
for (i, id) in MATRIX_INPUTS.iter().enumerate() {
matrix[i] = match inputs.get(*id) {
Some(v) => v.to_double(),
None => core.value_at_time(id, -1, time).to_double(),
};
}
let mut params = inputs.clone();
params.insert(MATRIX_UNIFORM.to_string(), NodeValue::Matrix(matrix));
table.push(
ValueType::Texture,
NodeValue::Texture(crate::handle::make_owned(ShaderJobPayload {
node_id: crate::id::NodeId::INVALID,
time,
iterations: 1,
type_id: self.type_id().to_string(),
shader_id: String::new(),
effect_input: core.effect_input.clone(),
params,
iterative_input: String::new(),
})),
None,
);
}
/// Shader code request: always the one fragment source.
fn shader_code(&self, _request: &str) -> Option<String> {
Some(Self::shader_frag().to_string())
}
/// Deep copy.
fn duplicate(&self, _core: &NodeCore) -> Option<Box<dyn NodeBehavior>> {
Some(Box::new(ColorMatrixNode))
}
}
/// Constructor: adds `tex_in` plus the sixteen matrix inputs (identity
/// defaults), sets the video-effect flag and the effect input.
pub fn create() -> (NodeCore, Box<dyn NodeBehavior>) {
let mut core = NodeCore::new();
let mut tex = crate::input::Input::new(
TEXTURE_INPUT,
crate::value::ValueType::Texture,
crate::value::NodeValue::None,
);
tex.flags |= crate::input::flags::NOT_KEYFRAMABLE;
core.add_input(tex);
for (i, id) in MATRIX_INPUTS.iter().enumerate() {
// The identity diagonal: m0, m5, m10, m15.
let default = if i % 5 == 0 { 1.0 } else { 0.0 };
let mut input = crate::input::Input::new(
id,
crate::value::ValueType::Float,
crate::value::NodeValue::Float(default),
);
input.flags |= crate::input::flags::NOT_KEYFRAMABLE;
core.add_input(input);
}
core.flags |= crate::node::flags::VIDEO_EFFECT;
core.effect_input = TEXTURE_INPUT.to_string();
(core, Box::new(ColorMatrixNode))
}
#[cfg(test)]
mod tests {
use super::*;
use crate::value::{NodeValue, NodeValueTable, ValueType};
use oak_core::Rational;
fn tex() -> NodeValue {
NodeValue::Texture(crate::handle::CHandle::null())
}
#[test]
fn input_names() {
let n = ColorMatrixNode;
assert_eq!(n.input_name(TEXTURE_INPUT), "Input");
assert_eq!(n.input_name("m0"), "R <- R");
assert_eq!(n.input_name("m15"), "A <- A");
assert_eq!(n.input_name("other"), "other");
}
#[test]
fn create_wires_inputs_and_flags() {
let (core, behavior) = create();
assert_eq!(behavior.type_id(), "org.olivevideoeditor.Olive.colormatrix");
assert_eq!(behavior.categories(), &[Category::Color]);
assert_eq!(core.effect_input, TEXTURE_INPUT);
assert_ne!(core.flags & crate::node::flags::VIDEO_EFFECT, 0);
assert_eq!(core.get_input(TEXTURE_INPUT).unwrap().value_type, ValueType::Texture);
for (i, id) in MATRIX_INPUTS.iter().enumerate() {
let input = core.get_input(id).expect("matrix input registered");
assert_eq!(input.value_type, ValueType::Float);
let expected = if i % 5 == 0 { 1.0 } else { 0.0 };
assert_eq!(input.default, NodeValue::Float(expected), "{id} default");
}
}
#[test]
fn value_no_texture_pushes_nothing() {
let (core, behavior) = create();
let mut table = NodeValueTable::default();
behavior.value(
&core,
&crate::value::NodeValueRow::default(),
Rational::new(0, 1),
&mut table,
);
assert!(table.is_empty());
}
#[test]
fn value_pushes_identity_matrix_by_default() {
let (core, behavior) = create();
let inputs = crate::value::NodeValueRow::from([(TEXTURE_INPUT.to_string(), tex())]);
let mut table = NodeValueTable::default();
behavior.value(&core, &inputs, Rational::new(0, 1), &mut table);
let Some(NodeValue::Texture(h)) = table.get(ValueType::Texture) else {
panic!("shader job expected");
};
let payload = unsafe { crate::handle::get_checked::<ShaderJobPayload>(h) }
.expect("shader job payload boxed");
let mut identity = [0.0f64; 16];
for i in 0..4 {
identity[i * 5] = 1.0;
}
assert_eq!(
payload.params.get(MATRIX_UNIFORM),
Some(&NodeValue::Matrix(identity))
);
assert_eq!(payload.type_id, "org.olivevideoeditor.Olive.colormatrix");
assert_eq!(payload.shader_id, "");
assert_eq!(payload.effect_input, TEXTURE_INPUT);
assert_eq!(payload.iterations, 1);
assert!(payload.params.contains_key(TEXTURE_INPUT));
}
#[test]
fn value_packs_row_major_matrix_from_row() {
let (core, behavior) = create();
// Red -> green, green -> red, blue and alpha held.
let swap = [0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0,
1.0];
let mut inputs = crate::value::NodeValueRow::from([(TEXTURE_INPUT.to_string(), tex())]);
for (i, id) in MATRIX_INPUTS.iter().enumerate() {
inputs.insert(id.to_string(), NodeValue::Float(swap[i]));
}
let mut table = NodeValueTable::default();
behavior.value(&core, &inputs, Rational::new(0, 1), &mut table);
let Some(NodeValue::Texture(h)) = table.get(ValueType::Texture) else {
panic!("shader job expected");
};
let payload = unsafe { crate::handle::get_checked::<ShaderJobPayload>(h) }
.expect("shader job payload boxed");
assert_eq!(
payload.params.get(MATRIX_UNIFORM),
Some(&NodeValue::Matrix(swap))
);
}
#[test]
fn value_reads_matrix_from_core_when_absent_from_row() {
let (mut core, behavior) = create();
core.set_standard_value("m1", -1, NodeValue::Float(0.25));
let inputs = crate::value::NodeValueRow::from([(TEXTURE_INPUT.to_string(), tex())]);
let mut table = NodeValueTable::default();
behavior.value(&core, &inputs, Rational::new(0, 1), &mut table);
let Some(NodeValue::Texture(h)) = table.get(ValueType::Texture) else {
panic!("shader job expected");
};
let payload = unsafe { crate::handle::get_checked::<ShaderJobPayload>(h) }
.expect("shader job payload boxed");
let Some(NodeValue::Matrix(m)) = payload.params.get(MATRIX_UNIFORM) else {
panic!("matrix uniform expected");
};
assert_eq!(m[1], 0.25);
assert_eq!(m[0], 1.0);
}
#[test]
fn shader_code_declares_matrix_uniform() {
let n = ColorMatrixNode;
let glsl = n.shader_code("").unwrap();
assert!(glsl.contains("uniform mat4 matrix_in;"));
assert!(glsl.contains("frag_color = matrix_in * texture(tex_in, ove_texcoord);"));
}
#[test]
fn duplicate_clones_behavior() {
let (core, behavior) = create();
let dup = behavior.duplicate(&core).unwrap();
assert_eq!(dup.name(), "Color Matrix");
}
}
/// Register this node type.
pub fn register(meta: &mut Vec<NodeMeta>) {
meta.push(NodeMeta {
type_id: "org.olivevideoeditor.Olive.colormatrix",
name: "Color Matrix",
categories: &[Category::Color],
create,
});
}
crates/oak-node/src/nodes/dilate.rs
+330
View File
@@ -0,0 +1,330 @@
// Oak Video Editor - Non-Linear Video Editor
// Copyright (C) 2026 Oak Team
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//! Dilate filter (clean-room reimplementation of the CImg `Dilate`/
//! `net.sf.cimg.CImgDilate` effect; `ofx-misc` used for parameter
//! semantics only, no code copied).
use crate::factory::NodeMeta;
use crate::jobs::ShaderJobPayload;
use crate::node::{Category, NodeBehavior, NodeCore};
/// Texture input id. Type: texture; flags: not-keyframable; this is the
/// node's effect input.
pub const TEXTURE_INPUT: &str = "tex_in";
/// Radius input id. Type: float; default `1.0`; properties: `min = 0.0`,
/// `max = 7.0`. The structuring element is a square of `2 * radius + 1`
/// pixels on a side, in pixels.
pub const RADIUS_INPUT: &str = "radius_in";
/// Largest supported radius. The shader clamps to this; the neighborhood
/// is `15 x 15` pixels, sampled in a single pass (see [`SHADER_FRAG`]).
pub const MAX_RADIUS: f64 = 7.0;
/// Dilate filter node. Morphological maximum over a square neighborhood.
pub struct DilateNode;
/// Fragment shader: one pass sampling the full `(2r+1)^2` neighborhood
/// and taking the per-channel maximum. `iterations` stays 1 — a single
/// wide pass is mathematically identical to `r` 3x3 iterations for a
/// square structuring element (max is associative and idempotent), and
/// avoids the ping-pong feedback textures entirely. `radius_in` is
/// rounded to the nearest integer and clamped to `0..=7`; offsets are
/// pixel-space texel steps (`resolution_in`, texel centers), with
/// edge-of-frame taps clamping to the border pixel.
const SHADER_FRAG: &str = r#"uniform sampler2D tex_in;
uniform float radius_in;
uniform vec2 resolution_in;
in vec2 ove_texcoord;
out vec4 frag_color;
void main() {
int radius = int(clamp(radius_in, 0.0, 7.0) + 0.5);
vec2 texel = vec2(1.0) / resolution_in;
vec4 acc = texture(tex_in, ove_texcoord);
for (int dy = -radius; dy <= radius; ++dy) {
for (int dx = -radius; dx <= radius; ++dx) {
vec2 uv = ove_texcoord + vec2(float(dx), float(dy)) * texel;
acc = max(acc, texture(tex_in, uv));
}
}
frag_color = acc;
}
"#;
impl DilateNode {
/// Fragment shader for any request (this node has a single variant).
fn shader_frag() -> &'static str {
SHADER_FRAG
}
}
impl NodeBehavior for DilateNode {
/// Human-readable name.
fn name(&self) -> &str {
"Dilate"
}
/// Stable type id.
fn type_id(&self) -> &str {
"org.olivevideoeditor.Olive.dilate"
}
/// Categories.
fn categories(&self) -> &[Category] {
&[Category::Filter]
}
/// Description.
fn description(&self) -> &str {
"Expand bright areas by taking the maximum over a square neighborhood."
}
/// Localized input names: `tex_in` -> "Input", `radius_in` ->
/// "Radius".
fn input_name<'a>(&self, id: &'a str) -> &'a str {
match id {
TEXTURE_INPUT => "Input",
RADIUS_INPUT => "Radius",
_ => id,
}
}
/// Evaluate outputs: no texture -> push nothing; radius <= 0 -> push
/// the input texture unchanged (the same no-work shortcut as
/// `blur.rs`'s `can_push_job`); otherwise push the single-pass
/// neighborhood shader job.
fn value(
&self,
core: &NodeCore,
inputs: &crate::value::NodeValueRow,
time: oak_core::Rational,
table: &mut crate::value::NodeValueTable,
) {
use crate::value::{NodeValue, ValueType};
let tex = match inputs.get(TEXTURE_INPUT) {
Some(tex @ NodeValue::Texture(_)) => tex.clone(),
_ => return,
};
let radius = match inputs.get(RADIUS_INPUT) {
Some(v) => v.to_double(),
None => core.value_at_time(RADIUS_INPUT, -1, time).to_double(),
};
if radius <= 0.0 {
table.push(ValueType::Texture, tex, None);
return;
}
let mut params = inputs.clone();
params.insert(RADIUS_INPUT.to_string(), NodeValue::Float(radius));
table.push(
ValueType::Texture,
NodeValue::Texture(crate::handle::make_owned(ShaderJobPayload {
node_id: crate::id::NodeId::INVALID,
time,
iterations: 1,
type_id: self.type_id().to_string(),
shader_id: String::new(),
effect_input: core.effect_input.clone(),
params,
iterative_input: String::new(),
})),
None,
);
}
/// Shader code request: always the one fragment source.
fn shader_code(&self, _request: &str) -> Option<String> {
Some(Self::shader_frag().to_string())
}
/// Deep copy.
fn duplicate(&self, _core: &NodeCore) -> Option<Box<dyn NodeBehavior>> {
Some(Box::new(DilateNode))
}
}
/// Constructor: adds `tex_in` and `radius_in` with the defaults and
/// properties documented on the constants, sets the video-effect flag and
/// the effect input.
pub fn create() -> (NodeCore, Box<dyn NodeBehavior>) {
let mut core = NodeCore::new();
let mut tex = crate::input::Input::new(
TEXTURE_INPUT,
crate::value::ValueType::Texture,
crate::value::NodeValue::None,
);
tex.flags |= crate::input::flags::NOT_KEYFRAMABLE;
core.add_input(tex);
let mut radius = crate::input::Input::new(
RADIUS_INPUT,
crate::value::ValueType::Float,
crate::value::NodeValue::Float(1.0),
);
radius.properties = vec![
("min".to_string(), crate::value::NodeValue::Float(0.0)),
("max".to_string(), crate::value::NodeValue::Float(MAX_RADIUS)),
];
core.add_input(radius);
core.flags |= crate::node::flags::VIDEO_EFFECT;
core.effect_input = TEXTURE_INPUT.to_string();
(core, Box::new(DilateNode))
}
#[cfg(test)]
mod tests {
use super::*;
use crate::value::{NodeValue, NodeValueTable, ValueType};
use oak_core::Rational;
fn tex() -> NodeValue {
NodeValue::Texture(crate::handle::CHandle::null())
}
#[test]
fn input_names() {
let n = DilateNode;
assert_eq!(n.input_name(TEXTURE_INPUT), "Input");
assert_eq!(n.input_name(RADIUS_INPUT), "Radius");
assert_eq!(n.input_name("other"), "other");
}
#[test]
fn create_wires_inputs_and_flags() {
let (core, behavior) = create();
assert_eq!(behavior.type_id(), "org.olivevideoeditor.Olive.dilate");
assert_eq!(behavior.categories(), &[Category::Filter]);
assert_eq!(core.effect_input, TEXTURE_INPUT);
assert_ne!(core.flags & crate::node::flags::VIDEO_EFFECT, 0);
let radius = core.get_input(RADIUS_INPUT).expect("radius input");
assert_eq!(radius.default, NodeValue::Float(1.0));
assert!(radius
.properties
.iter()
.any(|(k, v)| k == "min" && *v == NodeValue::Float(0.0)));
assert!(radius
.properties
.iter()
.any(|(k, v)| k == "max" && *v == NodeValue::Float(MAX_RADIUS)));
}
#[test]
fn value_no_texture_pushes_nothing() {
let (core, behavior) = create();
let mut table = NodeValueTable::default();
behavior.value(
&core,
&crate::value::NodeValueRow::default(),
Rational::new(0, 1),
&mut table,
);
assert!(table.is_empty());
}
#[test]
fn value_zero_radius_passes_through() {
let (core, behavior) = create();
let tex = tex();
let inputs = crate::value::NodeValueRow::from([
(TEXTURE_INPUT.to_string(), tex.clone()),
(RADIUS_INPUT.to_string(), NodeValue::Float(0.0)),
]);
let mut table = NodeValueTable::default();
behavior.value(&core, &inputs, Rational::new(0, 1), &mut table);
assert_eq!(table.get(ValueType::Texture), Some(&tex));
}
#[test]
fn value_pushes_single_pass_job() {
let (core, behavior) = create();
let inputs = crate::value::NodeValueRow::from([
(TEXTURE_INPUT.to_string(), tex()),
(RADIUS_INPUT.to_string(), NodeValue::Float(2.0)),
]);
let mut table = NodeValueTable::default();
behavior.value(&core, &inputs, Rational::new(0, 1), &mut table);
let Some(NodeValue::Texture(h)) = table.get(ValueType::Texture) else {
panic!("shader job expected");
};
let payload = unsafe { crate::handle::get_checked::<ShaderJobPayload>(h) }
.expect("shader job payload boxed");
assert_eq!(payload.type_id, "org.olivevideoeditor.Olive.dilate");
assert_eq!(payload.shader_id, "");
assert_eq!(payload.effect_input, TEXTURE_INPUT);
assert_eq!(payload.iterations, 1);
assert_eq!(payload.iterative_input, "");
assert_eq!(
payload.params.get(RADIUS_INPUT),
Some(&NodeValue::Float(2.0))
);
}
#[test]
fn value_default_radius_pushes_job() {
let (core, behavior) = create();
let inputs = crate::value::NodeValueRow::from([(TEXTURE_INPUT.to_string(), tex())]);
let mut table = NodeValueTable::default();
behavior.value(&core, &inputs, Rational::new(0, 1), &mut table);
let Some(NodeValue::Texture(h)) = table.get(ValueType::Texture) else {
panic!("shader job expected");
};
let payload = unsafe { crate::handle::get_checked::<ShaderJobPayload>(h) }
.expect("shader job payload boxed");
assert_eq!(
payload.params.get(RADIUS_INPUT),
Some(&NodeValue::Float(1.0))
);
}
#[test]
fn shader_code_is_single_pass_max_without_switch() {
let n = DilateNode;
let glsl = n.shader_code("").unwrap();
assert!(glsl.contains("uniform vec2 resolution_in;"));
assert!(glsl.contains("acc = max(acc, texture(tex_in, uv));"));
assert!(glsl.contains("int(clamp(radius_in, 0.0, 7.0) + 0.5)"));
assert!(!glsl.contains("switch"));
}
#[test]
fn duplicate_clones_behavior() {
let (core, behavior) = create();
let dup = behavior.duplicate(&core).unwrap();
assert_eq!(dup.name(), "Dilate");
}
}
/// Register this node type.
pub fn register(meta: &mut Vec<NodeMeta>) {
meta.push(NodeMeta {
type_id: "org.olivevideoeditor.Olive.dilate",
name: "Dilate",
categories: &[Category::Filter],
create,
});
}
crates/oak-node/src/nodes/dirblur.rs
+404
View File
@@ -0,0 +1,404 @@
// Oak Video Editor - Non-Linear Video Editor
// Copyright (C) 2026 Oak Team
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//! Directional blur filter (clean-room reimplementation of the
//! OpenFX-Misc `DirBlurOFX` / `net.sf.openfx.DirBlur` effect; `ofx-misc`
//! used for parameter semantics only, no code copied).
//!
//! Upstream blurs by concatenating a per-frame transform, i.e. by
//! resampling the image along the motion direction with an
//! `amount`-pixel smear and a `centered`/`fading` shaping of the tap
//! weights. The same picture is produced here by one fragment pass that
//! averages a fixed number of taps along the direction vector, centered
//! on the pixel (a box-shaped, non-fading smear — the `centered = true`,
//! `fading = 0` case).
use crate::factory::NodeMeta;
use crate::jobs::ShaderJobPayload;
use crate::node::{Category, NodeBehavior, NodeCore};
/// Texture input id. Type: texture; flags: not-keyframable; this is the
/// node's effect input.
pub const TEXTURE_INPUT: &str = "tex_in";
/// Blur radius input id (upstream `dirBlurAmount`, "Amount"). Type:
/// float; default `0.0`; properties: `min = 0.0`. The half-length of
/// the smear in sequence pixels: each tap lies within `amount_in`
/// pixels of the pixel along the direction vector.
pub const AMOUNT_INPUT: &str = "amount_in";
/// Blur direction input id (upstream `dirBlurAngle`/"Angle" on top of
/// the transform concatenation). Type: float; default `0.0`; degrees
/// counter-clockwise from the +x axis in the un-flipped image frame (as
/// in [`crate::nodes::blur`]'s `directional_degrees_in`, y grows down the
/// frame, so a growing angle rotates the smear clockwise on screen).
pub const ANGLE_INPUT: &str = "angle_in";
/// Directional blur node. Averages 16 taps evenly spaced along the
/// direction vector, centered on the pixel.
pub struct DirBlurNode;
/// Number of taps averaged per pixel. Fixed (upstream has no tap-count
/// knob either): a power-of-two constant keeps the division exact and
/// the shader otherwise branch-free.
const TAP_COUNT: i32 = 16;
/// Fragment shader: one direction vector from `angle_in`, then a
/// constant-count loop averaging the taps. The tap spacing collapses to
/// zero when `amount_in` is zero, so a zero amount is an exact
/// identity without a branch. Offsets are pixels (`resolution_in`,
/// auto-filled by the renderer from the effect input's size, or from
/// the sequence square resolution on the real render path — the amount
/// is a sequence-pixel value, matching the blur node's radius); the
/// sampler clamps to the border, so taps past the frame edge repeat the
/// edge pixel. `switch` is deliberately not used (naga rejects it).
const SHADER_FRAG: &str = r#"uniform sampler2D tex_in;
uniform float amount_in;
uniform float angle_in;
uniform vec2 resolution_in;
in vec2 ove_texcoord;
out vec4 frag_color;
// Taps averaged per pixel (keep in sync with TAP_COUNT).
#define TAP_COUNT 16
// M_PI mirrors the blur node's directional-blur shader (degrees ->
// radians without relying on built-in constants).
#define M_PI 3.1415926535897932384626433832795
void main() {
float angle = (angle_in * M_PI) / 180.0;
vec2 direction = vec2(cos(angle), sin(angle));
// Distance between neighboring taps: TAP_COUNT taps evenly spread
// over the 2 * amount_in pixel-long segment centered on the pixel.
vec2 step = direction * (2.0 * amount_in) / (resolution_in * float(TAP_COUNT - 1));
vec4 sum = vec4(0.0);
for (int i = 0; i < TAP_COUNT; ++i) {
// Tap offset in [-amount_in, +amount_in] pixels, centered on 0.
float t = float(i) - float(TAP_COUNT - 1) * 0.5;
sum += texture(tex_in, ove_texcoord + step * t);
}
frag_color = sum / float(TAP_COUNT);
}
"#;
impl DirBlurNode {
/// Fragment shader for any request (this node has a single variant).
fn shader_frag() -> &'static str {
SHADER_FRAG
}
}
impl NodeBehavior for DirBlurNode {
/// Human-readable name.
fn name(&self) -> &str {
"Directional Blur"
}
/// Stable type id.
fn type_id(&self) -> &str {
"org.olivevideoeditor.Olive.dirblur"
}
/// Categories.
fn categories(&self) -> &[Category] {
&[Category::Filter]
}
/// Description.
fn description(&self) -> &str {
"Blurs an image along a direction."
}
/// Localized input names: `tex_in` -> "Input", `amount_in` ->
/// "Amount", `angle_in` -> "Angle".
fn input_name<'a>(&self, id: &'a str) -> &'a str {
match id {
TEXTURE_INPUT => "Input",
AMOUNT_INPUT => "Amount",
ANGLE_INPUT => "Angle",
_ => id,
}
}
/// Evaluate outputs: no texture -> push nothing; otherwise push the
/// directional-blur shader job.
///
/// A zero `amount_in` still pushes the job (the shader's tap spacing
/// then collapses to zero and the pass is an exact identity) rather
/// than passing the input texture through as the blur node does for
/// a zero radius: the plan's node template reserves the pass-through
/// for the no-texture case, and feeding the input's CPU texture
/// downstream here would silently break nodes that expect a GPU
/// texture. The resolved amount and angle are written into the job
/// row so the uniforms are always present, even when the incoming
/// row only carries the effect input.
///
/// `resolution_in` is filled by the runner from the effect input's
/// size (C++ `tex->virtual_resolution()`; see the blur node's
/// `// CPP-PARITY: blur.cpp` note).
fn value(
&self,
core: &NodeCore,
inputs: &crate::value::NodeValueRow,
time: oak_core::Rational,
table: &mut crate::value::NodeValueTable,
) {
use crate::value::{NodeValue, ValueType};
match inputs.get(TEXTURE_INPUT) {
Some(NodeValue::Texture(_)) => {}
_ => return,
}
let amount = match inputs.get(AMOUNT_INPUT) {
Some(v) => v.to_double(),
None => core.value_at_time(AMOUNT_INPUT, -1, time).to_double(),
};
let angle = match inputs.get(ANGLE_INPUT) {
Some(v) => v.to_double(),
None => core.value_at_time(ANGLE_INPUT, -1, time).to_double(),
};
let mut params = inputs.clone();
params.insert(AMOUNT_INPUT.to_string(), NodeValue::Float(amount));
params.insert(ANGLE_INPUT.to_string(), NodeValue::Float(angle));
table.push(
ValueType::Texture,
NodeValue::Texture(crate::handle::make_owned(ShaderJobPayload {
node_id: crate::id::NodeId::INVALID,
time,
iterations: 1,
type_id: self.type_id().to_string(),
shader_id: String::new(),
effect_input: core.effect_input.clone(),
params,
iterative_input: String::new(),
})),
None,
);
}
/// Shader code request: always the one fragment source.
fn shader_code(&self, _request: &str) -> Option<String> {
Some(Self::shader_frag().to_string())
}
/// Deep copy.
fn duplicate(&self, _core: &NodeCore) -> Option<Box<dyn NodeBehavior>> {
Some(Box::new(DirBlurNode))
}
}
/// Constructor: adds `tex_in`, `amount_in` and `angle_in` with the
/// defaults and properties documented on the constants, sets the
/// video-effect flag and the effect input.
pub fn create() -> (NodeCore, Box<dyn NodeBehavior>) {
let mut core = NodeCore::new();
let mut tex = crate::input::Input::new(
TEXTURE_INPUT,
crate::value::ValueType::Texture,
crate::value::NodeValue::None,
);
tex.flags |= crate::input::flags::NOT_KEYFRAMABLE;
core.add_input(tex);
let mut amount = crate::input::Input::new(
AMOUNT_INPUT,
crate::value::ValueType::Float,
crate::value::NodeValue::Float(0.0),
);
amount.properties = vec![("min".to_string(), crate::value::NodeValue::Float(0.0))];
core.add_input(amount);
core.add_input(crate::input::Input::new(
ANGLE_INPUT,
crate::value::ValueType::Float,
crate::value::NodeValue::Float(0.0),
));
core.flags |= crate::node::flags::VIDEO_EFFECT;
core.effect_input = TEXTURE_INPUT.to_string();
(core, Box::new(DirBlurNode))
}
#[cfg(test)]
mod tests {
use super::*;
use crate::value::{NodeValue, NodeValueTable, ValueType};
use oak_core::Rational;
fn tex() -> NodeValue {
NodeValue::Texture(crate::handle::CHandle::null())
}
fn run(core: &NodeCore, inputs: &crate::value::NodeValueRow) -> ShaderJobPayload {
let behavior = DirBlurNode;
let mut table = NodeValueTable::default();
behavior.value(core, inputs, Rational::new(0, 1), &mut table);
let Some(NodeValue::Texture(h)) = table.get(ValueType::Texture) else {
panic!("shader job expected");
};
unsafe { crate::handle::get_checked::<ShaderJobPayload>(h) }
.expect("shader job payload boxed")
.clone()
}
#[test]
fn input_names() {
let n = DirBlurNode;
assert_eq!(n.input_name(TEXTURE_INPUT), "Input");
assert_eq!(n.input_name(AMOUNT_INPUT), "Amount");
assert_eq!(n.input_name(ANGLE_INPUT), "Angle");
assert_eq!(n.input_name("other"), "other");
}
#[test]
fn create_wires_inputs_and_flags() {
let (core, behavior) = create();
assert_eq!(behavior.type_id(), "org.olivevideoeditor.Olive.dirblur");
assert_eq!(behavior.name(), "Directional Blur");
assert_eq!(behavior.categories(), &[Category::Filter]);
assert_eq!(core.effect_input, TEXTURE_INPUT);
assert_ne!(core.flags & crate::node::flags::VIDEO_EFFECT, 0);
let amount = core.get_input(AMOUNT_INPUT).expect("amount input");
assert_eq!(amount.default, NodeValue::Float(0.0));
assert!(amount
.properties
.iter()
.any(|(k, v)| k == "min" && *v == NodeValue::Float(0.0)));
let angle = core.get_input(ANGLE_INPUT).expect("angle input");
assert_eq!(angle.default, NodeValue::Float(0.0));
}
#[test]
fn value_no_texture_pushes_nothing() {
let (core, behavior) = create();
let mut table = NodeValueTable::default();
behavior.value(
&core,
&crate::value::NodeValueRow::default(),
Rational::new(0, 1),
&mut table,
);
assert!(table.is_empty());
}
#[test]
fn value_zero_amount_still_pushes_job_with_defaults() {
let (core, _) = create();
let inputs = crate::value::NodeValueRow::from([(TEXTURE_INPUT.to_string(), tex())]);
let payload = run(&core, &inputs);
assert_eq!(payload.type_id, "org.olivevideoeditor.Olive.dirblur");
assert_eq!(payload.shader_id, "");
assert_eq!(payload.effect_input, TEXTURE_INPUT);
assert_eq!(payload.iterations, 1);
assert_eq!(payload.iterative_input, "");
assert_eq!(
payload.params.get(AMOUNT_INPUT),
Some(&NodeValue::Float(0.0)),
"the blur amount rides in the job params"
);
assert_eq!(
payload.params.get(ANGLE_INPUT),
Some(&NodeValue::Float(0.0))
);
}
#[test]
fn value_takes_params_from_row() {
let (core, _) = create();
let inputs = crate::value::NodeValueRow::from([
(TEXTURE_INPUT.to_string(), tex()),
(AMOUNT_INPUT.to_string(), NodeValue::Float(12.0)),
(ANGLE_INPUT.to_string(), NodeValue::Float(90.0)),
]);
let payload = run(&core, &inputs);
assert_eq!(
payload.params.get(AMOUNT_INPUT),
Some(&NodeValue::Float(12.0))
);
assert_eq!(
payload.params.get(ANGLE_INPUT),
Some(&NodeValue::Float(90.0))
);
}
#[test]
fn value_takes_params_from_core() {
let (mut core, _) = create();
core.set_standard_value(AMOUNT_INPUT, -1, NodeValue::Float(4.0));
core.set_standard_value(ANGLE_INPUT, -1, NodeValue::Float(-45.0));
let inputs = crate::value::NodeValueRow::from([(TEXTURE_INPUT.to_string(), tex())]);
let payload = run(&core, &inputs);
assert_eq!(
payload.params.get(AMOUNT_INPUT),
Some(&NodeValue::Float(4.0))
);
assert_eq!(
payload.params.get(ANGLE_INPUT),
Some(&NodeValue::Float(-45.0))
);
}
#[test]
fn shader_code_is_centered_tap_average_without_switch() {
let n = DirBlurNode;
let glsl = n.shader_code("").unwrap();
assert!(glsl.contains("uniform float amount_in;"));
assert!(glsl.contains("uniform float angle_in;"));
assert!(glsl.contains("uniform vec2 resolution_in;"));
assert!(glsl.contains("#define TAP_COUNT 16"));
assert!(glsl.contains("float(TAP_COUNT - 1) * 0.5"));
assert!(glsl.contains("frag_color = sum / float(TAP_COUNT);"));
assert!(!glsl.contains("switch"));
}
#[test]
fn tap_count_matches_shader() {
let glsl = DirBlurNode::shader_frag();
assert!(
glsl.contains(&format!("#define TAP_COUNT {TAP_COUNT}")),
"the shader and the Rust-side tap count must agree"
);
}
#[test]
fn duplicate_clones_behavior() {
let (core, behavior) = create();
let dup = behavior.duplicate(&core).unwrap();
assert_eq!(dup.name(), "Directional Blur");
}
}
/// Register this node type.
pub fn register(meta: &mut Vec<NodeMeta>) {
meta.push(NodeMeta {
type_id: "org.olivevideoeditor.Olive.dirblur",
name: "Directional Blur",
categories: &[Category::Filter],
create,
});
}
crates/oak-node/src/nodes/dissolve.rs
+414
View File
@@ -0,0 +1,414 @@
// Oak Video Editor - Non-Linear Video Editor
// Copyright (C) 2026 Oak Team
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//! Dissolve effect (clean-room reimplementation of the OpenFX-Misc
//! `DissolveOFX` / `net.sf.openfx.DissolvePlugin`; the `Dissolve`
//! reference tree is used for parameter semantics only, no code copied).
//!
//! Upstream cross-fades a stack of inputs with a single `which` mix
//! factor — Natron folds a many-input dissolve into one effect, and for
//! two inputs that per-pixel result is the weighted average
//! `(1 - mix) * a + mix * b`. This node implements exactly that: two
//! texture inputs and a `mix_in` factor, so it is the atomic piece a
//! transition would be built from.
//!
//! Like [`crate::nodes::merge`], the node never sets a `core.effect_input`;
//! the both-present case boxes one [`ShaderJobPayload`] whose params row
//! carries both textures, and the renderer binds `tex_in`/`blend_in` by
//! name (the pass size follows the first bound texture — `blend_in`, the
//! alphabetically first key of the job's `BTreeMap` row).
use crate::factory::NodeMeta;
use crate::jobs::ShaderJobPayload;
use crate::node::{Category, NodeBehavior, NodeCore};
/// First ("from") texture input id. Type: texture; flags:
/// not-keyframable.
pub const TEXTURE_INPUT: &str = "tex_in";
/// Second ("to") texture input id. Type: texture; flags:
/// not-keyframable.
pub const BLEND_INPUT: &str = "blend_in";
/// Mix factor input id (upstream `which`, "Which"). Type: float; default
/// `0.5`; properties: `min = 0.0`, `max = 1.0`, `view = percentage`.
/// `0.0` yields `tex_in`, `1.0` yields `blend_in`. Upstream leaves its
/// default at OFX's `0.0` because `which` is an input *index* there;
/// with two inputs a neutral 50/50 dissolve is the more useful default
/// (`// CPP-PARITY: Dissolve.cpp` `describeInContext`).
pub const MIX_INPUT: &str = "mix_in";
/// Dissolve node. Unit-like: there is no per-instance state.
pub struct DissolveNode;
/// Fragment shader: cross-fade the two inputs by `mix_in`. The
/// `_enabled` flags mirror the alpha-over shader's convention for
/// unbound samplers (the renderer fills them in from the job's bound
/// textures; `run_effect`'s first-sampler fallback cannot misfire here
/// because `value()` passes the missing input through on the CPU side
/// instead of pushing a job). `switch` is deliberately not used (naga
/// rejects it).
const SHADER_FRAG: &str = r#"uniform sampler2D tex_in;
uniform sampler2D blend_in;
uniform bool tex_in_enabled;
uniform bool blend_in_enabled;
uniform float mix_in;
in vec2 ove_texcoord;
out vec4 frag_color;
void main(void) {
if (!tex_in_enabled && !blend_in_enabled) {
frag_color = vec4(0.0);
return;
}
if (!tex_in_enabled) {
frag_color = texture(blend_in, ove_texcoord);
return;
}
if (!blend_in_enabled) {
frag_color = texture(tex_in, ove_texcoord);
return;
}
vec4 tex_col = texture(tex_in, ove_texcoord);
vec4 blend_col = texture(blend_in, ove_texcoord);
frag_color = mix(tex_col, blend_col, mix_in);
}
"#;
impl DissolveNode {
/// Fragment shader (single variant, so the request id is ignored).
fn shader_frag() -> &'static str {
SHADER_FRAG
}
}
impl NodeBehavior for DissolveNode {
/// Human-readable name.
fn name(&self) -> &str {
"Dissolve"
}
/// Stable type id.
fn type_id(&self) -> &str {
"org.olivevideoeditor.Olive.dissolve"
}
/// Categories. Filed under math like the alpha-over
/// [`crate::nodes::merge`] (the `Category` enum has no merge group).
fn categories(&self) -> &[Category] {
&[Category::Math]
}
/// Description.
fn description(&self) -> &str {
"Dissolve between two textures by a mix factor."
}
/// Localized input names: `tex_in` -> "Input", `blend_in` ->
/// "Blend", `mix_in` -> "Mix".
fn input_name<'a>(&self, id: &'a str) -> &'a str {
match id {
TEXTURE_INPUT => "Input",
BLEND_INPUT => "Blend",
MIX_INPUT => "Mix",
_ => id,
}
}
/// Evaluate outputs: if only one texture is present, push it as-is
/// (a dissolve against nothing is the input itself — pushing a job
/// would also let `run_effect`'s first-sampler fallback bind the
/// lone texture to the missing one); if both are present, push one
/// shader job over the whole input row; if neither, push nothing.
///
/// The resolved mix factor is written into the job row so the
/// `mix_in` uniform is always present, even when the incoming row
/// only carries the textures (the row/standard-value split mirrors
/// the directional-blur node).
fn value(
&self,
core: &NodeCore,
inputs: &crate::value::NodeValueRow,
time: oak_core::Rational,
table: &mut crate::value::NodeValueTable,
) {
use crate::value::{NodeValue, ValueType};
let tex = inputs.get(TEXTURE_INPUT);
let blend = inputs.get(BLEND_INPUT);
match (tex, blend) {
(Some(NodeValue::Texture(_)), Some(NodeValue::Texture(_))) => {
let mix = match inputs.get(MIX_INPUT) {
Some(v) => v.to_double(),
None => core.value_at_time(MIX_INPUT, -1, time).to_double(),
};
let mut params = inputs.clone();
params.insert(MIX_INPUT.to_string(), NodeValue::Float(mix));
table.push(
ValueType::Texture,
NodeValue::Texture(crate::handle::make_owned(ShaderJobPayload {
node_id: crate::id::NodeId::INVALID,
time,
iterations: 1,
type_id: self.type_id().to_string(),
shader_id: String::new(),
effect_input: core.effect_input.clone(),
params,
iterative_input: String::new(),
})),
None,
);
}
(Some(t @ NodeValue::Texture(_)), _) => {
table.push(ValueType::Texture, t.clone(), None);
}
(_, Some(b @ NodeValue::Texture(_))) => {
table.push(ValueType::Texture, b.clone(), None);
}
_ => {}
}
}
/// Shader code request: always the cross-fade fragment source.
fn shader_code(&self, _request: &str) -> Option<String> {
Some(Self::shader_frag().to_string())
}
/// Deep copy.
fn duplicate(&self, _core: &NodeCore) -> Option<Box<dyn NodeBehavior>> {
Some(Box::new(DissolveNode))
}
}
/// Constructor: adds `tex_in`, `blend_in` and `mix_in` with the defaults
/// and properties documented on the constants and sets the video-effect
/// flag (no effect input: both textures bind by name).
pub fn create() -> (NodeCore, Box<dyn NodeBehavior>) {
let mut core = NodeCore::new();
let mut tex = crate::input::Input::new(
TEXTURE_INPUT,
crate::value::ValueType::Texture,
crate::value::NodeValue::None,
);
tex.flags |= crate::input::flags::NOT_KEYFRAMABLE;
core.add_input(tex);
let mut blend = crate::input::Input::new(
BLEND_INPUT,
crate::value::ValueType::Texture,
crate::value::NodeValue::None,
);
blend.flags |= crate::input::flags::NOT_KEYFRAMABLE;
core.add_input(blend);
let mut mix = crate::input::Input::new(
MIX_INPUT,
crate::value::ValueType::Float,
crate::value::NodeValue::Float(0.5),
);
mix.properties = vec![
("min".to_string(), crate::value::NodeValue::Float(0.0)),
("max".to_string(), crate::value::NodeValue::Float(1.0)),
(
"view".to_string(),
crate::value::NodeValue::Text("percentage".into()),
),
];
core.add_input(mix);
core.flags |= crate::node::flags::VIDEO_EFFECT;
(core, Box::new(DissolveNode))
}
#[cfg(test)]
mod tests {
use super::*;
use crate::value::{NodeValue, NodeValueTable, ValueType};
use oak_core::Rational;
fn tex() -> NodeValue {
NodeValue::Texture(crate::handle::CHandle::null())
}
fn run(core: &NodeCore, inputs: &crate::value::NodeValueRow) -> ShaderJobPayload {
let behavior = DissolveNode;
let mut table = NodeValueTable::default();
behavior.value(core, inputs, Rational::new(0, 1), &mut table);
let Some(NodeValue::Texture(h)) = table.get(ValueType::Texture) else {
panic!("shader job expected");
};
unsafe { crate::handle::get_checked::<ShaderJobPayload>(h) }
.expect("shader job payload boxed")
.clone()
}
#[test]
fn input_names() {
let n = DissolveNode;
assert_eq!(n.input_name(TEXTURE_INPUT), "Input");
assert_eq!(n.input_name(BLEND_INPUT), "Blend");
assert_eq!(n.input_name(MIX_INPUT), "Mix");
assert_eq!(n.input_name("other"), "other");
}
#[test]
fn create_wires_inputs_and_flags() {
let (core, behavior) = create();
assert_eq!(behavior.type_id(), "org.olivevideoeditor.Olive.dissolve");
assert_eq!(behavior.name(), "Dissolve");
assert_eq!(behavior.categories(), &[Category::Math]);
assert_ne!(core.flags & crate::node::flags::VIDEO_EFFECT, 0);
assert_eq!(core.effect_input, "");
for id in [TEXTURE_INPUT, BLEND_INPUT] {
let input = core.get_input(id).expect("texture input");
assert_ne!(input.flags & crate::input::flags::NOT_KEYFRAMABLE, 0);
}
let mix = core.get_input(MIX_INPUT).expect("mix input");
assert_eq!(mix.default, NodeValue::Float(0.5));
assert!(mix
.properties
.iter()
.any(|(k, v)| k == "min" && *v == NodeValue::Float(0.0)));
assert!(mix
.properties
.iter()
.any(|(k, v)| k == "max" && *v == NodeValue::Float(1.0)));
assert!(mix
.properties
.iter()
.any(|(k, v)| k == "view" && *v == NodeValue::Text("percentage".into())));
}
#[test]
fn value_no_texture_pushes_nothing() {
let (core, behavior) = create();
let mut table = NodeValueTable::default();
behavior.value(
&core,
&crate::value::NodeValueRow::default(),
Rational::new(0, 1),
&mut table,
);
assert!(table.is_empty());
}
#[test]
fn value_tex_only_pushes_tex() {
let (core, behavior) = create();
let input = tex();
let inputs = crate::value::NodeValueRow::from([(TEXTURE_INPUT.to_string(), input.clone())]);
let mut table = NodeValueTable::default();
behavior.value(&core, &inputs, Rational::new(0, 1), &mut table);
assert_eq!(table.get(ValueType::Texture), Some(&input));
}
#[test]
fn value_blend_only_pushes_blend() {
let (core, behavior) = create();
let blend = tex();
let inputs = crate::value::NodeValueRow::from([(BLEND_INPUT.to_string(), blend.clone())]);
let mut table = NodeValueTable::default();
behavior.value(&core, &inputs, Rational::new(0, 1), &mut table);
assert_eq!(table.get(ValueType::Texture), Some(&blend));
}
#[test]
fn value_both_pushes_job_payload_with_both_textures() {
let (core, _) = create();
let inputs = crate::value::NodeValueRow::from([
(TEXTURE_INPUT.to_string(), tex()),
(BLEND_INPUT.to_string(), tex()),
]);
let payload = run(&core, &inputs);
assert_eq!(payload.type_id, "org.olivevideoeditor.Olive.dissolve");
assert_eq!(payload.shader_id, "");
assert_eq!(payload.iterations, 1);
assert_eq!(payload.iterative_input, "");
assert!(payload.params.contains_key(TEXTURE_INPUT));
assert!(payload.params.contains_key(BLEND_INPUT));
assert_eq!(
payload.params.get(MIX_INPUT),
Some(&NodeValue::Float(0.5)),
"the mix factor rides in the job params"
);
}
#[test]
fn value_takes_mix_from_row() {
let (core, _) = create();
let inputs = crate::value::NodeValueRow::from([
(TEXTURE_INPUT.to_string(), tex()),
(BLEND_INPUT.to_string(), tex()),
(MIX_INPUT.to_string(), NodeValue::Float(1.0)),
]);
let payload = run(&core, &inputs);
assert_eq!(payload.params.get(MIX_INPUT), Some(&NodeValue::Float(1.0)));
}
#[test]
fn value_takes_mix_from_core() {
let (mut core, _) = create();
core.set_standard_value(MIX_INPUT, -1, NodeValue::Float(0.25));
let inputs = crate::value::NodeValueRow::from([
(TEXTURE_INPUT.to_string(), tex()),
(BLEND_INPUT.to_string(), tex()),
]);
let payload = run(&core, &inputs);
assert_eq!(payload.params.get(MIX_INPUT), Some(&NodeValue::Float(0.25)));
}
#[test]
fn shader_code_declares_inputs_without_switch() {
let n = DissolveNode;
let glsl = n.shader_code("").unwrap();
assert!(glsl.contains("uniform sampler2D tex_in;"));
assert!(glsl.contains("uniform sampler2D blend_in;"));
assert!(glsl.contains("uniform bool tex_in_enabled;"));
assert!(glsl.contains("uniform bool blend_in_enabled;"));
assert!(glsl.contains("uniform float mix_in;"));
assert!(glsl.contains("frag_color = mix(tex_col, blend_col, mix_in);"));
assert!(!glsl.contains("switch"));
}
#[test]
fn duplicate_clones_behavior() {
let (core, behavior) = create();
let dup = behavior.duplicate(&core).unwrap();
assert_eq!(dup.name(), "Dissolve");
}
}
/// Register this node type.
pub fn register(meta: &mut Vec<NodeMeta>) {
meta.push(NodeMeta {
type_id: "org.olivevideoeditor.Olive.dissolve",
name: "Dissolve",
categories: &[Category::Math],
create,
});
}
crates/oak-node/src/nodes/edgedetect.rs
+319
View File
@@ -0,0 +1,319 @@
// Oak Video Editor - Non-Linear Video Editor
// Copyright (C) 2026 Oak Team
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//! Edge detect filter (clean-room reimplementation of the CImg
//! `EdgeDetect`/`eu.cimg.EdgeDetect` effect; `ofx-misc` used for
//! parameter semantics only, no code copied).
use crate::factory::NodeMeta;
use crate::jobs::ShaderJobPayload;
use crate::node::{Category, NodeBehavior, NodeCore};
/// Texture input id. Type: texture; flags: not-keyframable; this is the
/// node's effect input.
pub const TEXTURE_INPUT: &str = "tex_in";
/// Threshold input id. Type: float; default `0.0`; properties: `min =
/// 0.0`. Gradient magnitudes below this value output black.
pub const THRESHOLD_INPUT: &str = "threshold_in";
/// Edge detect filter node. Sobel gradient magnitude, per RGB channel.
pub struct EdgeDetectNode;
/// Fragment shader: 3x3 Sobel gradient, per RGB channel; the magnitude is
/// `sqrt(gx^2 + gy^2)`, zeroed where it falls below `threshold_in` (a
/// branch-free `step`, no `switch`). The alpha channel passes through
/// unchanged so the result stays a visible, composable image; magnitudes
/// are not clamped (the filter is meant to feed a grade downstream).
/// Pixel offsets are one texel (`resolution_in`), sampling at texel
/// centers; edge-of-frame taps clamp to the border pixel.
const SHADER_FRAG: &str = r#"uniform sampler2D tex_in;
uniform float threshold_in;
uniform vec2 resolution_in;
in vec2 ove_texcoord;
out vec4 frag_color;
vec3 edge_sample(vec2 uv) {
return texture(tex_in, uv).rgb;
}
void main() {
vec2 texel = vec2(1.0) / resolution_in;
vec3 tl = edge_sample(ove_texcoord + texel * vec2(-1.0, -1.0));
vec3 tc = edge_sample(ove_texcoord + texel * vec2( 0.0, -1.0));
vec3 tr = edge_sample(ove_texcoord + texel * vec2( 1.0, -1.0));
vec3 ml = edge_sample(ove_texcoord + texel * vec2(-1.0, 0.0));
vec3 mr = edge_sample(ove_texcoord + texel * vec2( 1.0, 0.0));
vec3 bl = edge_sample(ove_texcoord + texel * vec2(-1.0, 1.0));
vec3 bc = edge_sample(ove_texcoord + texel * vec2( 0.0, 1.0));
vec3 br = edge_sample(ove_texcoord + texel * vec2( 1.0, 1.0));
vec3 gx = (tr + 2.0 * mr + br) - (tl + 2.0 * ml + bl);
vec3 gy = (bl + 2.0 * bc + br) - (tl + 2.0 * tc + tr);
vec3 magnitude = sqrt(gx * gx + gy * gy);
vec3 masked = magnitude * step(vec3(threshold_in), magnitude);
frag_color = vec4(masked, texture(tex_in, ove_texcoord).a);
}
"#;
impl EdgeDetectNode {
/// Fragment shader for any request (this node has a single variant).
fn shader_frag() -> &'static str {
SHADER_FRAG
}
}
impl NodeBehavior for EdgeDetectNode {
/// Human-readable name.
fn name(&self) -> &str {
"Edge Detect"
}
/// Stable type id.
fn type_id(&self) -> &str {
"org.olivevideoeditor.Olive.edgedetect"
}
/// Categories.
fn categories(&self) -> &[Category] {
&[Category::Filter]
}
/// Description.
fn description(&self) -> &str {
"Detect edges with a Sobel gradient filter."
}
/// Localized input names: `tex_in` -> "Input", `threshold_in` ->
/// "Threshold".
fn input_name<'a>(&self, id: &'a str) -> &'a str {
match id {
TEXTURE_INPUT => "Input",
THRESHOLD_INPUT => "Threshold",
_ => id,
}
}
/// Evaluate outputs: no texture -> push nothing; otherwise push the
/// Sobel shader job (threshold rides in the params row as the
/// `threshold_in` uniform).
fn value(
&self,
core: &NodeCore,
inputs: &crate::value::NodeValueRow,
time: oak_core::Rational,
table: &mut crate::value::NodeValueTable,
) {
use crate::value::{NodeValue, ValueType};
match inputs.get(TEXTURE_INPUT) {
Some(NodeValue::Texture(_)) => {}
_ => return,
}
let threshold = match inputs.get(THRESHOLD_INPUT) {
Some(v) => v.to_double(),
None => core.value_at_time(THRESHOLD_INPUT, -1, time).to_double(),
};
let mut params = inputs.clone();
params.insert(THRESHOLD_INPUT.to_string(), NodeValue::Float(threshold));
table.push(
ValueType::Texture,
NodeValue::Texture(crate::handle::make_owned(ShaderJobPayload {
node_id: crate::id::NodeId::INVALID,
time,
iterations: 1,
type_id: self.type_id().to_string(),
shader_id: String::new(),
effect_input: core.effect_input.clone(),
params,
iterative_input: String::new(),
})),
None,
);
}
/// Shader code request: always the one fragment source.
fn shader_code(&self, _request: &str) -> Option<String> {
Some(Self::shader_frag().to_string())
}
/// Deep copy.
fn duplicate(&self, _core: &NodeCore) -> Option<Box<dyn NodeBehavior>> {
Some(Box::new(EdgeDetectNode))
}
}
/// Constructor: adds `tex_in` and `threshold_in` with the defaults and
/// properties documented on the constants, sets the video-effect flag and
/// the effect input.
pub fn create() -> (NodeCore, Box<dyn NodeBehavior>) {
let mut core = NodeCore::new();
let mut tex = crate::input::Input::new(
TEXTURE_INPUT,
crate::value::ValueType::Texture,
crate::value::NodeValue::None,
);
tex.flags |= crate::input::flags::NOT_KEYFRAMABLE;
core.add_input(tex);
let mut threshold = crate::input::Input::new(
THRESHOLD_INPUT,
crate::value::ValueType::Float,
crate::value::NodeValue::Float(0.0),
);
threshold.properties = vec![("min".to_string(), crate::value::NodeValue::Float(0.0))];
core.add_input(threshold);
core.flags |= crate::node::flags::VIDEO_EFFECT;
core.effect_input = TEXTURE_INPUT.to_string();
(core, Box::new(EdgeDetectNode))
}
#[cfg(test)]
mod tests {
use super::*;
use crate::value::{NodeValue, NodeValueTable, ValueType};
use oak_core::Rational;
fn tex() -> NodeValue {
NodeValue::Texture(crate::handle::CHandle::null())
}
fn run(core: &NodeCore, inputs: &crate::value::NodeValueRow) -> ShaderJobPayload {
let behavior = EdgeDetectNode;
let mut table = NodeValueTable::default();
behavior.value(core, inputs, Rational::new(0, 1), &mut table);
let Some(NodeValue::Texture(h)) = table.get(ValueType::Texture) else {
panic!("shader job expected");
};
unsafe { crate::handle::get_checked::<ShaderJobPayload>(h) }
.expect("shader job payload boxed")
.clone()
}
#[test]
fn input_names() {
let n = EdgeDetectNode;
assert_eq!(n.input_name(TEXTURE_INPUT), "Input");
assert_eq!(n.input_name(THRESHOLD_INPUT), "Threshold");
assert_eq!(n.input_name("other"), "other");
}
#[test]
fn create_wires_inputs_and_flags() {
let (core, behavior) = create();
assert_eq!(behavior.type_id(), "org.olivevideoeditor.Olive.edgedetect");
assert_eq!(behavior.categories(), &[Category::Filter]);
assert_eq!(core.effect_input, TEXTURE_INPUT);
assert_ne!(core.flags & crate::node::flags::VIDEO_EFFECT, 0);
let threshold = core.get_input(THRESHOLD_INPUT).expect("threshold input");
assert_eq!(threshold.default, NodeValue::Float(0.0));
assert!(threshold
.properties
.iter()
.any(|(k, v)| k == "min" && *v == NodeValue::Float(0.0)));
}
#[test]
fn value_no_texture_pushes_nothing() {
let (core, behavior) = create();
let mut table = NodeValueTable::default();
behavior.value(
&core,
&crate::value::NodeValueRow::default(),
Rational::new(0, 1),
&mut table,
);
assert!(table.is_empty());
}
#[test]
fn value_pushes_job_with_threshold_default() {
let (core, _) = create();
let inputs = crate::value::NodeValueRow::from([(TEXTURE_INPUT.to_string(), tex())]);
let payload = run(&core, &inputs);
assert_eq!(payload.type_id, "org.olivevideoeditor.Olive.edgedetect");
assert_eq!(payload.shader_id, "");
assert_eq!(payload.effect_input, TEXTURE_INPUT);
assert_eq!(payload.iterations, 1);
assert_eq!(payload.iterative_input, "");
assert_eq!(
payload.params.get(THRESHOLD_INPUT),
Some(&NodeValue::Float(0.0))
);
}
#[test]
fn value_takes_threshold_from_row() {
let (core, _) = create();
let inputs = crate::value::NodeValueRow::from([
(TEXTURE_INPUT.to_string(), tex()),
(THRESHOLD_INPUT.to_string(), NodeValue::Float(0.5)),
]);
let payload = run(&core, &inputs);
assert_eq!(
payload.params.get(THRESHOLD_INPUT),
Some(&NodeValue::Float(0.5))
);
}
#[test]
fn value_takes_threshold_from_core() {
let (mut core, _) = create();
core.set_standard_value(THRESHOLD_INPUT, -1, NodeValue::Float(0.75));
let inputs = crate::value::NodeValueRow::from([(TEXTURE_INPUT.to_string(), tex())]);
let payload = run(&core, &inputs);
assert_eq!(
payload.params.get(THRESHOLD_INPUT),
Some(&NodeValue::Float(0.75))
);
}
#[test]
fn shader_code_is_sobel_without_switch() {
let n = EdgeDetectNode;
let glsl = n.shader_code("").unwrap();
assert!(glsl.contains("uniform vec2 resolution_in;"));
assert!(glsl.contains("sqrt(gx * gx + gy * gy)"));
assert!(glsl.contains("step(vec3(threshold_in), magnitude)"));
assert!(!glsl.contains("switch"));
}
#[test]
fn duplicate_clones_behavior() {
let (core, behavior) = create();
let dup = behavior.duplicate(&core).unwrap();
assert_eq!(dup.name(), "Edge Detect");
}
}
/// Register this node type.
pub fn register(meta: &mut Vec<NodeMeta>) {
meta.push(NodeMeta {
type_id: "org.olivevideoeditor.Olive.edgedetect",
name: "Edge Detect",
categories: &[Category::Filter],
create,
});
}
crates/oak-node/src/nodes/erode.rs
+330
View File
@@ -0,0 +1,330 @@
// Oak Video Editor - Non-Linear Video Editor
// Copyright (C) 2026 Oak Team
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//! Erode filter (clean-room reimplementation of the CImg `Erode`/
//! `net.sf.cimg.CImgErode` effect; `ofx-misc` used for parameter
//! semantics only, no code copied).
use crate::factory::NodeMeta;
use crate::jobs::ShaderJobPayload;
use crate::node::{Category, NodeBehavior, NodeCore};
/// Texture input id. Type: texture; flags: not-keyframable; this is the
/// node's effect input.
pub const TEXTURE_INPUT: &str = "tex_in";
/// Radius input id. Type: float; default `1.0`; properties: `min = 0.0`,
/// `max = 7.0`. The structuring element is a square of `2 * radius + 1`
/// pixels on a side, in pixels.
pub const RADIUS_INPUT: &str = "radius_in";
/// Largest supported radius. The shader clamps to this; the neighborhood
/// is `15 x 15` pixels, sampled in a single pass (see [`SHADER_FRAG`]).
pub const MAX_RADIUS: f64 = 7.0;
/// Erode filter node. Morphological minimum over a square neighborhood.
pub struct ErodeNode;
/// Fragment shader: one pass sampling the full `(2r+1)^2` neighborhood
/// and taking the per-channel minimum. `iterations` stays 1 — a single
/// wide pass is mathematically identical to `r` 3x3 iterations for a
/// square structuring element (min is associative and idempotent), and
/// avoids the ping-pong feedback textures entirely. `radius_in` is
/// rounded to the nearest integer and clamped to `0..=7`; offsets are
/// pixel-space texel steps (`resolution_in`, texel centers), with
/// edge-of-frame taps clamping to the border pixel.
const SHADER_FRAG: &str = r#"uniform sampler2D tex_in;
uniform float radius_in;
uniform vec2 resolution_in;
in vec2 ove_texcoord;
out vec4 frag_color;
void main() {
int radius = int(clamp(radius_in, 0.0, 7.0) + 0.5);
vec2 texel = vec2(1.0) / resolution_in;
vec4 acc = texture(tex_in, ove_texcoord);
for (int dy = -radius; dy <= radius; ++dy) {
for (int dx = -radius; dx <= radius; ++dx) {
vec2 uv = ove_texcoord + vec2(float(dx), float(dy)) * texel;
acc = min(acc, texture(tex_in, uv));
}
}
frag_color = acc;
}
"#;
impl ErodeNode {
/// Fragment shader for any request (this node has a single variant).
fn shader_frag() -> &'static str {
SHADER_FRAG
}
}
impl NodeBehavior for ErodeNode {
/// Human-readable name.
fn name(&self) -> &str {
"Erode"
}
/// Stable type id.
fn type_id(&self) -> &str {
"org.olivevideoeditor.Olive.erode"
}
/// Categories.
fn categories(&self) -> &[Category] {
&[Category::Filter]
}
/// Description.
fn description(&self) -> &str {
"Shrink bright areas by taking the minimum over a square neighborhood."
}
/// Localized input names: `tex_in` -> "Input", `radius_in` ->
/// "Radius".
fn input_name<'a>(&self, id: &'a str) -> &'a str {
match id {
TEXTURE_INPUT => "Input",
RADIUS_INPUT => "Radius",
_ => id,
}
}
/// Evaluate outputs: no texture -> push nothing; radius <= 0 -> push
/// the input texture unchanged (the same no-work shortcut as
/// `blur.rs`'s `can_push_job`); otherwise push the single-pass
/// neighborhood shader job.
fn value(
&self,
core: &NodeCore,
inputs: &crate::value::NodeValueRow,
time: oak_core::Rational,
table: &mut crate::value::NodeValueTable,
) {
use crate::value::{NodeValue, ValueType};
let tex = match inputs.get(TEXTURE_INPUT) {
Some(tex @ NodeValue::Texture(_)) => tex.clone(),
_ => return,
};
let radius = match inputs.get(RADIUS_INPUT) {
Some(v) => v.to_double(),
None => core.value_at_time(RADIUS_INPUT, -1, time).to_double(),
};
if radius <= 0.0 {
table.push(ValueType::Texture, tex, None);
return;
}
let mut params = inputs.clone();
params.insert(RADIUS_INPUT.to_string(), NodeValue::Float(radius));
table.push(
ValueType::Texture,
NodeValue::Texture(crate::handle::make_owned(ShaderJobPayload {
node_id: crate::id::NodeId::INVALID,
time,
iterations: 1,
type_id: self.type_id().to_string(),
shader_id: String::new(),
effect_input: core.effect_input.clone(),
params,
iterative_input: String::new(),
})),
None,
);
}
/// Shader code request: always the one fragment source.
fn shader_code(&self, _request: &str) -> Option<String> {
Some(Self::shader_frag().to_string())
}
/// Deep copy.
fn duplicate(&self, _core: &NodeCore) -> Option<Box<dyn NodeBehavior>> {
Some(Box::new(ErodeNode))
}
}
/// Constructor: adds `tex_in` and `radius_in` with the defaults and
/// properties documented on the constants, sets the video-effect flag and
/// the effect input.
pub fn create() -> (NodeCore, Box<dyn NodeBehavior>) {
let mut core = NodeCore::new();
let mut tex = crate::input::Input::new(
TEXTURE_INPUT,
crate::value::ValueType::Texture,
crate::value::NodeValue::None,
);
tex.flags |= crate::input::flags::NOT_KEYFRAMABLE;
core.add_input(tex);
let mut radius = crate::input::Input::new(
RADIUS_INPUT,
crate::value::ValueType::Float,
crate::value::NodeValue::Float(1.0),
);
radius.properties = vec![
("min".to_string(), crate::value::NodeValue::Float(0.0)),
("max".to_string(), crate::value::NodeValue::Float(MAX_RADIUS)),
];
core.add_input(radius);
core.flags |= crate::node::flags::VIDEO_EFFECT;
core.effect_input = TEXTURE_INPUT.to_string();
(core, Box::new(ErodeNode))
}
#[cfg(test)]
mod tests {
use super::*;
use crate::value::{NodeValue, NodeValueTable, ValueType};
use oak_core::Rational;
fn tex() -> NodeValue {
NodeValue::Texture(crate::handle::CHandle::null())
}
#[test]
fn input_names() {
let n = ErodeNode;
assert_eq!(n.input_name(TEXTURE_INPUT), "Input");
assert_eq!(n.input_name(RADIUS_INPUT), "Radius");
assert_eq!(n.input_name("other"), "other");
}
#[test]
fn create_wires_inputs_and_flags() {
let (core, behavior) = create();
assert_eq!(behavior.type_id(), "org.olivevideoeditor.Olive.erode");
assert_eq!(behavior.categories(), &[Category::Filter]);
assert_eq!(core.effect_input, TEXTURE_INPUT);
assert_ne!(core.flags & crate::node::flags::VIDEO_EFFECT, 0);
let radius = core.get_input(RADIUS_INPUT).expect("radius input");
assert_eq!(radius.default, NodeValue::Float(1.0));
assert!(radius
.properties
.iter()
.any(|(k, v)| k == "min" && *v == NodeValue::Float(0.0)));
assert!(radius
.properties
.iter()
.any(|(k, v)| k == "max" && *v == NodeValue::Float(MAX_RADIUS)));
}
#[test]
fn value_no_texture_pushes_nothing() {
let (core, behavior) = create();
let mut table = NodeValueTable::default();
behavior.value(
&core,
&crate::value::NodeValueRow::default(),
Rational::new(0, 1),
&mut table,
);
assert!(table.is_empty());
}
#[test]
fn value_zero_radius_passes_through() {
let (core, behavior) = create();
let tex = tex();
let inputs = crate::value::NodeValueRow::from([
(TEXTURE_INPUT.to_string(), tex.clone()),
(RADIUS_INPUT.to_string(), NodeValue::Float(0.0)),
]);
let mut table = NodeValueTable::default();
behavior.value(&core, &inputs, Rational::new(0, 1), &mut table);
assert_eq!(table.get(ValueType::Texture), Some(&tex));
}
#[test]
fn value_pushes_single_pass_job() {
let (core, behavior) = create();
let inputs = crate::value::NodeValueRow::from([
(TEXTURE_INPUT.to_string(), tex()),
(RADIUS_INPUT.to_string(), NodeValue::Float(2.0)),
]);
let mut table = NodeValueTable::default();
behavior.value(&core, &inputs, Rational::new(0, 1), &mut table);
let Some(NodeValue::Texture(h)) = table.get(ValueType::Texture) else {
panic!("shader job expected");
};
let payload = unsafe { crate::handle::get_checked::<ShaderJobPayload>(h) }
.expect("shader job payload boxed");
assert_eq!(payload.type_id, "org.olivevideoeditor.Olive.erode");
assert_eq!(payload.shader_id, "");
assert_eq!(payload.effect_input, TEXTURE_INPUT);
assert_eq!(payload.iterations, 1);
assert_eq!(payload.iterative_input, "");
assert_eq!(
payload.params.get(RADIUS_INPUT),
Some(&NodeValue::Float(2.0))
);
}
#[test]
fn value_default_radius_pushes_job() {
let (core, behavior) = create();
let inputs = crate::value::NodeValueRow::from([(TEXTURE_INPUT.to_string(), tex())]);
let mut table = NodeValueTable::default();
behavior.value(&core, &inputs, Rational::new(0, 1), &mut table);
let Some(NodeValue::Texture(h)) = table.get(ValueType::Texture) else {
panic!("shader job expected");
};
let payload = unsafe { crate::handle::get_checked::<ShaderJobPayload>(h) }
.expect("shader job payload boxed");
assert_eq!(
payload.params.get(RADIUS_INPUT),
Some(&NodeValue::Float(1.0))
);
}
#[test]
fn shader_code_is_single_pass_min_without_switch() {
let n = ErodeNode;
let glsl = n.shader_code("").unwrap();
assert!(glsl.contains("uniform vec2 resolution_in;"));
assert!(glsl.contains("acc = min(acc, texture(tex_in, uv));"));
assert!(glsl.contains("int(clamp(radius_in, 0.0, 7.0) + 0.5)"));
assert!(!glsl.contains("switch"));
}
#[test]
fn duplicate_clones_behavior() {
let (core, behavior) = create();
let dup = behavior.duplicate(&core).unwrap();
assert_eq!(dup.name(), "Erode");
}
}
/// Register this node type.
pub fn register(meta: &mut Vec<NodeMeta>) {
meta.push(NodeMeta {
type_id: "org.olivevideoeditor.Olive.erode",
name: "Erode",
categories: &[Category::Filter],
create,
});
}
crates/oak-node/src/nodes/gamma.rs
+335
View File
@@ -0,0 +1,335 @@
// Oak Video Editor - Non-Linear Video Editor
// Copyright (C) 2026 Oak Team
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//! Gamma effect — a clean-room reimplementation of the OpenFX-Misc
//! `Gamma` plugin's parameter semantics (upstream
//! `github.com/cgvirus/OpenFX-Misc`, GPL2; read for behavior only, no
//! upstream code copied).
//!
//! One gamma control, applied to all three color channels:
//!
//! ```text
//! x = (x > 0) ? pow(x, 1 / gamma) : x
//! ```
//!
//! Alpha is left untouched (the reference has no alpha toggle for this
//! node), and the pass only runs when the control differs from `1.0`.
//! Non-positive channels keep their value — a negative base has no real
//! power — and a non-positive gamma is clamped to a tiny positive
//! minimum so the reciprocal exponent never divides by zero.
use crate::factory::NodeMeta;
use crate::jobs::ShaderJobPayload;
use crate::node::{Category, NodeBehavior, NodeCore};
/// Texture input id. Type: texture; flags: not-keyframable; this is
/// the node's effect input.
pub const TEXTURE_INPUT: &str = "tex_in";
/// Gamma input id. Type: float; default `1.0`; properties:
/// `min = 0.0`, `max = 4.0`. Reciprocal exponent (`pow(x, 1/gamma)`);
/// `1.0` leaves the image unchanged.
pub const GAMMA_INPUT: &str = "gamma_in";
/// Gamma node. The reference class holds no state beyond its parameter
/// pointers, so this is a unit-like struct.
pub struct GammaNode;
/// Fragment shader (clean-room GLSL for the reference's
/// `GammaPlugin::render` chain). The uniforms are named after the node
/// inputs: the renderer binds uniforms by matching the declared name
/// against the job's parameter row.
const SHADER_FRAG: &str = r#"// Inputs
uniform sampler2D tex_in;
uniform float gamma_in;
// Input texture coordinate
in vec2 ove_texcoord;
out vec4 frag_color;
void main() {
vec4 c = texture(tex_in, ove_texcoord);
// Gamma: reciprocal exponent on the color channels. A non-positive
// gamma would divide by zero, so it is clamped to a tiny minimum, and
// non-positive channels pass through unchanged.
if (gamma_in != 1.0) {
float g = max(gamma_in, 1.0e-8);
if (c.r > 0.0) {
c.r = pow(c.r, 1.0 / g);
}
if (c.g > 0.0) {
c.g = pow(c.g, 1.0 / g);
}
if (c.b > 0.0) {
c.b = pow(c.b, 1.0 / g);
}
}
frag_color = c;
}
"#;
impl NodeBehavior for GammaNode {
/// Human-readable name.
fn name(&self) -> &str {
"Gamma"
}
/// Stable type id.
fn type_id(&self) -> &str {
"org.olivevideoeditor.Olive.gamma"
}
/// Categories.
fn categories(&self) -> &[Category] {
&[Category::Color]
}
/// Description.
fn description(&self) -> &str {
"Apply a gamma (reciprocal-exponent) correction to the image."
}
/// Localized input names: `tex_in` -> "Input", `gamma_in` ->
/// "Gamma".
fn input_name<'a>(&self, id: &'a str) -> &'a str {
match id {
TEXTURE_INPUT => "Input",
GAMMA_INPUT => "Gamma",
_ => id,
}
}
/// Evaluate outputs: no texture on `tex_in` -> push nothing;
/// texture present -> push a shader job over the input row with the
/// control resolved (so the renderer always finds a value for the
/// uniform, whether the row carried the input or the node's own
/// default/keyframe supplied it).
fn value(
&self,
core: &NodeCore,
inputs: &crate::value::NodeValueRow,
time: oak_core::Rational,
table: &mut crate::value::NodeValueTable,
) {
if !matches!(
inputs.get(TEXTURE_INPUT),
Some(crate::value::NodeValue::Texture(_))
) {
return;
}
let resolve = |id: &str| match inputs.get(id) {
Some(v) => v.clone(),
None => core.value_at_time(id, -1, time),
};
let mut params = inputs.clone();
params.insert(GAMMA_INPUT.to_string(), resolve(GAMMA_INPUT));
table.push(
crate::value::ValueType::Texture,
crate::value::NodeValue::Texture(crate::handle::make_owned(ShaderJobPayload {
node_id: crate::id::NodeId::INVALID,
time,
iterations: 1,
type_id: self.type_id().to_string(),
shader_id: String::new(),
effect_input: core.effect_input.clone(),
params,
iterative_input: String::new(),
})),
None,
);
}
/// Shader code request: the request id is ignored; always returns
/// [`SHADER_FRAG`].
fn shader_code(&self, _request: &str) -> Option<String> {
Some(SHADER_FRAG.to_string())
}
/// Deep copy.
fn duplicate(&self, _core: &NodeCore) -> Option<Box<dyn NodeBehavior>> {
Some(Box::new(GammaNode))
}
}
/// Constructor: adds `tex_in` (texture, effect input) and the gamma
/// control with the default and range documented on the constant, and
/// sets the video-effect flag.
pub fn create() -> (NodeCore, Box<dyn NodeBehavior>) {
let mut core = NodeCore::new();
let mut tex = crate::input::Input::new(
TEXTURE_INPUT,
crate::value::ValueType::Texture,
crate::value::NodeValue::None,
);
tex.flags |= crate::input::flags::NOT_KEYFRAMABLE;
core.add_input(tex);
add_float_input(&mut core, GAMMA_INPUT, 1.0, 0.0, 4.0);
core.flags |= crate::node::flags::VIDEO_EFFECT;
core.effect_input = TEXTURE_INPUT.to_string();
(core, Box::new(GammaNode))
}
/// Add a float input with its default and `min`/`max`/`view`
/// properties.
fn add_float_input(core: &mut NodeCore, id: &str, default: f64, min: f64, max: f64) {
let mut input = crate::input::Input::new(
id,
crate::value::ValueType::Float,
crate::value::NodeValue::Float(default),
);
input.properties = vec![
("min".to_string(), crate::value::NodeValue::Float(min)),
("max".to_string(), crate::value::NodeValue::Float(max)),
(
"view".to_string(),
crate::value::NodeValue::Text("normal".into()),
),
];
core.add_input(input);
}
/// Register this node type.
pub fn register(meta: &mut Vec<NodeMeta>) {
meta.push(NodeMeta {
type_id: "org.olivevideoeditor.Olive.gamma",
name: "Gamma",
categories: &[Category::Color],
create,
});
}
#[cfg(test)]
mod tests {
use super::*;
use crate::value::{NodeValue, NodeValueTable, ValueType};
use oak_core::Rational;
#[test]
fn input_names() {
let n = GammaNode;
assert_eq!(n.input_name(TEXTURE_INPUT), "Input");
assert_eq!(n.input_name(GAMMA_INPUT), "Gamma");
assert_eq!(n.input_name("other_in"), "other_in");
}
#[test]
fn create_wires_inputs_and_flags() {
let (core, behavior) = create();
assert_eq!(behavior.type_id(), "org.olivevideoeditor.Olive.gamma");
assert_eq!(behavior.name(), "Gamma");
assert_eq!(behavior.categories(), &[Category::Color]);
let tex = core.get_input(TEXTURE_INPUT).unwrap();
assert_ne!(tex.flags & crate::input::flags::NOT_KEYFRAMABLE, 0);
assert_eq!(
core.get_input(GAMMA_INPUT).unwrap().default,
NodeValue::Float(1.0)
);
assert_eq!(core.effect_input, TEXTURE_INPUT);
assert_ne!(core.flags & crate::node::flags::VIDEO_EFFECT, 0);
}
#[test]
fn create_sets_control_range() {
let (core, _) = create();
let gamma = core.get_input(GAMMA_INPUT).unwrap();
assert_eq!(gamma.properties[0].1, NodeValue::Float(0.0));
assert_eq!(gamma.properties[1].1, NodeValue::Float(4.0));
}
#[test]
fn value_no_texture_pushes_nothing() {
let (core, behavior) = create();
let mut table = NodeValueTable::default();
behavior.value(
&core,
&crate::value::NodeValueRow::default(),
Rational::new(0, 1),
&mut table,
);
assert!(table.is_empty());
}
#[test]
fn value_with_texture_pushes_shader_job_with_resolved_params() {
let (core, behavior) = create();
let inputs = crate::value::NodeValueRow::from([(
TEXTURE_INPUT.to_string(),
NodeValue::Texture(crate::handle::CHandle::null()),
)]);
let mut table = NodeValueTable::default();
behavior.value(&core, &inputs, Rational::new(0, 1), &mut table);
let Some(NodeValue::Texture(handle)) = table.get(ValueType::Texture) else {
panic!("expected a texture-typed value");
};
let payload =
unsafe { crate::handle::get_checked::<crate::jobs::ShaderJobPayload>(handle) }
.expect("shader job pushed");
assert_eq!(payload.type_id, "org.olivevideoeditor.Olive.gamma");
assert_eq!(payload.effect_input, TEXTURE_INPUT);
assert_eq!(payload.params.get(GAMMA_INPUT), Some(&NodeValue::Float(1.0)));
}
#[test]
fn value_row_values_win_over_defaults() {
let (mut core, behavior) = create();
core.set_standard_value(GAMMA_INPUT, -1, NodeValue::Float(3.0));
let inputs = crate::value::NodeValueRow::from([
(
TEXTURE_INPUT.to_string(),
NodeValue::Texture(crate::handle::CHandle::null()),
),
(GAMMA_INPUT.to_string(), NodeValue::Float(2.0)),
]);
let mut table = NodeValueTable::default();
behavior.value(&core, &inputs, Rational::new(0, 1), &mut table);
let Some(NodeValue::Texture(handle)) = table.get(ValueType::Texture) else {
panic!("expected a texture-typed value");
};
let payload =
unsafe { crate::handle::get_checked::<crate::jobs::ShaderJobPayload>(handle) }
.expect("shader job pushed");
assert_eq!(payload.params.get(GAMMA_INPUT), Some(&NodeValue::Float(2.0)));
}
#[test]
fn shader_declares_uniforms_and_avoids_switch() {
let code = GammaNode.shader_code("").unwrap();
for uniform in ["tex_in", GAMMA_INPUT] {
assert!(code.contains(uniform), "uniform {uniform} declared");
}
assert!(code.contains("ove_texcoord"));
assert!(code.contains("frag_color"));
assert!(!code.contains("switch"), "naga rejects GLSL switch");
}
#[test]
fn duplicate_clones() {
let (core, behavior) = create();
let dup = behavior.duplicate(&core).unwrap();
assert_eq!(dup.name(), "Gamma");
assert_eq!(dup.type_id(), "org.olivevideoeditor.Olive.gamma");
}
}
crates/oak-node/src/nodes/grade.rs
+417
View File
@@ -0,0 +1,417 @@
// Oak Video Editor - Non-Linear Video Editor
// Copyright (C) 2026 Oak Team
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//! Grade effect — a clean-room reimplementation of the OpenFX-Misc
//! `Grade` plugin's parameter semantics (upstream
//! `github.com/cgvirus/OpenFX-Misc`, GPL2; read for behavior only, no
//! upstream code copied).
//!
//! A five-point level remap of the three color channels:
//!
//! ```text
//! d = whitepoint - blackpoint
//! a = (d != 0) ? (white - black) / d : 0
//! b = black - a * blackpoint
//! x = a * x + b
//! x = (x > 0) ? pow(x, 1 / gamma) : x
//! ```
//!
//! Alpha is left untouched (the reference's grade pass is color-only).
//! The first line is the reference's black/white point stretch and the
//! second its gamma pass; only the reciprocal exponent is kept from the
//! reference's gamma stage. Deviations from the reference, all
//! deliberate:
//!
//! * The reference's `multiply`/`offset` parameters are dropped — they
//! sit at their identity values (`1.0`/`0.0`) in the reference's
//! default setup and would add two no-op controls.
//! * The reference guards its gamma pass with a small positive
//! threshold; here only non-positive channels are skipped (`pow` has
//! no real value there) and a non-positive gamma is clamped to a tiny
//! minimum rather than producing an infinity or a division by zero.
//! * A degenerate point range (`whitepoint == blackpoint`) leaves the
//! slope at `0.0` instead of dividing by zero.
use crate::factory::NodeMeta;
use crate::jobs::ShaderJobPayload;
use crate::node::{Category, NodeBehavior, NodeCore};
/// Texture input id. Type: texture; flags: not-keyframable; this is
/// the node's effect input.
pub const TEXTURE_INPUT: &str = "tex_in";
/// Black point input id. Type: float; default `0.0`. Input level mapped
/// to [`BLACK_INPUT`].
pub const BLACKPOINT_INPUT: &str = "blackpoint_in";
/// White point input id. Type: float; default `1.0`. Input level mapped
/// to [`WHITE_INPUT`].
pub const WHITEPOINT_INPUT: &str = "whitepoint_in";
/// Black output input id. Type: float; default `0.0`. Output value the
/// black point maps to.
pub const BLACK_INPUT: &str = "black_in";
/// White output input id. Type: float; default `1.0`. Output value the
/// white point maps to.
pub const WHITE_INPUT: &str = "white_in";
/// Gamma input id. Type: float; default `1.0`. Reciprocal exponent
/// applied after the level remap (`pow(x, 1/gamma)`).
pub const GAMMA_INPUT: &str = "gamma_in";
/// Grade node. The reference class holds no state beyond its parameter
/// pointers, so this is a unit-like struct.
pub struct GradeNode;
/// Fragment shader (clean-room GLSL for the reference's
/// `GradePlugin::render` chain). The uniforms are named after the node
/// inputs: the renderer binds uniforms by matching the declared name
/// against the job's parameter row.
const SHADER_FRAG: &str = r#"// Inputs
uniform sampler2D tex_in;
uniform float blackpoint_in;
uniform float whitepoint_in;
uniform float black_in;
uniform float white_in;
uniform float gamma_in;
// Input texture coordinate
in vec2 ove_texcoord;
out vec4 frag_color;
// Remap one channel: stretch [blackpoint, whitepoint] onto
// [black, white], then apply the reciprocal-exponent gamma.
float ove_grade(float v) {
float d = whitepoint_in - blackpoint_in;
float a = 0.0;
if (d != 0.0) {
a = (white_in - black_in) / d;
}
float b = black_in - a * blackpoint_in;
v = a * v + b;
if (gamma_in != 1.0) {
float g = max(gamma_in, 1.0e-8);
if (v > 0.0) {
v = pow(v, 1.0 / g);
}
}
return v;
}
void main() {
vec4 c = texture(tex_in, ove_texcoord);
c.r = ove_grade(c.r);
c.g = ove_grade(c.g);
c.b = ove_grade(c.b);
frag_color = c;
}
"#;
impl NodeBehavior for GradeNode {
/// Human-readable name.
fn name(&self) -> &str {
"Grade"
}
/// Stable type id.
fn type_id(&self) -> &str {
"org.olivevideoeditor.Olive.grade"
}
/// Categories.
fn categories(&self) -> &[Category] {
&[Category::Color]
}
/// Description.
fn description(&self) -> &str {
"Remap the color range with black/white points and a gamma."
}
/// Localized input names: `tex_in` -> "Input", `blackpoint_in` ->
/// "Black Point", `whitepoint_in` -> "White Point", `black_in` ->
/// "Black Output", `white_in` -> "White Output", `gamma_in` ->
/// "Gamma".
fn input_name<'a>(&self, id: &'a str) -> &'a str {
match id {
TEXTURE_INPUT => "Input",
BLACKPOINT_INPUT => "Black Point",
WHITEPOINT_INPUT => "White Point",
BLACK_INPUT => "Black Output",
WHITE_INPUT => "White Output",
GAMMA_INPUT => "Gamma",
_ => id,
}
}
/// Evaluate outputs: no texture on `tex_in` -> push nothing;
/// texture present -> push a shader job over the input row with
/// every control resolved (so the renderer always finds a value for
/// each uniform, whether the row carried the input or the node's own
/// default/keyframe supplied it).
fn value(
&self,
core: &NodeCore,
inputs: &crate::value::NodeValueRow,
time: oak_core::Rational,
table: &mut crate::value::NodeValueTable,
) {
if !matches!(
inputs.get(TEXTURE_INPUT),
Some(crate::value::NodeValue::Texture(_))
) {
return;
}
let resolve = |id: &str| match inputs.get(id) {
Some(v) => v.clone(),
None => core.value_at_time(id, -1, time),
};
let mut params = inputs.clone();
for id in [
BLACKPOINT_INPUT,
WHITEPOINT_INPUT,
BLACK_INPUT,
WHITE_INPUT,
GAMMA_INPUT,
] {
params.insert(id.to_string(), resolve(id));
}
table.push(
crate::value::ValueType::Texture,
crate::value::NodeValue::Texture(crate::handle::make_owned(ShaderJobPayload {
node_id: crate::id::NodeId::INVALID,
time,
iterations: 1,
type_id: self.type_id().to_string(),
shader_id: String::new(),
effect_input: core.effect_input.clone(),
params,
iterative_input: String::new(),
})),
None,
);
}
/// Shader code request: the request id is ignored; always returns
/// [`SHADER_FRAG`].
fn shader_code(&self, _request: &str) -> Option<String> {
Some(SHADER_FRAG.to_string())
}
/// Deep copy.
fn duplicate(&self, _core: &NodeCore) -> Option<Box<dyn NodeBehavior>> {
Some(Box::new(GradeNode))
}
}
/// Constructor: adds `tex_in` (texture, effect input) and the five
/// controls with the defaults documented on the constants, and sets the
/// video-effect flag.
pub fn create() -> (NodeCore, Box<dyn NodeBehavior>) {
let mut core = NodeCore::new();
let mut tex = crate::input::Input::new(
TEXTURE_INPUT,
crate::value::ValueType::Texture,
crate::value::NodeValue::None,
);
tex.flags |= crate::input::flags::NOT_KEYFRAMABLE;
core.add_input(tex);
add_float_input(&mut core, BLACKPOINT_INPUT, 0.0);
add_float_input(&mut core, WHITEPOINT_INPUT, 1.0);
add_float_input(&mut core, BLACK_INPUT, 0.0);
add_float_input(&mut core, WHITE_INPUT, 1.0);
add_float_input(&mut core, GAMMA_INPUT, 1.0);
core.flags |= crate::node::flags::VIDEO_EFFECT;
core.effect_input = TEXTURE_INPUT.to_string();
(core, Box::new(GradeNode))
}
/// Add a float input with its default. The reference declares no range
/// for these parameters, so no `min`/`max` properties are attached.
fn add_float_input(core: &mut NodeCore, id: &str, default: f64) {
core.add_input(crate::input::Input::new(
id,
crate::value::ValueType::Float,
crate::value::NodeValue::Float(default),
));
}
/// Register this node type.
pub fn register(meta: &mut Vec<NodeMeta>) {
meta.push(NodeMeta {
type_id: "org.olivevideoeditor.Olive.grade",
name: "Grade",
categories: &[Category::Color],
create,
});
}
#[cfg(test)]
mod tests {
use super::*;
use crate::value::{NodeValue, NodeValueTable, ValueType};
use oak_core::Rational;
#[test]
fn input_names() {
let n = GradeNode;
assert_eq!(n.input_name(TEXTURE_INPUT), "Input");
assert_eq!(n.input_name(BLACKPOINT_INPUT), "Black Point");
assert_eq!(n.input_name(WHITEPOINT_INPUT), "White Point");
assert_eq!(n.input_name(BLACK_INPUT), "Black Output");
assert_eq!(n.input_name(WHITE_INPUT), "White Output");
assert_eq!(n.input_name(GAMMA_INPUT), "Gamma");
assert_eq!(n.input_name("other_in"), "other_in");
}
#[test]
fn create_wires_inputs_and_flags() {
let (core, behavior) = create();
assert_eq!(behavior.type_id(), "org.olivevideoeditor.Olive.grade");
assert_eq!(behavior.name(), "Grade");
assert_eq!(behavior.categories(), &[Category::Color]);
let tex = core.get_input(TEXTURE_INPUT).unwrap();
assert_ne!(tex.flags & crate::input::flags::NOT_KEYFRAMABLE, 0);
assert_eq!(
core.get_input(BLACKPOINT_INPUT).unwrap().default,
NodeValue::Float(0.0)
);
assert_eq!(
core.get_input(WHITEPOINT_INPUT).unwrap().default,
NodeValue::Float(1.0)
);
assert_eq!(
core.get_input(BLACK_INPUT).unwrap().default,
NodeValue::Float(0.0)
);
assert_eq!(
core.get_input(WHITE_INPUT).unwrap().default,
NodeValue::Float(1.0)
);
assert_eq!(
core.get_input(GAMMA_INPUT).unwrap().default,
NodeValue::Float(1.0)
);
assert_eq!(core.effect_input, TEXTURE_INPUT);
assert_ne!(core.flags & crate::node::flags::VIDEO_EFFECT, 0);
}
#[test]
fn value_no_texture_pushes_nothing() {
let (core, behavior) = create();
let mut table = NodeValueTable::default();
behavior.value(
&core,
&crate::value::NodeValueRow::default(),
Rational::new(0, 1),
&mut table,
);
assert!(table.is_empty());
}
#[test]
fn value_with_texture_pushes_shader_job_with_resolved_params() {
let (core, behavior) = create();
let inputs = crate::value::NodeValueRow::from([(
TEXTURE_INPUT.to_string(),
NodeValue::Texture(crate::handle::CHandle::null()),
)]);
let mut table = NodeValueTable::default();
behavior.value(&core, &inputs, Rational::new(0, 1), &mut table);
let Some(NodeValue::Texture(handle)) = table.get(ValueType::Texture) else {
panic!("expected a texture-typed value");
};
let payload =
unsafe { crate::handle::get_checked::<crate::jobs::ShaderJobPayload>(handle) }
.expect("shader job pushed");
assert_eq!(payload.type_id, "org.olivevideoeditor.Olive.grade");
assert_eq!(payload.effect_input, TEXTURE_INPUT);
assert_eq!(
payload.params.get(BLACKPOINT_INPUT),
Some(&NodeValue::Float(0.0))
);
assert_eq!(
payload.params.get(WHITEPOINT_INPUT),
Some(&NodeValue::Float(1.0))
);
assert_eq!(payload.params.get(BLACK_INPUT), Some(&NodeValue::Float(0.0)));
assert_eq!(payload.params.get(WHITE_INPUT), Some(&NodeValue::Float(1.0)));
assert_eq!(payload.params.get(GAMMA_INPUT), Some(&NodeValue::Float(1.0)));
}
#[test]
fn value_row_values_win_over_defaults() {
let (mut core, behavior) = create();
core.set_standard_value(BLACKPOINT_INPUT, -1, NodeValue::Float(0.0));
let inputs = crate::value::NodeValueRow::from([
(
TEXTURE_INPUT.to_string(),
NodeValue::Texture(crate::handle::CHandle::null()),
),
(BLACKPOINT_INPUT.to_string(), NodeValue::Float(0.1)),
]);
let mut table = NodeValueTable::default();
behavior.value(&core, &inputs, Rational::new(0, 1), &mut table);
let Some(NodeValue::Texture(handle)) = table.get(ValueType::Texture) else {
panic!("expected a texture-typed value");
};
let payload =
unsafe { crate::handle::get_checked::<crate::jobs::ShaderJobPayload>(handle) }
.expect("shader job pushed");
assert_eq!(
payload.params.get(BLACKPOINT_INPUT),
Some(&NodeValue::Float(0.1))
);
}
#[test]
fn shader_declares_uniforms_and_avoids_switch() {
let code = GradeNode.shader_code("").unwrap();
for uniform in [
"tex_in",
BLACKPOINT_INPUT,
WHITEPOINT_INPUT,
BLACK_INPUT,
WHITE_INPUT,
GAMMA_INPUT,
] {
assert!(code.contains(uniform), "uniform {uniform} declared");
}
assert!(code.contains("ove_texcoord"));
assert!(code.contains("frag_color"));
assert!(!code.contains("switch"), "naga rejects GLSL switch");
}
#[test]
fn duplicate_clones() {
let (core, behavior) = create();
let dup = behavior.duplicate(&core).unwrap();
assert_eq!(dup.name(), "Grade");
assert_eq!(dup.type_id(), "org.olivevideoeditor.Olive.grade");
}
}
crates/oak-node/src/nodes/invert.rs
+364
View File
@@ -0,0 +1,364 @@
// Oak Video Editor - Non-Linear Video Editor
// Copyright (C) 2026 Oak Team
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//! Invert effect — a clean-room reimplementation of the OpenFX-Misc
//! `Invert` plugin's parameter semantics (upstream
//! `github.com/cgvirus/OpenFX-Misc`, GPL2; read for behavior only, no
//! upstream code copied).
//!
//! One enable toggle per channel:
//!
//! ```text
//! x = enabled ? 1 - x : x (independently for r, g, b, a)
//! ```
//!
//! All four toggles default to on, matching the reference, whose
//! `processA`/`processR`/`processG`/`processB` booleans all default to
//! `true`. Unlike the reference (fixed per-component instance
//! parameters), each toggle is a separate node input here.
use crate::factory::NodeMeta;
use crate::jobs::ShaderJobPayload;
use crate::node::{Category, NodeBehavior, NodeCore};
/// Texture input id. Type: texture; flags: not-keyframable; this is
/// the node's effect input.
pub const TEXTURE_INPUT: &str = "tex_in";
/// Red channel toggle id. Type: boolean; default `true`.
pub const INVERT_R_INPUT: &str = "invert_r_in";
/// Green channel toggle id. Type: boolean; default `true`.
pub const INVERT_G_INPUT: &str = "invert_g_in";
/// Blue channel toggle id. Type: boolean; default `true`.
pub const INVERT_B_INPUT: &str = "invert_b_in";
/// Alpha channel toggle id. Type: boolean; default `true`.
pub const INVERT_A_INPUT: &str = "invert_a_in";
/// Invert node. The reference class holds no state beyond its
/// parameter pointers, so this is a unit-like struct.
pub struct InvertNode;
/// Fragment shader (clean-room GLSL for the reference's
/// `InvertPlugin::render` chain). The uniforms are named after the node
/// inputs: the renderer binds uniforms by matching the declared name
/// against the job's parameter row.
const SHADER_FRAG: &str = r#"// Inputs
uniform sampler2D tex_in;
uniform bool invert_r_in;
uniform bool invert_g_in;
uniform bool invert_b_in;
uniform bool invert_a_in;
// Input texture coordinate
in vec2 ove_texcoord;
out vec4 frag_color;
void main() {
vec4 c = texture(tex_in, ove_texcoord);
// One independent toggle per channel.
if (invert_r_in) {
c.r = 1.0 - c.r;
}
if (invert_g_in) {
c.g = 1.0 - c.g;
}
if (invert_b_in) {
c.b = 1.0 - c.b;
}
if (invert_a_in) {
c.a = 1.0 - c.a;
}
frag_color = c;
}
"#;
impl NodeBehavior for InvertNode {
/// Human-readable name.
fn name(&self) -> &str {
"Invert"
}
/// Stable type id.
fn type_id(&self) -> &str {
"org.olivevideoeditor.Olive.invert"
}
/// Categories.
fn categories(&self) -> &[Category] {
&[Category::Color]
}
/// Description.
fn description(&self) -> &str {
"Invert individual color channels."
}
/// Localized input names: `tex_in` -> "Input" and one "Invert
/// <Channel>" label per toggle.
fn input_name<'a>(&self, id: &'a str) -> &'a str {
match id {
TEXTURE_INPUT => "Input",
INVERT_R_INPUT => "Invert Red",
INVERT_G_INPUT => "Invert Green",
INVERT_B_INPUT => "Invert Blue",
INVERT_A_INPUT => "Invert Alpha",
_ => id,
}
}
/// Evaluate outputs: no texture on `tex_in` -> push nothing;
/// texture present -> push a shader job over the input row with
/// every toggle resolved (so the renderer always finds a value for
/// each uniform, whether the row carried the input or the node's own
/// default/keyframe supplied it).
fn value(
&self,
core: &NodeCore,
inputs: &crate::value::NodeValueRow,
time: oak_core::Rational,
table: &mut crate::value::NodeValueTable,
) {
if !matches!(
inputs.get(TEXTURE_INPUT),
Some(crate::value::NodeValue::Texture(_))
) {
return;
}
let resolve = |id: &str| match inputs.get(id) {
Some(v) => v.clone(),
None => core.value_at_time(id, -1, time),
};
let mut params = inputs.clone();
for id in [
INVERT_R_INPUT,
INVERT_G_INPUT,
INVERT_B_INPUT,
INVERT_A_INPUT,
] {
params.insert(id.to_string(), resolve(id));
}
table.push(
crate::value::ValueType::Texture,
crate::value::NodeValue::Texture(crate::handle::make_owned(ShaderJobPayload {
node_id: crate::id::NodeId::INVALID,
time,
iterations: 1,
type_id: self.type_id().to_string(),
shader_id: String::new(),
effect_input: core.effect_input.clone(),
params,
iterative_input: String::new(),
})),
None,
);
}
/// Shader code request: the request id is ignored; always returns
/// [`SHADER_FRAG`].
fn shader_code(&self, _request: &str) -> Option<String> {
Some(SHADER_FRAG.to_string())
}
/// Deep copy.
fn duplicate(&self, _core: &NodeCore) -> Option<Box<dyn NodeBehavior>> {
Some(Box::new(InvertNode))
}
}
/// Constructor: adds `tex_in` (texture, effect input) and the four
/// channel toggles, all defaulting to on, and sets the video-effect
/// flag.
pub fn create() -> (NodeCore, Box<dyn NodeBehavior>) {
let mut core = NodeCore::new();
let mut tex = crate::input::Input::new(
TEXTURE_INPUT,
crate::value::ValueType::Texture,
crate::value::NodeValue::None,
);
tex.flags |= crate::input::flags::NOT_KEYFRAMABLE;
core.add_input(tex);
for id in [
INVERT_R_INPUT,
INVERT_G_INPUT,
INVERT_B_INPUT,
INVERT_A_INPUT,
] {
core.add_input(crate::input::Input::new(
id,
crate::value::ValueType::Boolean,
crate::value::NodeValue::Boolean(true),
));
}
core.flags |= crate::node::flags::VIDEO_EFFECT;
core.effect_input = TEXTURE_INPUT.to_string();
(core, Box::new(InvertNode))
}
/// Register this node type.
pub fn register(meta: &mut Vec<NodeMeta>) {
meta.push(NodeMeta {
type_id: "org.olivevideoeditor.Olive.invert",
name: "Invert",
categories: &[Category::Color],
create,
});
}
#[cfg(test)]
mod tests {
use super::*;
use crate::value::{NodeValue, NodeValueTable, ValueType};
use oak_core::Rational;
#[test]
fn input_names() {
let n = InvertNode;
assert_eq!(n.input_name(TEXTURE_INPUT), "Input");
assert_eq!(n.input_name(INVERT_R_INPUT), "Invert Red");
assert_eq!(n.input_name(INVERT_G_INPUT), "Invert Green");
assert_eq!(n.input_name(INVERT_B_INPUT), "Invert Blue");
assert_eq!(n.input_name(INVERT_A_INPUT), "Invert Alpha");
assert_eq!(n.input_name("other_in"), "other_in");
}
#[test]
fn create_wires_inputs_and_flags() {
let (core, behavior) = create();
assert_eq!(behavior.type_id(), "org.olivevideoeditor.Olive.invert");
assert_eq!(behavior.name(), "Invert");
assert_eq!(behavior.categories(), &[Category::Color]);
let tex = core.get_input(TEXTURE_INPUT).unwrap();
assert_ne!(tex.flags & crate::input::flags::NOT_KEYFRAMABLE, 0);
// The reference defaults every process* toggle to on.
for id in [
INVERT_R_INPUT,
INVERT_G_INPUT,
INVERT_B_INPUT,
INVERT_A_INPUT,
] {
assert_eq!(
core.get_input(id).unwrap().default,
NodeValue::Boolean(true),
"{id} defaults to on"
);
}
assert_eq!(core.effect_input, TEXTURE_INPUT);
assert_ne!(core.flags & crate::node::flags::VIDEO_EFFECT, 0);
}
#[test]
fn value_no_texture_pushes_nothing() {
let (core, behavior) = create();
let mut table = NodeValueTable::default();
behavior.value(
&core,
&crate::value::NodeValueRow::default(),
Rational::new(0, 1),
&mut table,
);
assert!(table.is_empty());
}
#[test]
fn value_with_texture_pushes_shader_job_with_resolved_params() {
let (core, behavior) = create();
let inputs = crate::value::NodeValueRow::from([(
TEXTURE_INPUT.to_string(),
NodeValue::Texture(crate::handle::CHandle::null()),
)]);
let mut table = NodeValueTable::default();
behavior.value(&core, &inputs, Rational::new(0, 1), &mut table);
let Some(NodeValue::Texture(handle)) = table.get(ValueType::Texture) else {
panic!("expected a texture-typed value");
};
let payload =
unsafe { crate::handle::get_checked::<crate::jobs::ShaderJobPayload>(handle) }
.expect("shader job pushed");
assert_eq!(payload.type_id, "org.olivevideoeditor.Olive.invert");
assert_eq!(payload.effect_input, TEXTURE_INPUT);
for id in [
INVERT_R_INPUT,
INVERT_G_INPUT,
INVERT_B_INPUT,
INVERT_A_INPUT,
] {
assert_eq!(payload.params.get(id), Some(&NodeValue::Boolean(true)));
}
}
#[test]
fn value_row_values_win_over_defaults() {
let (mut core, behavior) = create();
core.set_standard_value(INVERT_A_INPUT, -1, NodeValue::Boolean(true));
let inputs = crate::value::NodeValueRow::from([
(
TEXTURE_INPUT.to_string(),
NodeValue::Texture(crate::handle::CHandle::null()),
),
(INVERT_A_INPUT.to_string(), NodeValue::Boolean(false)),
]);
let mut table = NodeValueTable::default();
behavior.value(&core, &inputs, Rational::new(0, 1), &mut table);
let Some(NodeValue::Texture(handle)) = table.get(ValueType::Texture) else {
panic!("expected a texture-typed value");
};
let payload =
unsafe { crate::handle::get_checked::<crate::jobs::ShaderJobPayload>(handle) }
.expect("shader job pushed");
assert_eq!(
payload.params.get(INVERT_A_INPUT),
Some(&NodeValue::Boolean(false))
);
}
#[test]
fn shader_declares_uniforms_and_avoids_switch() {
let code = InvertNode.shader_code("").unwrap();
for uniform in [
"tex_in",
INVERT_R_INPUT,
INVERT_G_INPUT,
INVERT_B_INPUT,
INVERT_A_INPUT,
] {
assert!(code.contains(uniform), "uniform {uniform} declared");
}
assert!(code.contains("ove_texcoord"));
assert!(code.contains("frag_color"));
assert!(!code.contains("switch"), "naga rejects GLSL switch");
}
#[test]
fn duplicate_clones() {
let (core, behavior) = create();
let dup = behavior.duplicate(&core).unwrap();
assert_eq!(dup.name(), "Invert");
assert_eq!(dup.type_id(), "org.olivevideoeditor.Olive.invert");
}
}
crates/oak-node/src/nodes/keymix.rs
+369
View File
@@ -0,0 +1,369 @@
// Oak Video Editor - Non-Linear Video Editor
// Copyright (C) 2026 Oak Team
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//! KeyMix effect (clean-room reimplementation of the OpenFX-Misc
//! `KeyMixOFX` / `net.sf.openfx.KeyMix`; the `KeyMix` reference tree is
//! used for parameter semantics only, no code copied).
//!
//! Upstream copies the foreground over the background wherever the mask
//! is opaque (`ofxsMaskMixPix` with its fixed `mix = 1`): a connected
//! mask paints the foreground through its alpha, an unconnected mask is
//! treated as white and the foreground wins everywhere. This node
//! reduces that to the mask's alpha threshold — `mask.a > 0` takes the
//! blend, else the input — which is the mask-binding piece of the
//! Tier-1 merge group (the mask input mirrors the chroma-key/despill
//! texture binding: a plain not-keyframable texture input).
//!
//! Like [`crate::nodes::merge`], the node never sets a
//! `core.effect_input`; the both-present case boxes one
//! [`ShaderJobPayload`] whose params row carries all three textures, and
//! the renderer binds `tex_in`/`blend_in`/`mask_in` by name (the pass
//! size follows the first bound texture — `blend_in`, the
//! alphabetically first key of the job's `BTreeMap` row).
use crate::factory::NodeMeta;
use crate::jobs::ShaderJobPayload;
use crate::node::{Category, NodeBehavior, NodeCore};
/// Background texture input id. Type: texture; flags: not-keyframable.
pub const TEXTURE_INPUT: &str = "tex_in";
/// Foreground texture input id. Type: texture; flags: not-keyframable.
pub const BLEND_INPUT: &str = "blend_in";
/// Mask texture input id (upstream's mask input, "Mask"). Type:
/// texture; flags: not-keyframable. Its **alpha** selects per pixel
/// (`> 0` keeps the foreground); an unconnected mask selects it
/// everywhere.
pub const MASK_INPUT: &str = "mask_in";
/// KeyMix node. Unit-like: there is no per-instance state.
pub struct KeyMixNode;
/// Fragment shader: copy the blend over the input through the mask's
/// alpha. The `_enabled` flags mirror the alpha-over shader's convention
/// for unbound samplers; the mask one carries upstream's "no mask means
/// white" rule. `switch` is deliberately not used (naga rejects it).
///
/// The ternary is kept off the `texture()` call on purpose (naga's GLSL
/// front end is happiest with the plain-branch spelling), and the
/// `value()` pass-through means the "input missing" branches are only
/// reachable through a direct renderer call.
const SHADER_FRAG: &str = r#"uniform sampler2D tex_in;
uniform sampler2D blend_in;
uniform sampler2D mask_in;
uniform bool tex_in_enabled;
uniform bool blend_in_enabled;
uniform bool mask_in_enabled;
in vec2 ove_texcoord;
out vec4 frag_color;
void main(void) {
if (!tex_in_enabled && !blend_in_enabled) {
frag_color = vec4(0.0);
return;
}
if (!tex_in_enabled) {
frag_color = texture(blend_in, ove_texcoord);
return;
}
if (!blend_in_enabled) {
frag_color = texture(tex_in, ove_texcoord);
return;
}
vec4 tex_col = texture(tex_in, ove_texcoord);
vec4 blend_col = texture(blend_in, ove_texcoord);
// No mask connected: upstream's mask-mix helper sees no mask image
// and uses an opaque one, so the foreground wins everywhere.
vec4 mask_col = vec4(1.0);
if (mask_in_enabled) {
mask_col = texture(mask_in, ove_texcoord);
}
frag_color = mask_col.a > 0.0 ? blend_col : tex_col;
}
"#;
impl KeyMixNode {
/// Fragment shader (single variant, so the request id is ignored).
fn shader_frag() -> &'static str {
SHADER_FRAG
}
}
impl NodeBehavior for KeyMixNode {
/// Human-readable name.
fn name(&self) -> &str {
"KeyMix"
}
/// Stable type id.
fn type_id(&self) -> &str {
"org.olivevideoeditor.Olive.keymix"
}
/// Categories. Filed under math like the alpha-over
/// [`crate::nodes::merge`] (the `Category` enum has no merge group).
fn categories(&self) -> &[Category] {
&[Category::Math]
}
/// Description.
fn description(&self) -> &str {
"Mix two textures by a mask's alpha."
}
/// Localized input names: `tex_in` -> "Input", `blend_in` ->
/// "Blend", `mask_in` -> "Mask".
fn input_name<'a>(&self, id: &'a str) -> &'a str {
match id {
TEXTURE_INPUT => "Input",
BLEND_INPUT => "Blend",
MASK_INPUT => "Mask",
_ => id,
}
}
/// Evaluate outputs: if only one of the two picture textures is
/// present, push it as-is (no mask can conjure the other side);
/// if both are present, push one shader job over the whole input
/// row — the mask rides in the row and may be absent, which the
/// shader reads as fully opaque. If neither picture is present,
/// push nothing.
fn value(
&self,
core: &NodeCore,
inputs: &crate::value::NodeValueRow,
time: oak_core::Rational,
table: &mut crate::value::NodeValueTable,
) {
use crate::value::{NodeValue, ValueType};
let tex = inputs.get(TEXTURE_INPUT);
let blend = inputs.get(BLEND_INPUT);
match (tex, blend) {
(Some(NodeValue::Texture(_)), Some(NodeValue::Texture(_))) => {
table.push(
ValueType::Texture,
NodeValue::Texture(crate::handle::make_owned(ShaderJobPayload {
node_id: crate::id::NodeId::INVALID,
time,
iterations: 1,
type_id: self.type_id().to_string(),
shader_id: String::new(),
effect_input: core.effect_input.clone(),
params: inputs.clone(),
iterative_input: String::new(),
})),
None,
);
}
(Some(t @ NodeValue::Texture(_)), _) => {
table.push(ValueType::Texture, t.clone(), None);
}
(_, Some(b @ NodeValue::Texture(_))) => {
table.push(ValueType::Texture, b.clone(), None);
}
_ => {}
}
}
/// Shader code request: always the mask-copy fragment source.
fn shader_code(&self, _request: &str) -> Option<String> {
Some(Self::shader_frag().to_string())
}
/// Deep copy.
fn duplicate(&self, _core: &NodeCore) -> Option<Box<dyn NodeBehavior>> {
Some(Box::new(KeyMixNode))
}
}
/// Constructor: adds `tex_in`, `blend_in` and `mask_in` as
/// not-keyframable texture inputs and sets the video-effect flag (no
/// effect input: every texture binds by name).
pub fn create() -> (NodeCore, Box<dyn NodeBehavior>) {
let mut core = NodeCore::new();
for id in [TEXTURE_INPUT, BLEND_INPUT, MASK_INPUT] {
let mut input = crate::input::Input::new(
id,
crate::value::ValueType::Texture,
crate::value::NodeValue::None,
);
input.flags |= crate::input::flags::NOT_KEYFRAMABLE;
core.add_input(input);
}
core.flags |= crate::node::flags::VIDEO_EFFECT;
(core, Box::new(KeyMixNode))
}
#[cfg(test)]
mod tests {
use super::*;
use crate::value::{NodeValue, NodeValueTable, ValueType};
use oak_core::Rational;
fn tex() -> NodeValue {
NodeValue::Texture(crate::handle::CHandle::null())
}
fn run(core: &NodeCore, inputs: &crate::value::NodeValueRow) -> ShaderJobPayload {
let behavior = KeyMixNode;
let mut table = NodeValueTable::default();
behavior.value(core, inputs, Rational::new(0, 1), &mut table);
let Some(NodeValue::Texture(h)) = table.get(ValueType::Texture) else {
panic!("shader job expected");
};
unsafe { crate::handle::get_checked::<ShaderJobPayload>(h) }
.expect("shader job payload boxed")
.clone()
}
#[test]
fn input_names() {
let n = KeyMixNode;
assert_eq!(n.input_name(TEXTURE_INPUT), "Input");
assert_eq!(n.input_name(BLEND_INPUT), "Blend");
assert_eq!(n.input_name(MASK_INPUT), "Mask");
assert_eq!(n.input_name("other"), "other");
}
#[test]
fn create_wires_inputs_and_flags() {
let (core, behavior) = create();
assert_eq!(behavior.type_id(), "org.olivevideoeditor.Olive.keymix");
assert_eq!(behavior.name(), "KeyMix");
assert_eq!(behavior.categories(), &[Category::Math]);
assert_ne!(core.flags & crate::node::flags::VIDEO_EFFECT, 0);
assert_eq!(core.effect_input, "");
for id in [TEXTURE_INPUT, BLEND_INPUT, MASK_INPUT] {
let input = core.get_input(id).expect("texture input");
assert_eq!(input.value_type, ValueType::Texture);
assert_ne!(input.flags & crate::input::flags::NOT_KEYFRAMABLE, 0);
}
}
#[test]
fn value_no_texture_pushes_nothing() {
let (core, behavior) = create();
let mut table = NodeValueTable::default();
behavior.value(
&core,
&crate::value::NodeValueRow::default(),
Rational::new(0, 1),
&mut table,
);
assert!(table.is_empty());
}
#[test]
fn value_tex_only_pushes_tex() {
let (core, behavior) = create();
let input = tex();
let inputs = crate::value::NodeValueRow::from([(TEXTURE_INPUT.to_string(), input.clone())]);
let mut table = NodeValueTable::default();
behavior.value(&core, &inputs, Rational::new(0, 1), &mut table);
assert_eq!(table.get(ValueType::Texture), Some(&input));
}
#[test]
fn value_blend_only_pushes_blend() {
let (core, behavior) = create();
let blend = tex();
let inputs = crate::value::NodeValueRow::from([(BLEND_INPUT.to_string(), blend.clone())]);
let mut table = NodeValueTable::default();
behavior.value(&core, &inputs, Rational::new(0, 1), &mut table);
assert_eq!(table.get(ValueType::Texture), Some(&blend));
}
#[test]
fn value_mask_only_pushes_nothing() {
let (core, behavior) = create();
let inputs = crate::value::NodeValueRow::from([(MASK_INPUT.to_string(), tex())]);
let mut table = NodeValueTable::default();
behavior.value(&core, &inputs, Rational::new(0, 1), &mut table);
assert!(table.is_empty());
}
#[test]
fn value_both_pushes_job_payload_with_mask() {
let (core, _) = create();
let inputs = crate::value::NodeValueRow::from([
(TEXTURE_INPUT.to_string(), tex()),
(BLEND_INPUT.to_string(), tex()),
(MASK_INPUT.to_string(), tex()),
]);
let payload = run(&core, &inputs);
assert_eq!(payload.type_id, "org.olivevideoeditor.Olive.keymix");
assert_eq!(payload.shader_id, "");
assert_eq!(payload.iterations, 1);
assert_eq!(payload.iterative_input, "");
assert!(payload.params.contains_key(TEXTURE_INPUT));
assert!(payload.params.contains_key(BLEND_INPUT));
assert!(payload.params.contains_key(MASK_INPUT));
}
#[test]
fn value_both_without_mask_still_pushes_job() {
let (core, _) = create();
let inputs = crate::value::NodeValueRow::from([
(TEXTURE_INPUT.to_string(), tex()),
(BLEND_INPUT.to_string(), tex()),
]);
let payload = run(&core, &inputs);
assert!(!payload.params.contains_key(MASK_INPUT));
}
#[test]
fn shader_code_declares_inputs_without_switch() {
let n = KeyMixNode;
let glsl = n.shader_code("").unwrap();
assert!(glsl.contains("uniform sampler2D tex_in;"));
assert!(glsl.contains("uniform sampler2D blend_in;"));
assert!(glsl.contains("uniform sampler2D mask_in;"));
assert!(glsl.contains("uniform bool mask_in_enabled;"));
assert!(glsl.contains("mask_col = vec4(1.0);"));
assert!(glsl.contains("frag_color = mask_col.a > 0.0 ? blend_col : tex_col;"));
assert!(!glsl.contains("switch"));
}
#[test]
fn duplicate_clones_behavior() {
let (core, behavior) = create();
let dup = behavior.duplicate(&core).unwrap();
assert_eq!(dup.name(), "KeyMix");
}
}
/// Register this node type.
pub fn register(meta: &mut Vec<NodeMeta>) {
meta.push(NodeMeta {
type_id: "org.olivevideoeditor.Olive.keymix",
name: "KeyMix",
categories: &[Category::Math],
create,
});
}
crates/oak-node/src/nodes/mirror.rs
+339
View File
@@ -0,0 +1,339 @@
// Oak Video Editor - Non-Linear Video Editor
// Copyright (C) 2026 Oak Team
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//! Mirror effect: clean-room reimplementation of the OpenFX-Misc `Mirror`
//! plugin's parameter semantics (upstream github.com/cgvirus/OpenFX-Misc,
//! GPL2; read for behavior only, no upstream code copied).
//!
//! Upstream `Mirror` and this crate's [`super::flipdistortnode`] describe
//! the same operation with the same algebra (mirror the sample
//! coordinates about the frame center), so this node is a thin alias: it
//! reuses the flip fragment shader verbatim through
//! [`super::flipdistortnode::FlipDistortNode`]'s
//! [`NodeBehavior::shader_code`] and only maps its own input names onto
//! the shader's uniforms. No second shader is duplicated.
use crate::factory::NodeMeta;
use crate::jobs::ShaderJobPayload;
use crate::node::{Category, NodeBehavior, NodeCore};
/// Main texture input id. Type: texture; flags: not-keyframable; this is
/// the node's effect input. Same key as the flip node's texture input, so
/// the flip shader's `tex_in` sampler finds it unchanged.
pub const TEXTURE_INPUT: &str = "tex_in";
/// Horizontal mirror input id (upstream `kParamMirrorFlop` "Horizontal
/// (flop)"). Type: bool; default `false`; mirrors left/right.
pub const HORIZONTAL_INPUT: &str = "horizontal_in";
/// Vertical mirror input id (upstream `kParamMirrorFlip` "Vertical
/// (flip)"). Type: bool; default `false`; mirrors top/bottom.
pub const VERTICAL_INPUT: &str = "vertical_in";
/// Mirror node. Mirrors the image horizontally and/or vertically.
pub struct MirrorNode;
impl NodeBehavior for MirrorNode {
/// Human-readable name.
fn name(&self) -> &str {
"Mirror"
}
/// Stable type id.
fn type_id(&self) -> &str {
"org.olivevideoeditor.Olive.mirror"
}
/// Categories.
fn categories(&self) -> &[Category] {
&[Category::Distort]
}
/// Description.
fn description(&self) -> &str {
"Mirrors an image horizontally or vertically"
}
/// Localized input names. The upstream labels name the axis of the
/// flip, so `horizontal_in` (flop, mirrors left/right) is labelled
/// "Horizontal (flop)" and `vertical_in` (flip, mirrors top/bottom)
/// "Vertical (flip)".
fn input_name<'a>(&self, id: &'a str) -> &'a str {
match id {
TEXTURE_INPUT => "Input",
HORIZONTAL_INPUT => "Horizontal (flop)",
VERTICAL_INPUT => "Vertical (flip)",
_ => id,
}
}
/// Evaluate outputs: no texture -> push nothing; neither flag set ->
/// pass-through push of the input texture unchanged; otherwise a shader
/// job running the shared flip fragment shader.
///
/// The job boxes a [`ShaderJobPayload`] whose `type_id` is this node's
/// (so the behavior is looked up here) while its `shader_id` is empty:
/// [`shader_code`](NodeBehavior::shader_code) forwards to the flip
/// node. The params row is the value row with this node's boolean keys
/// renamed to the uniform names the flip shader declares
/// (`horiz_in`/`vert_in`) — the renderer packs uniforms by declared
/// name and silently leaves undeclared ones at 0, so a raw pass-through
/// row would render an unmirrored image.
fn value(
&self,
core: &NodeCore,
inputs: &crate::value::NodeValueRow,
time: oak_core::Rational,
table: &mut crate::value::NodeValueTable,
) {
let tex = match inputs.get(TEXTURE_INPUT) {
Some(tex @ crate::value::NodeValue::Texture(_)) => tex.clone(),
_ => return,
};
let horiz = match inputs.get(HORIZONTAL_INPUT) {
Some(v) => v.to_double() != 0.0,
None => core.value_at_time(HORIZONTAL_INPUT, -1, time).to_double() != 0.0,
};
let vert = match inputs.get(VERTICAL_INPUT) {
Some(v) => v.to_double() != 0.0,
None => core.value_at_time(VERTICAL_INPUT, -1, time).to_double() != 0.0,
};
if !horiz && !vert {
table.push(crate::value::ValueType::Texture, tex, None);
return;
}
let mut params = inputs.clone();
params.remove(HORIZONTAL_INPUT);
params.remove(VERTICAL_INPUT);
params.insert(
super::flipdistortnode::HORIZONTAL_INPUT.to_string(),
crate::value::NodeValue::Boolean(horiz),
);
params.insert(
super::flipdistortnode::VERTICAL_INPUT.to_string(),
crate::value::NodeValue::Boolean(vert),
);
table.push(
crate::value::ValueType::Texture,
crate::value::NodeValue::Texture(crate::handle::make_owned(ShaderJobPayload {
node_id: crate::id::NodeId::INVALID,
time,
iterations: 1,
type_id: self.type_id().to_string(),
shader_id: String::new(),
effect_input: core.effect_input.clone(),
params,
iterative_input: TEXTURE_INPUT.to_string(),
})),
None,
);
}
/// Shader code request: delegates to the flip node's shader (the flip
/// request id is ignored there — it has a single shader variant).
fn shader_code(&self, request: &str) -> Option<String> {
super::flipdistortnode::FlipDistortNode.shader_code(request)
}
/// Deep copy.
fn duplicate(&self, _core: &NodeCore) -> Option<Box<dyn NodeBehavior>> {
Some(Box::new(MirrorNode))
}
}
/// Constructor: adds `tex_in`, `horizontal_in` and `vertical_in` with the
/// defaults and flags documented on the constants, sets the video-effect
/// flag and the effect input.
pub fn create() -> (NodeCore, Box<dyn NodeBehavior>) {
let mut core = NodeCore::new();
let mut tex = crate::input::Input::new(
TEXTURE_INPUT,
crate::value::ValueType::Texture,
crate::value::NodeValue::None,
);
tex.flags |= crate::input::flags::NOT_KEYFRAMABLE;
core.add_input(tex);
core.add_input(crate::input::Input::new(
HORIZONTAL_INPUT,
crate::value::ValueType::Boolean,
crate::value::NodeValue::Boolean(false),
));
core.add_input(crate::input::Input::new(
VERTICAL_INPUT,
crate::value::ValueType::Boolean,
crate::value::NodeValue::Boolean(false),
));
core.flags |= crate::node::flags::VIDEO_EFFECT;
core.effect_input = TEXTURE_INPUT.to_string();
(core, Box::new(MirrorNode))
}
#[cfg(test)]
mod tests {
use super::*;
use crate::node::NodeBehavior;
use crate::value::{NodeValue, NodeValueRow, NodeValueTable, ValueType};
use oak_core::Rational;
fn tex() -> NodeValue {
NodeValue::Texture(crate::handle::CHandle::null())
}
#[test]
fn input_names() {
let n = MirrorNode;
assert_eq!(n.input_name(TEXTURE_INPUT), "Input");
assert_eq!(n.input_name(HORIZONTAL_INPUT), "Horizontal (flop)");
assert_eq!(n.input_name(VERTICAL_INPUT), "Vertical (flip)");
assert_eq!(n.input_name("other_in"), "other_in");
}
#[test]
fn create_wires_inputs_and_flags() {
let (core, behavior) = create();
assert_eq!(behavior.type_id(), "org.olivevideoeditor.Olive.mirror");
assert_eq!(
core.get_input(HORIZONTAL_INPUT).unwrap().default,
NodeValue::Boolean(false)
);
assert_eq!(
core.get_input(VERTICAL_INPUT).unwrap().default,
NodeValue::Boolean(false)
);
assert_ne!(
core.get_input(TEXTURE_INPUT).unwrap().flags & crate::input::flags::NOT_KEYFRAMABLE,
0
);
assert_eq!(core.effect_input, TEXTURE_INPUT);
assert_ne!(core.flags & crate::node::flags::VIDEO_EFFECT, 0);
}
#[test]
fn value_no_texture_pushes_nothing() {
let (core, behavior) = create();
let mut table = NodeValueTable::default();
behavior.value(
&core,
&NodeValueRow::default(),
Rational::new(0, 1),
&mut table,
);
assert!(table.is_empty());
}
#[test]
fn value_no_mirror_passes_texture_through() {
let (core, behavior) = create();
let tex = tex();
let inputs = NodeValueRow::from([(TEXTURE_INPUT.to_string(), tex.clone())]);
let mut table = NodeValueTable::default();
behavior.value(&core, &inputs, Rational::new(0, 1), &mut table);
assert_eq!(table.get(ValueType::Texture), Some(&tex));
}
#[test]
fn value_translates_flag_names_to_the_flip_uniforms() {
let (core, behavior) = create();
let inputs = NodeValueRow::from([
(TEXTURE_INPUT.to_string(), tex()),
(HORIZONTAL_INPUT.to_string(), NodeValue::Boolean(true)),
(VERTICAL_INPUT.to_string(), NodeValue::Boolean(false)),
]);
let mut table = NodeValueTable::default();
behavior.value(&core, &inputs, Rational::new(0, 1), &mut table);
let handle = match table.get(ValueType::Texture) {
Some(NodeValue::Texture(h)) => *h,
_ => panic!("texture expected"),
};
let payload = unsafe { crate::handle::get_checked::<ShaderJobPayload>(&handle) }
.expect("shader job payload expected");
assert_eq!(payload.type_id, "org.olivevideoeditor.Olive.mirror");
assert_eq!(payload.shader_id, "");
assert_eq!(payload.iterations, 1);
assert_eq!(payload.effect_input, TEXTURE_INPUT);
assert_eq!(payload.iterative_input, TEXTURE_INPUT);
// The shader reads `horiz_in`/`vert_in`; the node's own keys are gone.
assert_eq!(
payload
.params
.get(super::super::flipdistortnode::HORIZONTAL_INPUT),
Some(&NodeValue::Boolean(true))
);
assert_eq!(
payload
.params
.get(super::super::flipdistortnode::VERTICAL_INPUT),
Some(&NodeValue::Boolean(false))
);
assert!(!payload.params.contains_key(HORIZONTAL_INPUT));
assert!(!payload.params.contains_key(VERTICAL_INPUT));
}
#[test]
fn value_connected_flags_win_over_the_node_values() {
let (mut core, behavior) = create();
core.set_standard_value(HORIZONTAL_INPUT, -1, NodeValue::Boolean(false));
core.set_standard_value(VERTICAL_INPUT, -1, NodeValue::Boolean(true));
let inputs = NodeValueRow::from([
(TEXTURE_INPUT.to_string(), tex()),
(VERTICAL_INPUT.to_string(), NodeValue::Boolean(false)),
]);
let mut table = NodeValueTable::default();
behavior.value(&core, &inputs, Rational::new(0, 1), &mut table);
// The row's false for vertical wins over the node's true, so both
// flags are off and the texture passes through unmirrored.
match table.get(ValueType::Texture) {
Some(NodeValue::Texture(h)) => assert!(h.is_null()),
other => panic!("pass-through texture expected, got {other:?}"),
}
}
#[test]
fn shader_code_returns_the_flip_shader() {
let code = MirrorNode.shader_code("").unwrap();
assert!(code.contains("uniform sampler2D tex_in;"));
assert!(code.contains("uniform bool horiz_in;"));
assert!(code.contains("uniform bool vert_in;"));
assert!(code.contains("if (horiz_in) new_coord.x = 1.0 - new_coord.x;"));
assert!(code.contains("if (vert_in) new_coord.y = 1.0 - new_coord.y;"));
assert!(!code.contains("switch"));
}
#[test]
fn duplicate_clones() {
let (core, behavior) = create();
let dup = behavior.duplicate(&core).unwrap();
assert_eq!(dup.name(), "Mirror");
}
}
/// Register this node type.
pub fn register(meta: &mut Vec<NodeMeta>) {
meta.push(NodeMeta {
type_id: "org.olivevideoeditor.Olive.mirror",
name: "Mirror",
categories: &[Category::Distort],
create,
});
}
crates/oak-node/src/nodes/position.rs
+313
View File
@@ -0,0 +1,313 @@
// Oak Video Editor - Non-Linear Video Editor
// Copyright (C) 2026 Oak Team
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//! Position effect: clean-room reimplementation of the OpenFX-Misc
//! `Position` plugin's parameter semantics (upstream
//! github.com/cgvirus/OpenFX-Misc, GPL2; read for behavior only, no
//! upstream code copied).
use crate::factory::NodeMeta;
use crate::jobs::ShaderJobPayload;
use crate::node::{Category, NodeBehavior, NodeCore};
/// Main texture input id (upstream `PositionPlugin`'s image input). Type:
/// texture; flags: not-keyframable; this is the node's effect input.
pub const TEXTURE_INPUT: &str = "tex_in";
/// Translate input id (upstream `kParamTranslate` "Translate"). Type:
/// vec2; default `[0.0, 0.0]`; units: whole pixels of the center-origin
/// pixel space (see the shader note). Not clamped.
pub const OFFSET_INPUT: &str = "offset_in";
/// Position node. Translates the input image by a whole-pixel offset.
/// Has no own member fields in C++ (state lives in the `Node` inputs).
pub struct PositionNode;
/// Fragment shader. The sampling is the inverse of the visual offset:
/// the output pixel at center-origin `px` reads the source at
/// `px - offset`, so the image content moves by `+offset` on screen.
///
/// Pixel space: `ove_texcoord * resolution_in - resolution_in * 0.5`,
/// i.e. the center-origin pixel coordinates used by
/// [`super::transformdistortnode`]. This crate's frame rows run top to
/// bottom, so `+y` moves the image DOWN — the opposite screen direction
/// of the upstream OFX plugin, whose y axis points up (upstream hints
/// the new position of the "bottom-left pixel"). The offset is rounded
/// with the upstream integer rounding, `floor(x + 0.5)`.
///
/// There is deliberately no identity fast path: an all-zero offset still
/// runs the shader pass (the upstream plugin does the same).
const SHADER_FRAG: &str = r#"uniform sampler2D tex_in;
uniform vec2 offset_in;
uniform vec2 resolution_in;
in vec2 ove_texcoord;
out vec4 frag_color;
void main(void) {
vec2 half_res = resolution_in * 0.5;
vec2 px = ove_texcoord * resolution_in - half_res;
vec2 offset = floor(offset_in + 0.5);
frag_color = texture(tex_in, (px - offset + half_res) / resolution_in);
}
"#;
impl PositionNode {
/// Fragment shader (the node has a single shader variant).
fn shader_frag() -> &'static str {
SHADER_FRAG
}
}
impl NodeBehavior for PositionNode {
/// Human-readable name.
fn name(&self) -> &str {
"Position"
}
/// Stable type id.
fn type_id(&self) -> &str {
"org.olivevideoeditor.Olive.position"
}
/// Categories.
fn categories(&self) -> &[Category] {
&[Category::Distort]
}
/// Description.
fn description(&self) -> &str {
"Translate an image by a whole-pixel offset."
}
/// Localized input names: `tex_in` -> "Input", `offset_in` ->
/// "Translate".
fn input_name<'a>(&self, id: &'a str) -> &'a str {
match id {
TEXTURE_INPUT => "Input",
OFFSET_INPUT => "Translate",
_ => id,
}
}
/// Evaluate outputs: no texture -> push nothing; otherwise a shader
/// job over the whole value row, translating the sampled coordinates
/// by `offset_in` whole pixels.
///
/// The job boxes a [`ShaderJobPayload`] that the renderer's resolve
/// hook executes and replaces with the result texture; the params row
/// carries the input texture and the uniforms, keyed by the effect
/// input. `resolution_in` is filled by the runner, so it is not part
/// of the params here.
fn value(
&self,
core: &NodeCore,
inputs: &crate::value::NodeValueRow,
time: oak_core::Rational,
table: &mut crate::value::NodeValueTable,
) {
if !matches!(inputs.get(TEXTURE_INPUT), Some(crate::value::NodeValue::Texture(_))) {
return;
}
// The offset is part of the row in the traverser flow (the bare key
// is always inserted for an unconnected input); fall back to the
// node's own value for direct `value()` calls.
let mut params = inputs.clone();
if !params.contains_key(OFFSET_INPUT) {
params.insert(
OFFSET_INPUT.to_string(),
core.value_at_time(OFFSET_INPUT, -1, time),
);
}
table.push(
crate::value::ValueType::Texture,
crate::value::NodeValue::Texture(crate::handle::make_owned(ShaderJobPayload {
node_id: crate::id::NodeId::INVALID,
time,
iterations: 1,
type_id: self.type_id().to_string(),
shader_id: String::new(),
effect_input: core.effect_input.clone(),
params,
iterative_input: TEXTURE_INPUT.to_string(),
})),
None,
);
}
/// Shader code request: the node has a single shader variant, so the
/// request id is ignored.
fn shader_code(&self, _request: &str) -> Option<String> {
Some(Self::shader_frag().to_string())
}
/// Deep copy.
fn duplicate(&self, _core: &NodeCore) -> Option<Box<dyn NodeBehavior>> {
Some(Box::new(PositionNode))
}
}
/// Constructor: adds `tex_in` and `offset_in` with the defaults and flags
/// documented on the constants, sets the video-effect flag and the effect
/// input.
pub fn create() -> (NodeCore, Box<dyn NodeBehavior>) {
let mut core = NodeCore::new();
let mut tex = crate::input::Input::new(
TEXTURE_INPUT,
crate::value::ValueType::Texture,
crate::value::NodeValue::None,
);
tex.flags |= crate::input::flags::NOT_KEYFRAMABLE;
core.add_input(tex);
core.add_input(crate::input::Input::new(
OFFSET_INPUT,
crate::value::ValueType::Vec2,
crate::value::NodeValue::Vec2([0.0, 0.0]),
));
core.flags |= crate::node::flags::VIDEO_EFFECT;
core.effect_input = TEXTURE_INPUT.to_string();
(core, Box::new(PositionNode))
}
#[cfg(test)]
mod tests {
use super::*;
use crate::node::NodeBehavior;
use crate::value::{NodeValue, NodeValueRow, NodeValueTable, ValueType};
use oak_core::Rational;
fn tex() -> NodeValue {
NodeValue::Texture(crate::handle::CHandle::null())
}
#[test]
fn input_names() {
let n = PositionNode;
assert_eq!(n.input_name(TEXTURE_INPUT), "Input");
assert_eq!(n.input_name(OFFSET_INPUT), "Translate");
assert_eq!(n.input_name("other_in"), "other_in");
}
#[test]
fn create_wires_inputs_and_flags() {
let (core, behavior) = create();
assert_eq!(behavior.type_id(), "org.olivevideoeditor.Olive.position");
assert_eq!(
core.get_input(OFFSET_INPUT).unwrap().default,
NodeValue::Vec2([0.0, 0.0])
);
assert_ne!(
core.get_input(TEXTURE_INPUT).unwrap().flags & crate::input::flags::NOT_KEYFRAMABLE,
0
);
assert_eq!(core.effect_input, TEXTURE_INPUT);
assert_ne!(core.flags & crate::node::flags::VIDEO_EFFECT, 0);
}
#[test]
fn value_no_texture_pushes_nothing() {
let (core, behavior) = create();
let mut table = NodeValueTable::default();
behavior.value(
&core,
&NodeValueRow::default(),
Rational::new(0, 1),
&mut table,
);
assert!(table.is_empty());
}
#[test]
fn value_pushes_shader_job_payload() {
let (core, behavior) = create();
let inputs = NodeValueRow::from([(TEXTURE_INPUT.to_string(), tex())]);
let mut table = NodeValueTable::default();
behavior.value(&core, &inputs, Rational::new(0, 1), &mut table);
let handle = match table.get(ValueType::Texture) {
Some(NodeValue::Texture(h)) => *h,
_ => panic!("texture expected"),
};
let payload = unsafe { crate::handle::get_checked::<ShaderJobPayload>(&handle) }
.expect("shader job payload expected");
assert_eq!(payload.type_id, "org.olivevideoeditor.Olive.position");
assert_eq!(payload.shader_id, "");
assert_eq!(payload.iterations, 1);
assert_eq!(payload.effect_input, TEXTURE_INPUT);
assert_eq!(payload.iterative_input, TEXTURE_INPUT);
assert_eq!(payload.time, Rational::new(0, 1));
assert!(payload.params.contains_key(TEXTURE_INPUT));
// The offset is not in the row: it resolves from the node default.
assert_eq!(
payload.params.get(OFFSET_INPUT),
Some(&NodeValue::Vec2([0.0, 0.0]))
);
}
#[test]
fn value_row_offset_wins_over_the_node_value() {
let (core, behavior) = create();
let inputs = NodeValueRow::from([
(TEXTURE_INPUT.to_string(), tex()),
(OFFSET_INPUT.to_string(), NodeValue::Vec2([3.0, 2.0])),
]);
let mut table = NodeValueTable::default();
behavior.value(&core, &inputs, Rational::new(0, 1), &mut table);
let handle = match table.get(ValueType::Texture) {
Some(NodeValue::Texture(h)) => *h,
_ => panic!("texture expected"),
};
let payload = unsafe { crate::handle::get_checked::<ShaderJobPayload>(&handle) }
.expect("shader job payload expected");
assert_eq!(
payload.params.get(OFFSET_INPUT),
Some(&NodeValue::Vec2([3.0, 2.0]))
);
}
#[test]
fn shader_declares_the_uniforms_it_reads() {
let code = PositionNode.shader_code("").unwrap();
assert!(code.contains("uniform sampler2D tex_in;"));
assert!(code.contains("uniform vec2 offset_in;"));
assert!(code.contains("uniform vec2 resolution_in;"));
assert!(code.contains("frag_color = texture(tex_in, (px - offset + half_res) / resolution_in);"));
assert!(!code.contains("switch"));
}
#[test]
fn duplicate_clones() {
let (core, behavior) = create();
let dup = behavior.duplicate(&core).unwrap();
assert_eq!(dup.name(), "Position");
}
}
/// Register this node type.
pub fn register(meta: &mut Vec<NodeMeta>) {
meta.push(NodeMeta {
type_id: "org.olivevideoeditor.Olive.position",
name: "Position",
categories: &[Category::Distort],
create,
});
}
crates/oak-node/src/nodes/premult.rs
+381
View File
@@ -0,0 +1,381 @@
// Oak Video Editor - Non-Linear Video Editor
// Copyright (C) 2026 Oak Team
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//! Premultiply effect (clean-room reimplementation of the OpenFX-Misc
//! `PremultOFX` / `net.sf.openfx.PremultPlugin`; the `Premult` reference
//! tree is used for parameter semantics only, no code copied).
//!
//! Upstream scales each channel by a chosen channel of the source —
//! `dst = src * alpha` for the usual full-alpha premultiply, with the
//! per-channel `process R/G/B/A` toggles and the multiplane premult
//! channel choice as the knobs (`// CPP-PARITY: Premult.cpp`). This node
//! keeps the channel-selection core: the RGB channels are scaled by the
//! channel picked in [`CHANNEL_INPUT`] (default [`Channel::Alpha`]), and
//! the source alpha rides through untouched.
//!
//! Single texture input, so `core.effect_input` is set to
//! [`TEXTURE_INPUT`] (the despill node's shape) and the job binds that
//! one sampler by name.
use crate::factory::NodeMeta;
use crate::jobs::ShaderJobPayload;
use crate::node::{Category, NodeBehavior, NodeCore};
/// Texture input id. Type: texture; flags: not-keyframable; this is the
/// node's effect input.
pub const TEXTURE_INPUT: &str = "tex_in";
/// Channel selector input id (upstream's "premult channel" choice). Type:
/// combo; default [`Channel::Alpha`] (`Combo(4)`); flags:
/// not-connectable, not-keyframable. Combo strings: "None", "R", "G",
/// "B", "A".
pub const CHANNEL_INPUT: &str = "premult_channel_in";
/// Channel selector values for [`CHANNEL_INPUT`], in combo order. The
/// numeric values are the shader's channel indices: `0` selects nothing
/// (the image passes through — a factor of 1) and `1..=4` select
/// `r`/`g`/`b`/`a`.
#[repr(i64)]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Channel {
/// No channel: the image is left unchanged.
None = 0,
/// Red channel.
Red = 1,
/// Green channel.
Green = 2,
/// Blue channel.
Blue = 3,
/// Alpha channel (the default multiply factor).
Alpha = 4,
}
/// Premultiply node. Unit-like: there is no per-instance state.
pub struct PremultiplyNode;
/// Fragment shader: `rgb *= selected_channel`. The channel dispatch is an
/// if/else chain and not a `switch` (naga rejects the latter); an
/// out-of-range selector falls back to a factor of 1, the "None" combo
/// entry. No `tex_in_enabled` flag is declared: with a single texture
/// input the sampler is either bound or the job never runs (`value()`
/// requires the texture), and the despill node's shader has the same
/// shape.
const SHADER_FRAG: &str = r#"uniform sampler2D tex_in;
uniform int premult_channel_in;
in vec2 ove_texcoord;
out vec4 frag_color;
float selected_channel(vec4 col, int channel) {
if (channel == 1) {
return col.r;
} else if (channel == 2) {
return col.g;
} else if (channel == 3) {
return col.b;
} else if (channel == 4) {
return col.a;
}
return 1.0;
}
void main(void) {
vec4 col = texture(tex_in, ove_texcoord);
float factor = selected_channel(col, premult_channel_in);
frag_color = vec4(col.rgb * factor, col.a);
}
"#;
impl PremultiplyNode {
/// Fragment shader (single variant, so the request id is ignored).
fn shader_frag() -> &'static str {
SHADER_FRAG
}
}
impl NodeBehavior for PremultiplyNode {
/// Human-readable name.
fn name(&self) -> &str {
"Premultiply"
}
/// Stable type id.
fn type_id(&self) -> &str {
"org.olivevideoeditor.Olive.premult"
}
/// Categories. Filed under math like the alpha-over
/// [`crate::nodes::merge`] (the `Category` enum has no merge group).
fn categories(&self) -> &[Category] {
&[Category::Math]
}
/// Description.
fn description(&self) -> &str {
"Multiply the RGB channels by a selected channel."
}
/// Localized input names: `tex_in` -> "Input", `premult_channel_in`
/// -> "Channel".
fn input_name<'a>(&self, id: &'a str) -> &'a str {
match id {
TEXTURE_INPUT => "Input",
CHANNEL_INPUT => "Channel",
_ => id,
}
}
/// Combo input option labels: `premult_channel_in` -> "None", "R",
/// "G", "B", "A" (the [`Channel`] order).
fn input_combo_strings(&self, id: &str) -> Vec<&'static str> {
match id {
CHANNEL_INPUT => vec!["None", "R", "G", "B", "A"],
_ => Vec::new(),
}
}
/// Evaluate outputs: with no texture there is nothing to premultiply;
/// otherwise push one shader job over the whole input row, with the
/// resolved channel selector written in so the uniform is always
/// present even when the incoming row only carries the texture (the
/// row/standard-value split mirrors the directional-blur node).
fn value(
&self,
core: &NodeCore,
inputs: &crate::value::NodeValueRow,
time: oak_core::Rational,
table: &mut crate::value::NodeValueTable,
) {
use crate::value::{NodeValue, ValueType};
match inputs.get(TEXTURE_INPUT) {
Some(NodeValue::Texture(_)) => {}
_ => return,
}
let channel = match inputs.get(CHANNEL_INPUT) {
Some(v) => v.clone(),
None => core.value_at_time(CHANNEL_INPUT, -1, time),
};
let mut params = inputs.clone();
params.insert(CHANNEL_INPUT.to_string(), channel);
table.push(
ValueType::Texture,
NodeValue::Texture(crate::handle::make_owned(ShaderJobPayload {
node_id: crate::id::NodeId::INVALID,
time,
iterations: 1,
type_id: self.type_id().to_string(),
shader_id: String::new(),
effect_input: core.effect_input.clone(),
params,
iterative_input: String::new(),
})),
None,
);
}
/// Shader code request: always the premultiply fragment source.
fn shader_code(&self, _request: &str) -> Option<String> {
Some(Self::shader_frag().to_string())
}
/// Deep copy.
fn duplicate(&self, _core: &NodeCore) -> Option<Box<dyn NodeBehavior>> {
Some(Box::new(PremultiplyNode))
}
}
/// Constructor: adds `tex_in` (not-keyframable) and `premult_channel_in`
/// (combo, default alpha), sets the video-effect flag and makes `tex_in`
/// the effect input.
pub fn create() -> (NodeCore, Box<dyn NodeBehavior>) {
let mut core = NodeCore::new();
let mut tex = crate::input::Input::new(
TEXTURE_INPUT,
crate::value::ValueType::Texture,
crate::value::NodeValue::None,
);
tex.flags |= crate::input::flags::NOT_KEYFRAMABLE;
core.add_input(tex);
let mut channel = crate::input::Input::new(
CHANNEL_INPUT,
crate::value::ValueType::Combo,
crate::value::NodeValue::Combo(Channel::Alpha as i64),
);
channel.flags |= crate::input::flags::NOT_CONNECTABLE | crate::input::flags::NOT_KEYFRAMABLE;
core.add_input(channel);
core.flags |= crate::node::flags::VIDEO_EFFECT;
core.effect_input = TEXTURE_INPUT.to_string();
(core, Box::new(PremultiplyNode))
}
#[cfg(test)]
mod tests {
use super::*;
use crate::value::{NodeValue, NodeValueTable, ValueType};
use oak_core::Rational;
fn tex() -> NodeValue {
NodeValue::Texture(crate::handle::CHandle::null())
}
fn run(core: &NodeCore, inputs: &crate::value::NodeValueRow) -> ShaderJobPayload {
let behavior = PremultiplyNode;
let mut table = NodeValueTable::default();
behavior.value(core, inputs, Rational::new(0, 1), &mut table);
let Some(NodeValue::Texture(h)) = table.get(ValueType::Texture) else {
panic!("shader job expected");
};
unsafe { crate::handle::get_checked::<ShaderJobPayload>(h) }
.expect("shader job payload boxed")
.clone()
}
#[test]
fn input_names() {
let n = PremultiplyNode;
assert_eq!(n.input_name(TEXTURE_INPUT), "Input");
assert_eq!(n.input_name(CHANNEL_INPUT), "Channel");
assert_eq!(n.input_name("other"), "other");
}
#[test]
fn combo_strings_match_channel_values() {
let n = PremultiplyNode;
let strings = n.input_combo_strings(CHANNEL_INPUT);
assert_eq!(strings, vec!["None", "R", "G", "B", "A"]);
assert_eq!(Channel::None as i64, 0);
assert_eq!(Channel::Red as i64, 1);
assert_eq!(Channel::Green as i64, 2);
assert_eq!(Channel::Blue as i64, 3);
assert_eq!(Channel::Alpha as i64, 4);
assert!(n.input_combo_strings("other").is_empty());
}
#[test]
fn create_wires_inputs_flags_and_defaults() {
let (core, behavior) = create();
assert_eq!(behavior.type_id(), "org.olivevideoeditor.Olive.premult");
assert_eq!(behavior.name(), "Premultiply");
assert_eq!(behavior.categories(), &[Category::Math]);
assert_ne!(core.flags & crate::node::flags::VIDEO_EFFECT, 0);
assert_eq!(core.effect_input, TEXTURE_INPUT);
let tex_input = core.get_input(TEXTURE_INPUT).expect("texture input");
assert_eq!(tex_input.value_type, ValueType::Texture);
assert_ne!(tex_input.flags & crate::input::flags::NOT_KEYFRAMABLE, 0);
let channel = core.get_input(CHANNEL_INPUT).expect("channel input");
assert_eq!(channel.value_type, ValueType::Combo);
assert_eq!(channel.default, NodeValue::Combo(Channel::Alpha as i64));
assert_ne!(channel.flags & crate::input::flags::NOT_CONNECTABLE, 0);
assert_ne!(channel.flags & crate::input::flags::NOT_KEYFRAMABLE, 0);
}
#[test]
fn value_no_texture_pushes_nothing() {
let (core, behavior) = create();
let mut table = NodeValueTable::default();
behavior.value(
&core,
&crate::value::NodeValueRow::default(),
Rational::new(0, 1),
&mut table,
);
assert!(table.is_empty());
}
#[test]
fn value_with_texture_defaults_channel_to_alpha() {
let (core, _) = create();
let inputs = crate::value::NodeValueRow::from([(TEXTURE_INPUT.to_string(), tex())]);
let payload = run(&core, &inputs);
assert_eq!(payload.type_id, "org.olivevideoeditor.Olive.premult");
assert_eq!(payload.shader_id, "");
assert_eq!(payload.iterations, 1);
assert_eq!(payload.iterative_input, "");
assert_eq!(payload.effect_input, TEXTURE_INPUT);
assert_eq!(
payload.params.get(CHANNEL_INPUT),
Some(&NodeValue::Combo(Channel::Alpha as i64)),
"the default channel rides in the job params"
);
}
#[test]
fn value_takes_channel_from_row() {
let (core, _) = create();
let inputs = crate::value::NodeValueRow::from([
(TEXTURE_INPUT.to_string(), tex()),
(
CHANNEL_INPUT.to_string(),
NodeValue::Combo(Channel::Red as i64),
),
]);
let payload = run(&core, &inputs);
assert_eq!(
payload.params.get(CHANNEL_INPUT),
Some(&NodeValue::Combo(Channel::Red as i64))
);
}
#[test]
fn value_takes_channel_from_core() {
let (mut core, _) = create();
core.set_standard_value(CHANNEL_INPUT, -1, NodeValue::Combo(Channel::Green as i64));
let inputs = crate::value::NodeValueRow::from([(TEXTURE_INPUT.to_string(), tex())]);
let payload = run(&core, &inputs);
assert_eq!(
payload.params.get(CHANNEL_INPUT),
Some(&NodeValue::Combo(Channel::Green as i64))
);
}
#[test]
fn shader_code_declares_inputs_without_switch() {
let n = PremultiplyNode;
let glsl = n.shader_code("").unwrap();
assert!(glsl.contains("uniform sampler2D tex_in;"));
assert!(glsl.contains("uniform int premult_channel_in;"));
assert!(glsl.contains("frag_color = vec4(col.rgb * factor, col.a);"));
assert!(!glsl.contains("switch"));
}
#[test]
fn duplicate_clones_behavior() {
let (core, behavior) = create();
let dup = behavior.duplicate(&core).unwrap();
assert_eq!(dup.name(), "Premultiply");
}
}
/// Register this node type.
pub fn register(meta: &mut Vec<NodeMeta>) {
meta.push(NodeMeta {
type_id: "org.olivevideoeditor.Olive.premult",
name: "Premultiply",
categories: &[Category::Math],
create,
});
}
crates/oak-node/src/nodes/ramp.rs
+406
View File
@@ -0,0 +1,406 @@
// Oak Video Editor - Non-Linear Video Editor
// Copyright (C) 2026 Oak Team
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//! Linear ramp generator: clean-room reimplementation of the OpenFX-Misc
//! `Ramp` plugin's parameter semantics (upstream github.com/cgvirus/
//! OpenFX-Misc, GPL2; read for behavior only, no upstream code copied).
//!
//! Deviations from the upstream plugin: it additionally offers a ramp
//! `type` combo and an `interactive` gizmo switch, neither of which is
//! reproduced here. The upstream parameter descriptors live in
//! `ofxsRamp.h`, which is not part of the reference copy, so the default
//! points below are this node's own choice (a horizontal black-to-white
//! ramp across a 200px-wide frame).
use crate::factory::NodeMeta;
use crate::jobs::ShaderJobPayload;
use crate::node::{Category, NodeBehavior, NodeCore};
/// Base texture input id (the shared generator-with-merge base). Type:
/// texture; flags: not-keyframable; this is the generator's effect input.
pub const BASE_INPUT: &str = super::generatorwithmerge::BASE_INPUT;
/// First point input id (upstream `kParamPoint0` "Point 0"). Type: vec2;
/// default `[-100.0, 0.0]`; units: pixels of the center-origin pixel
/// space (see the shader note).
pub const POINT0_INPUT: &str = "point0_in";
/// Second point input id (upstream `kParamPoint1` "Point 1"). Type: vec2;
/// default `[100.0, 0.0]`; units: pixels of the center-origin pixel
/// space.
pub const POINT1_INPUT: &str = "point1_in";
/// First color input id (upstream `kParamColor0`). Type: color; default
/// `[0.0, 0.0, 0.0, 1.0]` (black); properties: `view = color`.
pub const COLOR0_INPUT: &str = "color0_in";
/// Second color input id (upstream `kParamColor1`). Type: color; default
/// `[1.0, 1.0, 1.0, 1.0]` (white); properties: `view = color`.
pub const COLOR1_INPUT: &str = "color1_in";
/// Linear ramp generator node.
pub struct RampNode;
/// Fragment shader for the `"ramp"` shader id.
///
/// The gradient parameter `t` is the projection of the pixel onto the
/// `point0_in -> point1_in` axis: `t = dot(px - point0, d) / dot(d, d)`
/// with `d = point1 - point0`, exactly the upstream ramp function. `t`
/// is not clamped, so values outside the `[0, 1]` span extrapolate the
/// gradient past the endpoint colors (the upstream linear type does the
/// same); a degenerate axis (`point0 == point1`) leaves `t = 0`.
///
/// Pixel space: `ove_texcoord * resolution_in - resolution_in * 0.5`,
/// i.e. the center-origin pixel coordinates used by
/// [`super::transformdistortnode`], with y running downward.
const SHADER_FRAG: &str = r#"uniform vec2 resolution_in;
uniform vec2 point0_in;
uniform vec2 point1_in;
uniform vec4 color0_in;
uniform vec4 color1_in;
in vec2 ove_texcoord;
out vec4 frag_color;
void main(void) {
vec2 px = ove_texcoord * resolution_in - resolution_in * 0.5;
vec2 d = point1_in - point0_in;
float norm2 = dot(d, d);
float t = 0.0;
if (norm2 > 0.0) {
t = dot(px - point0_in, d) / norm2;
}
frag_color = color0_in * (1.0 - t) + color1_in * t;
}
"#;
impl RampNode {
/// Fragment shader for the `"ramp"` request.
fn shader_frag() -> &'static str {
SHADER_FRAG
}
}
impl NodeBehavior for RampNode {
/// Human-readable name.
fn name(&self) -> &str {
"Ramp"
}
/// Stable type id.
fn type_id(&self) -> &str {
"org.olivevideoeditor.Olive.ramp"
}
/// Categories.
fn categories(&self) -> &[Category] {
&[Category::Generator]
}
/// Description.
fn description(&self) -> &str {
"Generate a linear color ramp between two points."
}
/// Localized input names: the merge base's `base_in` -> "Base" plus
/// `point0_in` -> "Point 0", `point1_in` -> "Point 1", `color0_in` ->
/// "Color 0", `color1_in` -> "Color 1".
fn input_name<'a>(&self, id: &'a str) -> &'a str {
match id {
BASE_INPUT => "Base",
POINT0_INPUT => "Point 0",
POINT1_INPUT => "Point 1",
COLOR0_INPUT => "Color 0",
COLOR1_INPUT => "Color 1",
_ => id,
}
}
/// Evaluate outputs: a `"ramp"` shader job over the value row, pushed
/// through `push_mergable_job` — merged alpha-over `base_in` when a
/// base texture is connected, pushed bare otherwise.
///
/// The params row carries the two points and the two colors;
/// `resolution_in` is filled by the runner from the render target
/// size, so it is not part of the params here.
fn value(
&self,
core: &NodeCore,
inputs: &crate::value::NodeValueRow,
time: oak_core::Rational,
table: &mut crate::value::NodeValueTable,
) {
let mut params = inputs.clone();
// The inputs are part of the row in the traverser flow (the bare
// key is always inserted for an unconnected input); fall back to
// the node's own values for direct `value()` calls.
for id in [POINT0_INPUT, POINT1_INPUT, COLOR0_INPUT, COLOR1_INPUT] {
if !params.contains_key(id) {
params.insert(id.to_string(), core.value_at_time(id, -1, time));
}
}
let job = crate::handle::make_owned(ShaderJobPayload {
node_id: crate::id::NodeId::INVALID,
time,
iterations: 1,
type_id: self.type_id().to_string(),
shader_id: "ramp".to_string(),
effect_input: core.effect_input.clone(),
params,
iterative_input: String::new(),
});
super::generatorwithmerge::GeneratorWithMerge::push_mergable_job(inputs, job, table);
}
/// Shader code request: `"ramp"` returns this node's shader; the
/// `"mrg"` request returns the shared alpha-over merge shader;
/// anything else is unsupported.
fn shader_code(&self, request: &str) -> Option<String> {
match request {
"ramp" => Some(Self::shader_frag().to_string()),
"mrg" => Some(super::generatorwithmerge::merge_shader_frag().to_string()),
_ => None,
}
}
/// Deep copy.
fn duplicate(&self, _core: &NodeCore) -> Option<Box<dyn NodeBehavior>> {
Some(Box::new(RampNode))
}
}
/// Constructor: adds `base_in` (not-keyframable), the two points and the
/// two colors with the defaults and properties documented on the
/// constants, sets the video-effect flag and makes `base_in` the effect
/// input (the `GeneratorWithMerge` constructor side effects).
pub fn create() -> (NodeCore, Box<dyn NodeBehavior>) {
let mut core = NodeCore::new();
let mut base = crate::input::Input::new(
BASE_INPUT,
crate::value::ValueType::Texture,
crate::value::NodeValue::None,
);
base.flags |= crate::input::flags::NOT_KEYFRAMABLE;
core.add_input(base);
core.add_input(crate::input::Input::new(
POINT0_INPUT,
crate::value::ValueType::Vec2,
crate::value::NodeValue::Vec2([-100.0, 0.0]),
));
core.add_input(crate::input::Input::new(
POINT1_INPUT,
crate::value::ValueType::Vec2,
crate::value::NodeValue::Vec2([100.0, 0.0]),
));
for (id, default) in [
(COLOR0_INPUT, [0.0, 0.0, 0.0, 1.0]),
(COLOR1_INPUT, [1.0, 1.0, 1.0, 1.0]),
] {
let mut color = crate::input::Input::new(
id,
crate::value::ValueType::Color,
crate::value::NodeValue::Color(default),
);
color.properties = vec![(
"view".to_string(),
crate::value::NodeValue::Text("color".into()),
)];
core.add_input(color);
}
core.flags |= crate::node::flags::VIDEO_EFFECT;
core.effect_input = BASE_INPUT.to_string();
(core, Box::new(RampNode))
}
#[cfg(test)]
mod tests {
use super::*;
use crate::node::NodeBehavior;
use crate::value::{NodeValue, NodeValueRow, NodeValueTable, ValueType};
use oak_core::Rational;
#[test]
fn input_names() {
let n = RampNode;
assert_eq!(n.input_name(POINT0_INPUT), "Point 0");
assert_eq!(n.input_name(POINT1_INPUT), "Point 1");
assert_eq!(n.input_name(COLOR0_INPUT), "Color 0");
assert_eq!(n.input_name(COLOR1_INPUT), "Color 1");
assert_eq!(
n.input_name(super::super::generatorwithmerge::BASE_INPUT),
"Base"
);
}
#[test]
fn create_wires_inputs_and_flags() {
let (core, behavior) = create();
assert_eq!(behavior.type_id(), "org.olivevideoeditor.Olive.ramp");
assert_eq!(
core.get_input(POINT0_INPUT).unwrap().default,
NodeValue::Vec2([-100.0, 0.0])
);
assert_eq!(
core.get_input(POINT1_INPUT).unwrap().default,
NodeValue::Vec2([100.0, 0.0])
);
assert_eq!(
core.get_input(COLOR0_INPUT).unwrap().default,
NodeValue::Color([0.0, 0.0, 0.0, 1.0])
);
assert_eq!(
core.get_input(COLOR1_INPUT).unwrap().default,
NodeValue::Color([1.0, 1.0, 1.0, 1.0])
);
assert!(core.get_input(COLOR1_INPUT).unwrap().properties.iter().any(
|(k, v)| k == "view" && *v == NodeValue::Text("color".into())
));
assert_eq!(core.effect_input, BASE_INPUT);
assert_ne!(core.flags & crate::node::flags::VIDEO_EFFECT, 0);
}
#[test]
fn value_pushes_generator_job() {
let (core, behavior) = create();
let mut table = NodeValueTable::default();
behavior.value(
&core,
&NodeValueRow::default(),
Rational::new(0, 1),
&mut table,
);
let handle = match table.get(ValueType::Texture) {
Some(NodeValue::Texture(h)) => *h,
_ => panic!("texture expected"),
};
let payload = unsafe { crate::handle::get_checked::<ShaderJobPayload>(&handle) }
.expect("shader job payload expected");
assert_eq!(payload.type_id, "org.olivevideoeditor.Olive.ramp");
assert_eq!(payload.shader_id, "ramp");
assert_eq!(payload.iterations, 1);
assert_eq!(payload.effect_input, BASE_INPUT);
assert_eq!(payload.iterative_input, "");
assert_eq!(
payload.params.get(POINT0_INPUT),
Some(&NodeValue::Vec2([-100.0, 0.0]))
);
assert_eq!(
payload.params.get(COLOR1_INPUT),
Some(&NodeValue::Color([1.0, 1.0, 1.0, 1.0]))
);
}
#[test]
fn value_row_points_win_over_the_node_defaults() {
let (core, behavior) = create();
let inputs = NodeValueRow::from([
(POINT0_INPUT.to_string(), NodeValue::Vec2([-4.0, 0.0])),
(POINT1_INPUT.to_string(), NodeValue::Vec2([4.0, 0.0])),
(COLOR0_INPUT.to_string(), NodeValue::Color([1.0, 0.0, 0.0, 1.0])),
]);
let mut table = NodeValueTable::default();
behavior.value(&core, &inputs, Rational::new(0, 1), &mut table);
let handle = match table.get(ValueType::Texture) {
Some(NodeValue::Texture(h)) => *h,
_ => panic!("texture expected"),
};
let payload = unsafe { crate::handle::get_checked::<ShaderJobPayload>(&handle) }
.expect("shader job payload expected");
assert_eq!(
payload.params.get(POINT0_INPUT),
Some(&NodeValue::Vec2([-4.0, 0.0]))
);
assert_eq!(
payload.params.get(COLOR0_INPUT),
Some(&NodeValue::Color([1.0, 0.0, 0.0, 1.0]))
);
// The unset color falls back to the node default.
assert_eq!(
payload.params.get(COLOR1_INPUT),
Some(&NodeValue::Color([1.0, 1.0, 1.0, 1.0]))
);
}
#[test]
fn value_with_base_merges_nested_job() {
let (core, behavior) = create();
let inputs = NodeValueRow::from([(
BASE_INPUT.to_string(),
NodeValue::Texture(crate::handle::CHandle::null()),
)]);
let mut table = NodeValueTable::default();
behavior.value(&core, &inputs, Rational::new(0, 1), &mut table);
let handle = match table.get(ValueType::Texture) {
Some(NodeValue::Texture(h)) => *h,
_ => panic!("texture expected"),
};
let merge = unsafe { crate::handle::get_checked::<ShaderJobPayload>(&handle) }
.expect("merge job payload expected");
assert_eq!(merge.shader_id, "mrg");
assert_eq!(merge.effect_input, BASE_INPUT);
match merge.params.get(crate::nodes::merge::BLEND_INPUT) {
Some(NodeValue::Texture(blend)) => {
let nested = unsafe { crate::handle::get_checked::<ShaderJobPayload>(blend) }
.expect("nested job payload boxed");
assert_eq!(nested.shader_id, "ramp");
}
_ => panic!("nested blend job expected"),
}
}
#[test]
fn shader_code_dispatches() {
let n = RampNode;
let code = n.shader_code("ramp").unwrap();
assert!(code.contains("uniform vec2 point0_in;"));
assert!(code.contains("uniform vec2 point1_in;"));
assert!(code.contains("uniform vec4 color0_in;"));
assert!(code.contains("uniform vec4 color1_in;"));
assert!(code.contains("uniform vec2 resolution_in;"));
assert!(code.contains("t = dot(px - point0_in, d) / norm2;"));
assert!(!code.contains("switch"));
assert!(n
.shader_code("mrg")
.unwrap()
.contains("base_col *= 1.0 - blend_col.a;"));
assert!(n.shader_code("other").is_none());
}
#[test]
fn duplicate_clones() {
let (core, behavior) = create();
let dup = behavior.duplicate(&core).unwrap();
assert_eq!(dup.name(), "Ramp");
}
}
/// Register this node type.
pub fn register(meta: &mut Vec<NodeMeta>) {
meta.push(NodeMeta {
type_id: "org.olivevideoeditor.Olive.ramp",
name: "Ramp",
categories: &[Category::Generator],
create,
});
}
crates/oak-node/src/nodes/saturation.rs
+332
View File
@@ -0,0 +1,332 @@
// Oak Video Editor - Non-Linear Video Editor
// Copyright (C) 2026 Oak Team
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//! Saturation effect — a clean-room reimplementation of the OpenFX-Misc
//! `Saturation` plugin's parameter semantics (upstream
//! `github.com/cgvirus/OpenFX-Misc`, GPL2; read for behavior only, no
//! upstream code copied).
//!
//! One saturation control that lerps every color channel between the
//! pixel's Rec. 709 luma and its original value:
//!
//! ```text
//! luma = 0.2126*r + 0.7152*g + 0.0722*b
//! x = (1 - saturation) * luma + saturation * x
//! ```
//!
//! so `0.0` produces a grayscale image, `1.0` is the identity, and
//! values above `1.0` extrapolate away from gray. Alpha is left
//! untouched (the reference's saturation pass has no alpha term). The
//! lerp runs unconditionally — unlike the gamma-style passes there is
//! no "changed" test in the reference.
use crate::factory::NodeMeta;
use crate::jobs::ShaderJobPayload;
use crate::node::{Category, NodeBehavior, NodeCore};
/// Texture input id. Type: texture; flags: not-keyframable; this is
/// the node's effect input.
pub const TEXTURE_INPUT: &str = "tex_in";
/// Saturation input id. Type: float; default `1.0`; properties:
/// `min = 0.0`, `max = 4.0`. Lerps every channel toward the pixel's
/// Rec. 709 luma (`0.0` = grayscale, `1.0` = unchanged).
pub const SATURATION_INPUT: &str = "saturation_in";
/// Saturation node. The reference class holds no state beyond its
/// parameter pointers, so this is a unit-like struct.
pub struct SaturationNode;
/// Fragment shader (clean-room GLSL for the reference's
/// `SaturationPlugin::render` chain). The uniforms are named after the
/// node inputs: the renderer binds uniforms by matching the declared
/// name against the job's parameter row.
const SHADER_FRAG: &str = r#"// Inputs
uniform sampler2D tex_in;
uniform float saturation_in;
// Input texture coordinate
in vec2 ove_texcoord;
out vec4 frag_color;
void main() {
vec4 c = texture(tex_in, ove_texcoord);
// Lerp every color channel between the pixel's Rec. 709 luma and its
// original value.
float luma = dot(c.rgb, vec3(0.2126, 0.7152, 0.0722));
c.rgb = (1.0 - saturation_in) * luma + saturation_in * c.rgb;
frag_color = c;
}
"#;
impl NodeBehavior for SaturationNode {
/// Human-readable name.
fn name(&self) -> &str {
"Saturation"
}
/// Stable type id.
fn type_id(&self) -> &str {
"org.olivevideoeditor.Olive.saturation"
}
/// Categories.
fn categories(&self) -> &[Category] {
&[Category::Color]
}
/// Description.
fn description(&self) -> &str {
"Adjust the color intensity by lerping toward the image luma."
}
/// Localized input names: `tex_in` -> "Input", `saturation_in` ->
/// "Saturation".
fn input_name<'a>(&self, id: &'a str) -> &'a str {
match id {
TEXTURE_INPUT => "Input",
SATURATION_INPUT => "Saturation",
_ => id,
}
}
/// Evaluate outputs: no texture on `tex_in` -> push nothing;
/// texture present -> push a shader job over the input row with the
/// control resolved (so the renderer always finds a value for the
/// uniform, whether the row carried the input or the node's own
/// default/keyframe supplied it).
fn value(
&self,
core: &NodeCore,
inputs: &crate::value::NodeValueRow,
time: oak_core::Rational,
table: &mut crate::value::NodeValueTable,
) {
if !matches!(
inputs.get(TEXTURE_INPUT),
Some(crate::value::NodeValue::Texture(_))
) {
return;
}
let resolve = |id: &str| match inputs.get(id) {
Some(v) => v.clone(),
None => core.value_at_time(id, -1, time),
};
let mut params = inputs.clone();
params.insert(SATURATION_INPUT.to_string(), resolve(SATURATION_INPUT));
table.push(
crate::value::ValueType::Texture,
crate::value::NodeValue::Texture(crate::handle::make_owned(ShaderJobPayload {
node_id: crate::id::NodeId::INVALID,
time,
iterations: 1,
type_id: self.type_id().to_string(),
shader_id: String::new(),
effect_input: core.effect_input.clone(),
params,
iterative_input: String::new(),
})),
None,
);
}
/// Shader code request: the request id is ignored; always returns
/// [`SHADER_FRAG`].
fn shader_code(&self, _request: &str) -> Option<String> {
Some(SHADER_FRAG.to_string())
}
/// Deep copy.
fn duplicate(&self, _core: &NodeCore) -> Option<Box<dyn NodeBehavior>> {
Some(Box::new(SaturationNode))
}
}
/// Constructor: adds `tex_in` (texture, effect input) and the
/// saturation control with the default and range documented on the
/// constant, and sets the video-effect flag.
pub fn create() -> (NodeCore, Box<dyn NodeBehavior>) {
let mut core = NodeCore::new();
let mut tex = crate::input::Input::new(
TEXTURE_INPUT,
crate::value::ValueType::Texture,
crate::value::NodeValue::None,
);
tex.flags |= crate::input::flags::NOT_KEYFRAMABLE;
core.add_input(tex);
add_float_input(&mut core, SATURATION_INPUT, 1.0, 0.0, 4.0);
core.flags |= crate::node::flags::VIDEO_EFFECT;
core.effect_input = TEXTURE_INPUT.to_string();
(core, Box::new(SaturationNode))
}
/// Add a float input with its default and `min`/`max`/`view`
/// properties.
fn add_float_input(core: &mut NodeCore, id: &str, default: f64, min: f64, max: f64) {
let mut input = crate::input::Input::new(
id,
crate::value::ValueType::Float,
crate::value::NodeValue::Float(default),
);
input.properties = vec![
("min".to_string(), crate::value::NodeValue::Float(min)),
("max".to_string(), crate::value::NodeValue::Float(max)),
(
"view".to_string(),
crate::value::NodeValue::Text("normal".into()),
),
];
core.add_input(input);
}
/// Register this node type.
pub fn register(meta: &mut Vec<NodeMeta>) {
meta.push(NodeMeta {
type_id: "org.olivevideoeditor.Olive.saturation",
name: "Saturation",
categories: &[Category::Color],
create,
});
}
#[cfg(test)]
mod tests {
use super::*;
use crate::value::{NodeValue, NodeValueTable, ValueType};
use oak_core::Rational;
#[test]
fn input_names() {
let n = SaturationNode;
assert_eq!(n.input_name(TEXTURE_INPUT), "Input");
assert_eq!(n.input_name(SATURATION_INPUT), "Saturation");
assert_eq!(n.input_name("other_in"), "other_in");
}
#[test]
fn create_wires_inputs_and_flags() {
let (core, behavior) = create();
assert_eq!(behavior.type_id(), "org.olivevideoeditor.Olive.saturation");
assert_eq!(behavior.name(), "Saturation");
assert_eq!(behavior.categories(), &[Category::Color]);
let tex = core.get_input(TEXTURE_INPUT).unwrap();
assert_ne!(tex.flags & crate::input::flags::NOT_KEYFRAMABLE, 0);
assert_eq!(
core.get_input(SATURATION_INPUT).unwrap().default,
NodeValue::Float(1.0)
);
assert_eq!(core.effect_input, TEXTURE_INPUT);
assert_ne!(core.flags & crate::node::flags::VIDEO_EFFECT, 0);
}
#[test]
fn create_sets_control_range() {
let (core, _) = create();
let saturation = core.get_input(SATURATION_INPUT).unwrap();
assert_eq!(saturation.properties[0].1, NodeValue::Float(0.0));
assert_eq!(saturation.properties[1].1, NodeValue::Float(4.0));
}
#[test]
fn value_no_texture_pushes_nothing() {
let (core, behavior) = create();
let mut table = NodeValueTable::default();
behavior.value(
&core,
&crate::value::NodeValueRow::default(),
Rational::new(0, 1),
&mut table,
);
assert!(table.is_empty());
}
#[test]
fn value_with_texture_pushes_shader_job_with_resolved_params() {
let (core, behavior) = create();
let inputs = crate::value::NodeValueRow::from([(
TEXTURE_INPUT.to_string(),
NodeValue::Texture(crate::handle::CHandle::null()),
)]);
let mut table = NodeValueTable::default();
behavior.value(&core, &inputs, Rational::new(0, 1), &mut table);
let Some(NodeValue::Texture(handle)) = table.get(ValueType::Texture) else {
panic!("expected a texture-typed value");
};
let payload =
unsafe { crate::handle::get_checked::<crate::jobs::ShaderJobPayload>(handle) }
.expect("shader job pushed");
assert_eq!(payload.type_id, "org.olivevideoeditor.Olive.saturation");
assert_eq!(payload.effect_input, TEXTURE_INPUT);
assert_eq!(
payload.params.get(SATURATION_INPUT),
Some(&NodeValue::Float(1.0))
);
}
#[test]
fn value_row_values_win_over_defaults() {
let (mut core, behavior) = create();
core.set_standard_value(SATURATION_INPUT, -1, NodeValue::Float(3.0));
let inputs = crate::value::NodeValueRow::from([
(
TEXTURE_INPUT.to_string(),
NodeValue::Texture(crate::handle::CHandle::null()),
),
(SATURATION_INPUT.to_string(), NodeValue::Float(0.25)),
]);
let mut table = NodeValueTable::default();
behavior.value(&core, &inputs, Rational::new(0, 1), &mut table);
let Some(NodeValue::Texture(handle)) = table.get(ValueType::Texture) else {
panic!("expected a texture-typed value");
};
let payload =
unsafe { crate::handle::get_checked::<crate::jobs::ShaderJobPayload>(handle) }
.expect("shader job pushed");
assert_eq!(
payload.params.get(SATURATION_INPUT),
Some(&NodeValue::Float(0.25))
);
}
#[test]
fn shader_declares_uniforms_and_avoids_switch() {
let code = SaturationNode.shader_code("").unwrap();
for uniform in ["tex_in", SATURATION_INPUT] {
assert!(code.contains(uniform), "uniform {uniform} declared");
}
assert!(code.contains("ove_texcoord"));
assert!(code.contains("frag_color"));
assert!(!code.contains("switch"), "naga rejects GLSL switch");
}
#[test]
fn duplicate_clones() {
let (core, behavior) = create();
let dup = behavior.duplicate(&core).unwrap();
assert_eq!(dup.name(), "Saturation");
assert_eq!(dup.type_id(), "org.olivevideoeditor.Olive.saturation");
}
}
crates/oak-node/src/nodes/sharpen.rs
+339
View File
@@ -0,0 +1,339 @@
// Oak Video Editor - Non-Linear Video Editor
// Copyright (C) 2026 Oak Team
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//! Sharpen filter (clean-room reimplementation of the CImg `Sharpen`
//! / `net.sf.cimg.CImgSharpen` effect; `ofx-misc` used for parameter
//! semantics only, no code copied).
//!
//! Upstream blurs a copy of the image and mixes it back as
//! `input * (1 + amount) - blurred * amount`, i.e. an unsharp mask
//! `out = x + amount * (x - blur(x))` with its CImg blur kernel
//! (`amount` defaults to 1, negative values soften). The blur is a
//! 3x3 box average computed inline in the same pass — upstream's
//! separable, user-sized CImg blur would need a multi-pass job, which
//! this node trades for a single-pass small-kernel mask.
use crate::factory::NodeMeta;
use crate::jobs::ShaderJobPayload;
use crate::node::{Category, NodeBehavior, NodeCore};
/// Texture input id. Type: texture; flags: not-keyframable; this is the
/// node's effect input.
pub const TEXTURE_INPUT: &str = "tex_in";
/// Sharpening amount input id (upstream `amount`, "Amount"). Type:
/// float; default `1.0` (upstream default); no range restriction —
/// upstream's range is unbounded, so a negative amount softens
/// (`out = x + amount * (x - blur(x))` turns into a blend toward the
/// blurred image). `0.0` is an exact identity.
pub const AMOUNT_INPUT: &str = "amount_in";
/// Sharpen filter node. Unsharp mask against an inline 3x3 box blur.
pub struct SharpenNode;
/// Fragment shader: 3x3 box blur of the pixel neighborhood, then the
/// unsharp mask `x + amount * (x - blur(x))` on all four channels.
/// Offsets are one texel (`resolution_in`, auto-filled by the renderer);
/// edge-of-frame taps clamp to the border pixel. The result is not
/// clamped: F32 output, and the overshoot on either side of an edge is
/// the point of the effect. `switch` is deliberately not used (naga
/// rejects it).
const SHADER_FRAG: &str = r#"uniform sampler2D tex_in;
uniform float amount_in;
uniform vec2 resolution_in;
in vec2 ove_texcoord;
out vec4 frag_color;
// Blur kernel edge (3x3 box, i.e. 9 taps).
#define KERNEL_RADIUS 1
void main() {
vec2 texel = vec2(1.0) / resolution_in;
vec4 center = texture(tex_in, ove_texcoord);
// 3x3 box blur, computed inline: the unsharp mask only needs a small
// neighborhood, so no second pass (and no nested job) is involved.
vec4 blurred = vec4(0.0);
for (int y = -KERNEL_RADIUS; y <= KERNEL_RADIUS; ++y) {
for (int x = -KERNEL_RADIUS; x <= KERNEL_RADIUS; ++x) {
blurred += texture(tex_in, ove_texcoord + vec2(float(x), float(y)) * texel);
}
}
float kernel_area = float((2 * KERNEL_RADIUS + 1) * (2 * KERNEL_RADIUS + 1));
blurred /= kernel_area;
frag_color = center + amount_in * (center - blurred);
}
"#;
impl SharpenNode {
/// Fragment shader for any request (this node has a single variant).
fn shader_frag() -> &'static str {
SHADER_FRAG
}
}
impl NodeBehavior for SharpenNode {
/// Human-readable name.
fn name(&self) -> &str {
"Sharpen"
}
/// Stable type id.
fn type_id(&self) -> &str {
"org.olivevideoeditor.Olive.sharpen"
}
/// Categories.
fn categories(&self) -> &[Category] {
&[Category::Filter]
}
/// Description.
fn description(&self) -> &str {
"Sharpens an image with an unsharp mask."
}
/// Localized input names: `tex_in` -> "Input", `amount_in` ->
/// "Amount".
fn input_name<'a>(&self, id: &'a str) -> &'a str {
match id {
TEXTURE_INPUT => "Input",
AMOUNT_INPUT => "Amount",
_ => id,
}
}
/// Evaluate outputs: no texture -> push nothing; otherwise push the
/// unsharp-mask shader job.
///
/// A zero `amount_in` still pushes the job (the mask then reduces to
/// the input pixel exactly) rather than passing the input texture
/// through as the blur node does for a zero radius: the plan's node
/// template reserves the pass-through for the no-texture case, and
/// feeding the input's CPU texture downstream here would silently
/// break nodes that expect a GPU texture. The resolved amount is
/// written into the job row so the uniform is always present, even
/// when the incoming row only carries the effect input.
///
/// `resolution_in` is filled by the runner from the effect input's
/// size (C++ `tex->virtual_resolution()`; see the blur node's
/// `// CPP-PARITY: blur.cpp` note).
fn value(
&self,
core: &NodeCore,
inputs: &crate::value::NodeValueRow,
time: oak_core::Rational,
table: &mut crate::value::NodeValueTable,
) {
use crate::value::{NodeValue, ValueType};
match inputs.get(TEXTURE_INPUT) {
Some(NodeValue::Texture(_)) => {}
_ => return,
}
let amount = match inputs.get(AMOUNT_INPUT) {
Some(v) => v.to_double(),
None => core.value_at_time(AMOUNT_INPUT, -1, time).to_double(),
};
let mut params = inputs.clone();
params.insert(AMOUNT_INPUT.to_string(), NodeValue::Float(amount));
table.push(
ValueType::Texture,
NodeValue::Texture(crate::handle::make_owned(ShaderJobPayload {
node_id: crate::id::NodeId::INVALID,
time,
iterations: 1,
type_id: self.type_id().to_string(),
shader_id: String::new(),
effect_input: core.effect_input.clone(),
params,
iterative_input: String::new(),
})),
None,
);
}
/// Shader code request: always the one fragment source.
fn shader_code(&self, _request: &str) -> Option<String> {
Some(Self::shader_frag().to_string())
}
/// Deep copy.
fn duplicate(&self, _core: &NodeCore) -> Option<Box<dyn NodeBehavior>> {
Some(Box::new(SharpenNode))
}
}
/// Constructor: adds `tex_in` and `amount_in` with the defaults and
/// properties documented on the constants, sets the video-effect flag
/// and the effect input.
pub fn create() -> (NodeCore, Box<dyn NodeBehavior>) {
let mut core = NodeCore::new();
let mut tex = crate::input::Input::new(
TEXTURE_INPUT,
crate::value::ValueType::Texture,
crate::value::NodeValue::None,
);
tex.flags |= crate::input::flags::NOT_KEYFRAMABLE;
core.add_input(tex);
core.add_input(crate::input::Input::new(
AMOUNT_INPUT,
crate::value::ValueType::Float,
crate::value::NodeValue::Float(1.0),
));
core.flags |= crate::node::flags::VIDEO_EFFECT;
core.effect_input = TEXTURE_INPUT.to_string();
(core, Box::new(SharpenNode))
}
#[cfg(test)]
mod tests {
use super::*;
use crate::value::{NodeValue, NodeValueTable, ValueType};
use oak_core::Rational;
fn tex() -> NodeValue {
NodeValue::Texture(crate::handle::CHandle::null())
}
fn run(core: &NodeCore, inputs: &crate::value::NodeValueRow) -> ShaderJobPayload {
let behavior = SharpenNode;
let mut table = NodeValueTable::default();
behavior.value(core, inputs, Rational::new(0, 1), &mut table);
let Some(NodeValue::Texture(h)) = table.get(ValueType::Texture) else {
panic!("shader job expected");
};
unsafe { crate::handle::get_checked::<ShaderJobPayload>(h) }
.expect("shader job payload boxed")
.clone()
}
#[test]
fn input_names() {
let n = SharpenNode;
assert_eq!(n.input_name(TEXTURE_INPUT), "Input");
assert_eq!(n.input_name(AMOUNT_INPUT), "Amount");
assert_eq!(n.input_name("other"), "other");
}
#[test]
fn create_wires_inputs_and_flags() {
let (core, behavior) = create();
assert_eq!(behavior.type_id(), "org.olivevideoeditor.Olive.sharpen");
assert_eq!(behavior.name(), "Sharpen");
assert_eq!(behavior.categories(), &[Category::Filter]);
assert_eq!(core.effect_input, TEXTURE_INPUT);
assert_ne!(core.flags & crate::node::flags::VIDEO_EFFECT, 0);
assert_eq!(
core.get_input(AMOUNT_INPUT).expect("amount input").default,
NodeValue::Float(1.0)
);
}
#[test]
fn value_no_texture_pushes_nothing() {
let (core, behavior) = create();
let mut table = NodeValueTable::default();
behavior.value(
&core,
&crate::value::NodeValueRow::default(),
Rational::new(0, 1),
&mut table,
);
assert!(table.is_empty());
}
#[test]
fn value_pushes_job_with_default_amount() {
let (core, _) = create();
let inputs = crate::value::NodeValueRow::from([(TEXTURE_INPUT.to_string(), tex())]);
let payload = run(&core, &inputs);
assert_eq!(payload.type_id, "org.olivevideoeditor.Olive.sharpen");
assert_eq!(payload.shader_id, "");
assert_eq!(payload.effect_input, TEXTURE_INPUT);
assert_eq!(payload.iterations, 1);
assert_eq!(payload.iterative_input, "");
assert_eq!(
payload.params.get(AMOUNT_INPUT),
Some(&NodeValue::Float(1.0)),
"the sharpening amount rides in the job params"
);
}
#[test]
fn value_takes_amount_from_row() {
let (core, _) = create();
let inputs = crate::value::NodeValueRow::from([
(TEXTURE_INPUT.to_string(), tex()),
(AMOUNT_INPUT.to_string(), NodeValue::Float(0.0)),
]);
let payload = run(&core, &inputs);
assert_eq!(
payload.params.get(AMOUNT_INPUT),
Some(&NodeValue::Float(0.0))
);
}
#[test]
fn value_takes_amount_from_core() {
let (mut core, _) = create();
core.set_standard_value(AMOUNT_INPUT, -1, NodeValue::Float(2.5));
let inputs = crate::value::NodeValueRow::from([(TEXTURE_INPUT.to_string(), tex())]);
let payload = run(&core, &inputs);
assert_eq!(
payload.params.get(AMOUNT_INPUT),
Some(&NodeValue::Float(2.5))
);
}
#[test]
fn shader_code_is_inline_unsharp_mask_without_switch() {
let n = SharpenNode;
let glsl = n.shader_code("").unwrap();
assert!(glsl.contains("uniform float amount_in;"));
assert!(glsl.contains("uniform vec2 resolution_in;"));
assert!(glsl.contains("#define KERNEL_RADIUS 1"));
assert!(glsl.contains("frag_color = center + amount_in * (center - blurred);"));
assert!(!glsl.contains("switch"));
}
#[test]
fn duplicate_clones_behavior() {
let (core, behavior) = create();
let dup = behavior.duplicate(&core).unwrap();
assert_eq!(dup.name(), "Sharpen");
}
}
/// Register this node type.
pub fn register(meta: &mut Vec<NodeMeta>) {
meta.push(NodeMeta {
type_id: "org.olivevideoeditor.Olive.sharpen",
name: "Sharpen",
categories: &[Category::Filter],
create,
});
}
crates/oak-node/src/nodes/unpremult.rs
+379
View File
@@ -0,0 +1,379 @@
// Oak Video Editor - Non-Linear Video Editor
// Copyright (C) 2026 Oak Team
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//! Unpremultiply effect (clean-room reimplementation of the OpenFX-Misc
//! `UnpremultOFX` / `net.sf.openfx.PremultPlugin` in its unpremultiply
//! mode; the `Premult` reference tree is used for parameter semantics
//! only, no code copied).
//!
//! The inverse of [`crate::nodes::premult`]: each RGB channel is divided
//! by the channel picked in [`CHANNEL_INPUT`] (default
//! [`Channel::Alpha`]) instead of multiplied by it, and the source alpha
//! rides through untouched. Upstream guards the division —
//! `!process_c || alpha <= FLT_EPSILON` keeps the source value
//! (`// CPP-PARITY: Premult.cpp`) — and the shader keeps the same guard.
//!
//! Single texture input, so `core.effect_input` is set to
//! [`TEXTURE_INPUT`] (the despill node's shape) and the job binds that
//! one sampler by name. `None` (or an out-of-range selector) divides by
//! one, leaving the image unchanged.
use crate::factory::NodeMeta;
use crate::jobs::ShaderJobPayload;
use crate::node::{Category, NodeBehavior, NodeCore};
/// Texture input id. Type: texture; flags: not-keyframable; this is the
/// node's effect input.
pub const TEXTURE_INPUT: &str = "tex_in";
/// Channel selector input id (upstream's "premult channel" choice, used
/// here as the divisor). Type: combo; default [`Channel::Alpha`]
/// (`Combo(4)`); flags: not-connectable, not-keyframable. Combo strings:
/// "None", "R", "G", "B", "A".
pub const CHANNEL_INPUT: &str = "unpremult_channel_in";
/// Channel selector values for [`CHANNEL_INPUT`], in combo order. The
/// numeric values are the shader's channel indices: `0` selects nothing
/// (the image passes through — a divisor of 1) and `1..=4` select
/// `r`/`g`/`b`/`a`.
#[repr(i64)]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Channel {
/// No channel: the image is left unchanged.
None = 0,
/// Red channel.
Red = 1,
/// Green channel.
Green = 2,
/// Blue channel.
Blue = 3,
/// Alpha channel (the default divisor).
Alpha = 4,
}
/// Unpremultiply node. Unit-like: there is no per-instance state.
pub struct UnpremultiplyNode;
/// Fragment shader: `rgb /= selected_channel` with the upstream
/// near-zero guard. The channel dispatch is an if/else chain and not a
/// `switch` (naga rejects the latter); an out-of-range selector falls
/// back to a divisor of 1, the "None" combo entry. No `tex_in_enabled`
/// flag is declared: with a single texture input the sampler is either
/// bound or the job never runs (`value()` requires the texture), and the
/// despill node's shader has the same shape.
const SHADER_FRAG: &str = r#"uniform sampler2D tex_in;
uniform int unpremult_channel_in;
in vec2 ove_texcoord;
out vec4 frag_color;
float selected_channel(vec4 col, int channel) {
if (channel == 1) {
return col.r;
} else if (channel == 2) {
return col.g;
} else if (channel == 3) {
return col.b;
} else if (channel == 4) {
return col.a;
}
return 1.0;
}
void main(void) {
vec4 col = texture(tex_in, ove_texcoord);
float factor = selected_channel(col, unpremult_channel_in);
// Upstream keeps the source value when the divisor is (near) zero
// (`alpha <= FLT_EPSILON` in Premult.cpp), which is also what saves
// an unpainted alpha of 0 from blowing the RGB channels up.
if (factor <= 0.000001) {
frag_color = col;
return;
}
frag_color = vec4(col.rgb / factor, col.a);
}
"#;
impl UnpremultiplyNode {
/// Fragment shader (single variant, so the request id is ignored).
fn shader_frag() -> &'static str {
SHADER_FRAG
}
}
impl NodeBehavior for UnpremultiplyNode {
/// Human-readable name.
fn name(&self) -> &str {
"Unpremultiply"
}
/// Stable type id.
fn type_id(&self) -> &str {
"org.olivevideoeditor.Olive.unpremult"
}
/// Categories. Filed under math like the alpha-over
/// [`crate::nodes::merge`] (the `Category` enum has no merge group).
fn categories(&self) -> &[Category] {
&[Category::Math]
}
/// Description.
fn description(&self) -> &str {
"Divide the RGB channels by a selected channel (zero guarded)."
}
/// Localized input names: `tex_in` -> "Input", `unpremult_channel_in`
/// -> "Channel".
fn input_name<'a>(&self, id: &'a str) -> &'a str {
match id {
TEXTURE_INPUT => "Input",
CHANNEL_INPUT => "Channel",
_ => id,
}
}
/// Combo input option labels: `unpremult_channel_in` -> "None", "R",
/// "G", "B", "A" (the [`Channel`] order).
fn input_combo_strings(&self, id: &str) -> Vec<&'static str> {
match id {
CHANNEL_INPUT => vec!["None", "R", "G", "B", "A"],
_ => Vec::new(),
}
}
/// Evaluate outputs: with no texture there is nothing to divide;
/// otherwise push one shader job over the whole input row, with the
/// resolved channel selector written in so the uniform is always
/// present even when the incoming row only carries the texture (the
/// row/standard-value split mirrors the directional-blur node).
fn value(
&self,
core: &NodeCore,
inputs: &crate::value::NodeValueRow,
time: oak_core::Rational,
table: &mut crate::value::NodeValueTable,
) {
use crate::value::{NodeValue, ValueType};
match inputs.get(TEXTURE_INPUT) {
Some(NodeValue::Texture(_)) => {}
_ => return,
}
let channel = match inputs.get(CHANNEL_INPUT) {
Some(v) => v.clone(),
None => core.value_at_time(CHANNEL_INPUT, -1, time),
};
let mut params = inputs.clone();
params.insert(CHANNEL_INPUT.to_string(), channel);
table.push(
ValueType::Texture,
NodeValue::Texture(crate::handle::make_owned(ShaderJobPayload {
node_id: crate::id::NodeId::INVALID,
time,
iterations: 1,
type_id: self.type_id().to_string(),
shader_id: String::new(),
effect_input: core.effect_input.clone(),
params,
iterative_input: String::new(),
})),
None,
);
}
/// Shader code request: always the unpremultiply fragment source.
fn shader_code(&self, _request: &str) -> Option<String> {
Some(Self::shader_frag().to_string())
}
/// Deep copy.
fn duplicate(&self, _core: &NodeCore) -> Option<Box<dyn NodeBehavior>> {
Some(Box::new(UnpremultiplyNode))
}
}
/// Constructor: adds `tex_in` (not-keyframable) and
/// `unpremult_channel_in` (combo, default alpha), sets the video-effect
/// flag and makes `tex_in` the effect input.
pub fn create() -> (NodeCore, Box<dyn NodeBehavior>) {
let mut core = NodeCore::new();
let mut tex = crate::input::Input::new(
TEXTURE_INPUT,
crate::value::ValueType::Texture,
crate::value::NodeValue::None,
);
tex.flags |= crate::input::flags::NOT_KEYFRAMABLE;
core.add_input(tex);
let mut channel = crate::input::Input::new(
CHANNEL_INPUT,
crate::value::ValueType::Combo,
crate::value::NodeValue::Combo(Channel::Alpha as i64),
);
channel.flags |= crate::input::flags::NOT_CONNECTABLE | crate::input::flags::NOT_KEYFRAMABLE;
core.add_input(channel);
core.flags |= crate::node::flags::VIDEO_EFFECT;
core.effect_input = TEXTURE_INPUT.to_string();
(core, Box::new(UnpremultiplyNode))
}
#[cfg(test)]
mod tests {
use super::*;
use crate::value::{NodeValue, NodeValueTable, ValueType};
use oak_core::Rational;
fn tex() -> NodeValue {
NodeValue::Texture(crate::handle::CHandle::null())
}
fn run(core: &NodeCore, inputs: &crate::value::NodeValueRow) -> ShaderJobPayload {
let behavior = UnpremultiplyNode;
let mut table = NodeValueTable::default();
behavior.value(core, inputs, Rational::new(0, 1), &mut table);
let Some(NodeValue::Texture(h)) = table.get(ValueType::Texture) else {
panic!("shader job expected");
};
unsafe { crate::handle::get_checked::<ShaderJobPayload>(h) }
.expect("shader job payload boxed")
.clone()
}
#[test]
fn input_names() {
let n = UnpremultiplyNode;
assert_eq!(n.input_name(TEXTURE_INPUT), "Input");
assert_eq!(n.input_name(CHANNEL_INPUT), "Channel");
assert_eq!(n.input_name("other"), "other");
}
#[test]
fn combo_strings_match_channel_values() {
let n = UnpremultiplyNode;
let strings = n.input_combo_strings(CHANNEL_INPUT);
assert_eq!(strings, vec!["None", "R", "G", "B", "A"]);
assert_eq!(Channel::None as i64, 0);
assert_eq!(Channel::Red as i64, 1);
assert_eq!(Channel::Green as i64, 2);
assert_eq!(Channel::Blue as i64, 3);
assert_eq!(Channel::Alpha as i64, 4);
assert!(n.input_combo_strings("other").is_empty());
}
#[test]
fn create_wires_inputs_flags_and_defaults() {
let (core, behavior) = create();
assert_eq!(behavior.type_id(), "org.olivevideoeditor.Olive.unpremult");
assert_eq!(behavior.name(), "Unpremultiply");
assert_eq!(behavior.categories(), &[Category::Math]);
assert_ne!(core.flags & crate::node::flags::VIDEO_EFFECT, 0);
assert_eq!(core.effect_input, TEXTURE_INPUT);
let tex_input = core.get_input(TEXTURE_INPUT).expect("texture input");
assert_eq!(tex_input.value_type, ValueType::Texture);
assert_ne!(tex_input.flags & crate::input::flags::NOT_KEYFRAMABLE, 0);
let channel = core.get_input(CHANNEL_INPUT).expect("channel input");
assert_eq!(channel.value_type, ValueType::Combo);
assert_eq!(channel.default, NodeValue::Combo(Channel::Alpha as i64));
assert_ne!(channel.flags & crate::input::flags::NOT_CONNECTABLE, 0);
assert_ne!(channel.flags & crate::input::flags::NOT_KEYFRAMABLE, 0);
}
#[test]
fn value_no_texture_pushes_nothing() {
let (core, behavior) = create();
let mut table = NodeValueTable::default();
behavior.value(
&core,
&crate::value::NodeValueRow::default(),
Rational::new(0, 1),
&mut table,
);
assert!(table.is_empty());
}
#[test]
fn value_with_texture_defaults_channel_to_alpha() {
let (core, _) = create();
let inputs = crate::value::NodeValueRow::from([(TEXTURE_INPUT.to_string(), tex())]);
let payload = run(&core, &inputs);
assert_eq!(payload.type_id, "org.olivevideoeditor.Olive.unpremult");
assert_eq!(payload.shader_id, "");
assert_eq!(payload.iterations, 1);
assert_eq!(payload.iterative_input, "");
assert_eq!(payload.effect_input, TEXTURE_INPUT);
assert_eq!(
payload.params.get(CHANNEL_INPUT),
Some(&NodeValue::Combo(Channel::Alpha as i64)),
"the default channel rides in the job params"
);
}
#[test]
fn value_takes_channel_from_row() {
let (core, _) = create();
let inputs = crate::value::NodeValueRow::from([
(TEXTURE_INPUT.to_string(), tex()),
(
CHANNEL_INPUT.to_string(),
NodeValue::Combo(Channel::Red as i64),
),
]);
let payload = run(&core, &inputs);
assert_eq!(
payload.params.get(CHANNEL_INPUT),
Some(&NodeValue::Combo(Channel::Red as i64))
);
}
#[test]
fn shader_code_declares_inputs_and_zero_guard() {
let n = UnpremultiplyNode;
let glsl = n.shader_code("").unwrap();
assert!(glsl.contains("uniform sampler2D tex_in;"));
assert!(glsl.contains("uniform int unpremult_channel_in;"));
assert!(glsl.contains("if (factor <= 0.000001) {"));
assert!(glsl.contains("frag_color = vec4(col.rgb / factor, col.a);"));
assert!(!glsl.contains("switch"));
}
#[test]
fn duplicate_clones_behavior() {
let (core, behavior) = create();
let dup = behavior.duplicate(&core).unwrap();
assert_eq!(dup.name(), "Unpremultiply");
}
}
/// Register this node type.
pub fn register(meta: &mut Vec<NodeMeta>) {
meta.push(NodeMeta {
type_id: "org.olivevideoeditor.Olive.unpremult",
name: "Unpremultiply",
categories: &[Category::Math],
create,
});
}
crates/oak-render/tests/ofxmisc_blur.rs
+222
View File
@@ -0,0 +1,222 @@
//! GPU pixel tests for the Tier-1 blur/sharpen nodes (skip without GPU).
use oak_core::texture::Texture;
use oak_core::{PixelFormat, Rational};
use oak_node::value::{NodeValue, NodeValueRow, NodeValueTable, ValueType};
fn texture_value(t: Texture) -> NodeValue { NodeValue::Texture(oak_node::handle::make_owned(t)) }
fn gpu() -> bool { oak_core::backend::GpuContext::shared().is_some() }
fn filled_frame(size: (i32, i32), rgba: [f32; 4]) -> Texture {
let mut f = oak_render::eval::generate_frame(Rational::new(0, 1), size, PixelFormat::F32).unwrap();
for px in f.data.chunks_exact_mut(16) { for (c, v) in px.chunks_exact_mut(4).zip(rgba) { c.copy_from_slice(&v.to_le_bytes()); } }
Texture::wrap_frame(f)
}
fn pixel_at(frame: &oak_core::texture::Frame, x: usize, y: usize) -> [f32; 4] {
let stride = frame.linesize_bytes() as usize;
let at = y * stride + x * 16;
let mut out = [0f32; 4];
for c in 0..4 { out[c] = f32::from_le_bytes(frame.data[at + c*4..at + c*4 + 4].try_into().unwrap()); }
out
}
fn eval_node_row(type_id: &str, inputs: NodeValueRow, frame_size: Option<(i32, i32)>) -> oak_core::texture::Frame {
use oak_node::traverser::RenderHooks;
let (core, behavior) = oak_node::factory::Factory::global().create_any(type_id).expect("node type registered");
let mut table = NodeValueTable::default();
behavior.value(&core, &inputs, Rational::new(0, 1), &mut table);
let mut hooks = oak_render::eval::RenderEvalHooks::new();
hooks.frame_size = frame_size;
hooks.resolve(oak_node::id::NodeId::INVALID, &inputs, &mut table);
let Some(NodeValue::Texture(handle)) = table.get(ValueType::Texture) else { panic!("{type_id}: no texture produced") };
if handle.ctx.is_null() { panic!("{type_id}: null texture produced"); }
let tex = unsafe { oak_node::handle::get_checked::<Texture>(handle) }.expect("resolved texture");
assert!(matches!(tex, Texture::Gpu { .. }), "{type_id}: must render on the GPU");
tex.to_frame().expect("readback")
}
const DIRBLUR: &str = "org.olivevideoeditor.Olive.dirblur";
const SHARPEN: &str = "org.olivevideoeditor.Olive.sharpen";
/// A 16x16 F32 frame painted pixel by pixel from `paint(x, y)`.
fn painted_frame(paint: impl Fn(usize, usize) -> [f32; 4]) -> Texture {
let mut f = oak_render::eval::generate_frame(Rational::new(0, 1), (16, 16), PixelFormat::F32).unwrap();
let stride = f.linesize_bytes() as usize;
for y in 0..16 {
for x in 0..16 {
let at = y * stride + x * 16;
for (c, v) in paint(x, y).iter().enumerate() {
f.data[at + c * 4..at + c * 4 + 4].copy_from_slice(&v.to_le_bytes());
}
}
}
Texture::wrap_frame(f)
}
/// A row carrying the effect input plus any explicitly set float inputs.
fn row_with(texture: Texture, scalars: &[(&str, f64)]) -> NodeValueRow {
let mut row = NodeValueRow::new();
row.insert("tex_in".to_string(), texture_value(texture));
for (name, v) in scalars {
row.insert((*name).to_string(), NodeValue::Float(*v));
}
row
}
/// Assert every channel of `px` is within `tol` of `want`.
fn assert_close(px: [f32; 4], want: [f32; 4], tol: f32, what: &str) {
for c in 0..4 {
assert!(
(px[c] - want[c]).abs() <= tol,
"{what}: channel {c}: got {px:?}, want {want:?} (tol {tol})"
);
}
}
/// Zero amount (the input default) collapses the tap spacing to zero, so
/// the directional blur is an exact identity anchored to the sampled
/// coordinate; it still renders on the GPU.
#[test]
fn dirblur_zero_amount_is_identity() {
if !gpu() { eprintln!("no adapter; skipping"); return; }
let src = painted_frame(|x, y| [x as f32 / 15.0, y as f32 / 15.0, 0.25, 1.0]);
let out = eval_node_row(DIRBLUR, row_with(src, &[]), None);
for (x, y) in [(0, 0), (5, 3), (8, 8), (14, 12), (15, 15)] {
assert_close(
pixel_at(&out, x, y),
[x as f32 / 15.0, y as f32 / 15.0, 0.25, 1.0],
1e-3,
&format!("dirblur zero amount ({x},{y})"),
);
}
}
/// A one-pixel-wide white vertical line smears along +x at angle 0:
/// pixels either side pick up the line, the line itself dims, and
/// nothing leaks along y.
#[test]
fn dirblur_smears_horizontally_without_vertical_spread() {
if !gpu() { eprintln!("no adapter; skipping"); return; }
let src = painted_frame(|x, y| {
if x == 8 && (4..12).contains(&y) { [1.0, 1.0, 1.0, 1.0] } else { [0.0, 0.0, 0.0, 1.0] }
});
let out = eval_node_row(
DIRBLUR,
row_with(src, &[("amount_in", 2.0), ("angle_in", 0.0)]),
None,
);
let spread_l = pixel_at(&out, 6, 8)[0];
let spread_r = pixel_at(&out, 10, 8)[0];
assert!((0.05..0.3).contains(&spread_l), "pixel left of the line picks up the smear: {spread_l}");
assert!((spread_l - spread_r).abs() < 0.02, "smear is symmetric about the line: {spread_l} vs {spread_r}");
// The line dims, but not to nothing: the 16 taps sit 2*2/15 px apart,
// so they land at 8 + t*4/15 for t = -7.5..7.5 and the sampler's
// 1 px-wide linear reconstruction gives them 13/15, 9/15, 5/15 and
// 1/15 of the line each, twice over, leaving the center pixel at
// 2*(13+9+5+1)/(15*16) = 7/30.
let on_line = pixel_at(&out, 8, 8)[0];
assert!(
(on_line - 7.0 / 30.0).abs() < 0.02,
"a one-pixel line dims to ~7/30 of its brightness: {on_line}"
);
// The smear redistributes the line's brightness without adding or
// losing any: the linear-filter triangle has unit area, so the 16
// output pixels (each the average of 16 unit-spaced samples) still
// sum to the whole line. This holds whatever the filter mode.
let row_energy: f32 = (0..16).map(|x| pixel_at(&out, x, 8)[0]).sum();
assert!(
(row_energy - 1.0).abs() < 0.02,
"the row keeps the line's total brightness: {row_energy}"
);
assert!(pixel_at(&out, 5, 8)[0] < 0.01, "two pixels out stays black");
assert!(pixel_at(&out, 8, 3)[0] < 0.01, "no spread above the line");
assert!(pixel_at(&out, 8, 12)[0] < 0.01, "no spread below the line");
let alpha = pixel_at(&out, 6, 8)[3];
assert!((alpha - 1.0).abs() < 1e-3, "alpha passes through: {alpha}");
}
/// At angle 90 the smear runs along +y: the same one-pixel line laid
/// horizontally bleeds into the rows above and below it, and not along
/// its own axis.
#[test]
fn dirblur_angle_90_smears_vertically() {
if !gpu() { eprintln!("no adapter; skipping"); return; }
let src = painted_frame(|x, y| {
if y == 8 && (4..12).contains(&x) { [1.0, 1.0, 1.0, 1.0] } else { [0.0, 0.0, 0.0, 1.0] }
});
let out = eval_node_row(
DIRBLUR,
row_with(src, &[("amount_in", 2.0), ("angle_in", 90.0)]),
None,
);
let above = pixel_at(&out, 8, 6)[0];
let below = pixel_at(&out, 8, 10)[0];
assert!((0.05..0.3).contains(&above), "row above the line picks up the smear: {above}");
assert!((above - below).abs() < 0.02, "smear is symmetric about the line: {above} vs {below}");
// Same arithmetic as the horizontal case, rotated: 7/30 of the line.
let on_line = pixel_at(&out, 8, 8)[0];
assert!(
(on_line - 7.0 / 30.0).abs() < 0.02,
"a one-pixel line dims to ~7/30 of its brightness: {on_line}"
);
let column_energy: f32 = (0..16).map(|y| pixel_at(&out, 8, y)[0]).sum();
assert!(
(column_energy - 1.0).abs() < 0.02,
"the column keeps the line's total brightness: {column_energy}"
);
assert!(pixel_at(&out, 8, 5)[0] < 0.01, "two rows out stays black");
assert!(pixel_at(&out, 3, 6)[0] < 0.01, "no spread left of the line");
assert!(pixel_at(&out, 1, 8)[0] < 0.01, "no spread along the line's axis");
}
/// A flat region is untouched by the unsharp mask whatever the amount
/// (the default 1.0 included), and an explicit zero amount is an exact
/// identity on a gradient.
#[test]
fn sharpen_flat_and_zero_amount_pass_through() {
if !gpu() { eprintln!("no adapter; skipping"); return; }
let rgba = [0.4, 0.6, 0.8, 1.0];
let out = eval_node_row(SHARPEN, row_with(filled_frame((16, 16), rgba), &[]), None);
assert_close(pixel_at(&out, 8, 8), rgba, 1e-3, "sharpen default amount on a flat frame");
let src = painted_frame(|x, y| [x as f32 / 15.0, y as f32 / 15.0, 0.25, 1.0]);
let out = eval_node_row(SHARPEN, row_with(src, &[("amount_in", 0.0)]), None);
for (x, y) in [(0, 0), (5, 3), (8, 8), (14, 12), (15, 15)] {
assert_close(
pixel_at(&out, x, y),
[x as f32 / 15.0, y as f32 / 15.0, 0.25, 1.0],
1e-3,
&format!("sharpen zero amount ({x},{y})"),
);
}
}
/// At a black/white step the 3x3 box blur is 2/3 white on the bright
/// side (overshoot to 4/3) and 1/3 white on the dark side (undershoot to
/// -1/3); flat columns pass through and the result is not clamped.
#[test]
fn sharpen_overshoots_and_undershoots_a_step_edge() {
if !gpu() { eprintln!("no adapter; skipping"); return; }
let src = painted_frame(|x, _| {
if x < 8 { [0.0, 0.0, 0.0, 1.0] } else { [1.0, 1.0, 1.0, 1.0] }
});
let out = eval_node_row(SHARPEN, row_with(src, &[("amount_in", 1.0)]), None);
let bright = pixel_at(&out, 8, 8);
assert!((bright[0] - 4.0 / 3.0).abs() < 0.01, "overshoot on the bright side: {bright:?}");
assert!(bright[0] > 1.0, "overshoot is not clamped: {bright:?}");
assert!((bright[3] - 1.0).abs() < 1e-3, "alpha passes through: {bright:?}");
let dark = pixel_at(&out, 7, 8);
assert!((dark[0] + 1.0 / 3.0).abs() < 0.01, "undershoot on the dark side: {dark:?}");
assert!(dark[0] < 0.0, "undershoot is not clamped: {dark:?}");
assert!((dark[3] - 1.0).abs() < 1e-3, "alpha passes through: {dark:?}");
assert_close(pixel_at(&out, 6, 8), [0.0, 0.0, 0.0, 1.0], 1e-3, "flat black column");
assert_close(pixel_at(&out, 9, 8), [1.0, 1.0, 1.0, 1.0], 1e-3, "flat white column");
}
crates/oak-render/tests/ofxmisc_color.rs
+238
View File
@@ -0,0 +1,238 @@
//! GPU pixel tests for the Tier-1 color nodes (skip when no GPU adapter).
use oak_core::texture::Texture;
use oak_core::{PixelFormat, Rational};
use oak_node::value::{NodeValue, NodeValueRow, NodeValueTable, ValueType};
fn texture_value(t: Texture) -> NodeValue { NodeValue::Texture(oak_node::handle::make_owned(t)) }
fn gpu() -> bool { oak_core::backend::GpuContext::shared().is_some() }
fn filled_frame(size: (i32, i32), rgba: [f32; 4]) -> Texture {
let mut f = oak_render::eval::generate_frame(Rational::new(0, 1), size, PixelFormat::F32).unwrap();
for px in f.data.chunks_exact_mut(16) { for (c, v) in px.chunks_exact_mut(4).zip(rgba) { c.copy_from_slice(&v.to_le_bytes()); } }
Texture::wrap_frame(f)
}
fn pixel_at(frame: &oak_core::texture::Frame, x: usize, y: usize) -> [f32; 4] {
let stride = frame.linesize_bytes() as usize;
let at = y * stride + x * 16;
let mut out = [0f32; 4];
for c in 0..4 { out[c] = f32::from_le_bytes(frame.data[at + c*4..at + c*4 + 4].try_into().unwrap()); }
out
}
fn eval_node_row(type_id: &str, inputs: NodeValueRow, frame_size: Option<(i32, i32)>) -> oak_core::texture::Frame {
use oak_node::traverser::RenderHooks;
let (core, behavior) = oak_node::factory::Factory::global().create_any(type_id).expect("node type registered");
let mut table = NodeValueTable::default();
behavior.value(&core, &inputs, Rational::new(0, 1), &mut table);
let mut hooks = oak_render::eval::RenderEvalHooks::new();
hooks.frame_size = frame_size;
hooks.resolve(oak_node::id::NodeId::INVALID, &inputs, &mut table);
let Some(NodeValue::Texture(handle)) = table.get(ValueType::Texture) else { panic!("{type_id}: no texture produced") };
if handle.ctx.is_null() { panic!("{type_id}: null texture produced"); }
let tex = unsafe { oak_node::handle::get_checked::<Texture>(handle) }.expect("resolved texture");
assert!(matches!(tex, Texture::Gpu { .. }), "{type_id}: must render on the GPU");
tex.to_frame().expect("readback")
}
const COLORCORRECT: &str = "org.olivevideoeditor.Olive.colorcorrect";
const GAMMA: &str = "org.olivevideoeditor.Olive.gamma";
const SATURATION: &str = "org.olivevideoeditor.Olive.saturation";
const INVERT: &str = "org.olivevideoeditor.Olive.invert";
const CLAMP: &str = "org.olivevideoeditor.Olive.clamp";
const GRADE: &str = "org.olivevideoeditor.Olive.grade";
/// A row carrying just the effect input, with `rgba` painted over the
/// whole 8x8 frame.
fn row_with(rgba: [f32; 4]) -> NodeValueRow {
let mut row = NodeValueRow::new();
row.insert("tex_in".to_string(), texture_value(filled_frame((8, 8), rgba)));
row
}
/// Insert float parameters (input id -> value).
fn set_floats(row: &mut NodeValueRow, params: &[(&str, f64)]) {
for (id, v) in params {
row.insert((*id).to_string(), NodeValue::Float(*v));
}
}
/// Insert boolean parameters (input id -> value).
fn set_bools(row: &mut NodeValueRow, params: &[(&str, bool)]) {
for (id, v) in params {
row.insert((*id).to_string(), NodeValue::Boolean(*v));
}
}
/// Assert the four channels of a pixel against the expected values.
fn assert_pixel(px: [f32; 4], want: [f32; 4], what: &str) {
for c in 0..4 {
assert!(
(px[c] - want[c]).abs() < 1e-3,
"{what}: channel {c}: got {px:?}, want {want:?}"
);
}
}
/// ColorCorrect on mid gray: the saturation lerp is an identity on gray,
/// so the chain reduces to the contrast/gamma/gain/offset passes.
/// `0.5 -> pow(0.5/0.18, 1.2)*0.18 = 0.6133516 -> ^(1/0.8) = 0.5427963
/// -> *1.1 = 0.5970759 -> +0.02 = 0.6170759`.
#[test]
fn colorcorrect_mid_gray_control_chain() {
if !gpu() {
eprintln!("no adapter; skipping");
return;
}
let mut row = row_with([0.5, 0.5, 0.5, 1.0]);
set_floats(
&mut row,
&[
("saturation_in", 0.5),
("contrast_in", 1.2),
("gamma_in", 0.8),
("gain_in", 1.1),
("offset_in", 0.02),
],
);
let frame = eval_node_row(COLORCORRECT, row, None);
for (x, y) in [(0, 0), (4, 4), (7, 7)] {
assert_pixel(
pixel_at(&frame, x, y),
[0.6170759, 0.6170759, 0.6170759, 1.0],
&format!("colorcorrect ({x},{y})"),
);
}
}
/// Gamma 2.0 is the square root: `pow(0.5, 1/2) = 0.7071068`. Alpha is
/// untouched.
#[test]
fn gamma_mid_gray_square_root() {
if !gpu() {
eprintln!("no adapter; skipping");
return;
}
let mut row = row_with([0.5, 0.5, 0.5, 1.0]);
set_floats(&mut row, &[("gamma_in", 2.0)]);
let frame = eval_node_row(GAMMA, row, None);
assert_pixel(
pixel_at(&frame, 4, 4),
[0.70710677, 0.70710677, 0.70710677, 1.0],
"gamma",
);
}
/// Saturation 0.5 on a non-gray pixel lerps halfway to its Rec. 709
/// luma (`0.2126*0.6 + 0.7152*0.4 + 0.0722*0.2 = 0.42808`), and is an
/// identity on gray. Alpha is untouched.
#[test]
fn saturation_half_lerps_to_luma() {
if !gpu() {
eprintln!("no adapter; skipping");
return;
}
let mut row = row_with([0.6, 0.4, 0.2, 1.0]);
set_floats(&mut row, &[("saturation_in", 0.5)]);
let frame = eval_node_row(SATURATION, row, None);
assert_pixel(
pixel_at(&frame, 4, 4),
[0.51404, 0.41404, 0.31404, 1.0],
"saturation on color",
);
let mut gray = row_with([0.5, 0.5, 0.5, 1.0]);
set_floats(&mut gray, &[("saturation_in", 0.5)]);
let gray_frame = eval_node_row(SATURATION, gray, None);
assert_pixel(
pixel_at(&gray_frame, 4, 4),
[0.5, 0.5, 0.5, 1.0],
"saturation on gray",
);
}
/// Invert defaults to all four toggles on: mid gray 0.5 becomes 0.5 in
/// RGB but the alpha flips to 0.0. With the alpha toggle off, an
/// asymmetric pixel flips only its color channels.
#[test]
fn invert_per_channel_toggles() {
if !gpu() {
eprintln!("no adapter; skipping");
return;
}
// All four toggles default to on.
let frame = eval_node_row(INVERT, row_with([0.5, 0.5, 0.5, 1.0]), None);
assert_pixel(pixel_at(&frame, 4, 4), [0.5, 0.5, 0.5, 0.0], "invert defaults");
// Alpha toggle off: only the color channels invert.
let mut row = row_with([0.25, 0.75, 0.5, 1.0]);
set_bools(
&mut row,
&[
("invert_r_in", true),
("invert_g_in", true),
("invert_b_in", true),
("invert_a_in", false),
],
);
let frame = eval_node_row(INVERT, row, None);
assert_pixel(
pixel_at(&frame, 4, 4),
[0.75, 0.25, 0.5, 1.0],
"invert without alpha",
);
}
/// Clamp raises mid gray to the 0.6 lower bound (alpha is clamped too,
/// matching the reference's `processA` default), and a 0.4 upper bound
/// pulls every channel down to 0.4.
#[test]
fn clamp_bounds_every_channel() {
if !gpu() {
eprintln!("no adapter; skipping");
return;
}
let mut row = row_with([0.5, 0.5, 0.5, 1.0]);
set_floats(&mut row, &[("min_in", 0.6), ("max_in", 1.0)]);
let frame = eval_node_row(CLAMP, row, None);
assert_pixel(pixel_at(&frame, 4, 4), [0.6, 0.6, 0.6, 1.0], "clamp to min");
let mut low = row_with([0.5, 0.5, 0.5, 1.0]);
set_floats(&mut low, &[("min_in", 0.0), ("max_in", 0.4)]);
let low_frame = eval_node_row(CLAMP, low, None);
assert_pixel(
pixel_at(&low_frame, 4, 4),
[0.4, 0.4, 0.4, 0.4],
"clamp to max",
);
}
/// Grade stretch + gamma: with the black point at 0.1 and the white
/// point at 0.6 the slope is `(1-0)/(0.6-0.1) = 2` and the offset
/// `-0.2`, so 0.5 maps to 0.8, then the gamma 2.0 pass gives
/// `pow(0.8, 0.5) = 0.8944272`. The defaults are an identity.
#[test]
fn grade_stretch_and_gamma() {
if !gpu() {
eprintln!("no adapter; skipping");
return;
}
let mut row = row_with([0.5, 0.5, 0.5, 1.0]);
set_floats(
&mut row,
&[
("blackpoint_in", 0.1),
("whitepoint_in", 0.6),
("black_in", 0.0),
("white_in", 1.0),
("gamma_in", 2.0),
],
);
let frame = eval_node_row(GRADE, row, None);
assert_pixel(
pixel_at(&frame, 4, 4),
[0.8944272, 0.8944272, 0.8944272, 1.0],
"grade stretch",
);
// Default points and gamma: identity.
let frame = eval_node_row(GRADE, row_with([0.5, 0.5, 0.5, 1.0]), None);
assert_pixel(pixel_at(&frame, 4, 4), [0.5, 0.5, 0.5, 1.0], "grade identity");
}
crates/oak-render/tests/ofxmisc_gen.rs
+213
View File
@@ -0,0 +1,213 @@
//! GPU pixel tests for the Tier-1 geometry/generator nodes (skip without GPU).
use oak_core::texture::Texture;
use oak_core::{PixelFormat, Rational};
use oak_node::value::{NodeValue, NodeValueRow, NodeValueTable, ValueType};
fn texture_value(t: Texture) -> NodeValue { NodeValue::Texture(oak_node::handle::make_owned(t)) }
fn gpu() -> bool { oak_core::backend::GpuContext::shared().is_some() }
fn filled_frame(size: (i32, i32), rgba: [f32; 4]) -> Texture {
let mut f = oak_render::eval::generate_frame(Rational::new(0, 1), size, PixelFormat::F32).unwrap();
for px in f.data.chunks_exact_mut(16) { for (c, v) in px.chunks_exact_mut(4).zip(rgba) { c.copy_from_slice(&v.to_le_bytes()); } }
Texture::wrap_frame(f)
}
fn pixel_at(frame: &oak_core::texture::Frame, x: usize, y: usize) -> [f32; 4] {
let stride = frame.linesize_bytes() as usize;
let at = y * stride + x * 16;
let mut out = [0f32; 4];
for c in 0..4 { out[c] = f32::from_le_bytes(frame.data[at + c*4..at + c*4 + 4].try_into().unwrap()); }
out
}
fn eval_node_row(type_id: &str, inputs: NodeValueRow, frame_size: Option<(i32, i32)>) -> oak_core::texture::Frame {
use oak_node::traverser::RenderHooks;
let (core, behavior) = oak_node::factory::Factory::global().create_any(type_id).expect("node type registered");
let mut table = NodeValueTable::default();
behavior.value(&core, &inputs, Rational::new(0, 1), &mut table);
let mut hooks = oak_render::eval::RenderEvalHooks::new();
hooks.frame_size = frame_size;
hooks.resolve(oak_node::id::NodeId::INVALID, &inputs, &mut table);
let Some(NodeValue::Texture(handle)) = table.get(ValueType::Texture) else { panic!("{type_id}: no texture produced") };
if handle.ctx.is_null() { panic!("{type_id}: null texture produced"); }
let tex = unsafe { oak_node::handle::get_checked::<Texture>(handle) }.expect("resolved texture");
assert!(matches!(tex, Texture::Gpu { .. }), "{type_id}: must render on the GPU");
tex.to_frame().expect("readback")
}
const POSITION: &str = "org.olivevideoeditor.Olive.position";
const MIRROR: &str = "org.olivevideoeditor.Olive.mirror";
const CHECKERBOARD: &str = "org.olivevideoeditor.Olive.checkerboard";
const COLORBARS: &str = "org.olivevideoeditor.Olive.colorbars";
const RAMP: &str = "org.olivevideoeditor.Olive.ramp";
const WHITE: [f32; 4] = [1.0, 1.0, 1.0, 1.0];
const BLACK: [f32; 4] = [0.0, 0.0, 0.0, 1.0];
/// Paint one RGBA pixel into a CPU frame (these F32 frames are 16 bytes a
/// pixel).
fn paint(frame: &mut oak_core::texture::Frame, x: usize, y: usize, rgba: [f32; 4]) {
let at = y * frame.linesize_bytes() as usize + x * 16;
for (c, v) in rgba.iter().enumerate() {
frame.data[at + c * 4..at + c * 4 + 4].copy_from_slice(&v.to_le_bytes());
}
}
/// Opaque black with a single white pixel at `(x, y)`.
fn white_pixel_frame(size: (i32, i32), x: usize, y: usize) -> Texture {
let mut frame = filled_frame(size, BLACK).to_frame().expect("cpu frame");
paint(&mut frame, x, y, WHITE);
Texture::wrap_frame(frame)
}
/// Opaque black with the left half (`x < size.0 / 2`) painted white.
fn left_white_frame(size: (i32, i32)) -> Texture {
let mut frame = filled_frame(size, BLACK).to_frame().expect("cpu frame");
for y in 0..size.1 as usize {
for x in 0..(size.0 / 2) as usize {
paint(&mut frame, x, y, WHITE);
}
}
Texture::wrap_frame(frame)
}
/// Assert the four channels of a pixel within the tests' 0.02 tolerance.
fn assert_pixel(px: [f32; 4], want: [f32; 4], what: &str) {
for c in 0..4 {
assert!(
(px[c] - want[c]).abs() < 0.02,
"{what}: channel {c}: got {px:?}, want {want:?}"
);
}
}
/// Position with a whole-pixel `offset_in`: the white pixel at (2, 3)
/// lands at (5, 5) (frame rows run downward, so the offset moves the image
/// right and down), and the source pixel it vacated reads black.
#[test]
fn position_shifts_a_white_pixel_by_whole_pixels() {
if !gpu() {
eprintln!("no adapter; skipping");
return;
}
let mut row = NodeValueRow::new();
row.insert(
"tex_in".to_string(),
texture_value(white_pixel_frame((8, 8), 2, 3)),
);
row.insert("offset_in".to_string(), NodeValue::Vec2([3.0, 2.0]));
let frame = eval_node_row(POSITION, row, None);
assert_pixel(pixel_at(&frame, 5, 5), WHITE, "position moved pixel");
assert_pixel(pixel_at(&frame, 2, 3), BLACK, "position vacated pixel");
assert_pixel(pixel_at(&frame, 0, 0), BLACK, "position untouched corner");
}
/// Mirror with `horizontal_in` on flips a one-sided white block about the
/// frame center: the left-half white block moves to the right half.
/// `vertical_in` stays at its default (off), so rows are untouched.
#[test]
fn mirror_horizontal_flips_the_white_block_to_the_other_side() {
if !gpu() {
eprintln!("no adapter; skipping");
return;
}
let mut row = NodeValueRow::new();
row.insert(
"tex_in".to_string(),
texture_value(left_white_frame((8, 8))),
);
row.insert("horizontal_in".to_string(), NodeValue::Boolean(true));
let frame = eval_node_row(MIRROR, row, None);
assert_pixel(pixel_at(&frame, 5, 3), WHITE, "mirror moved block");
assert_pixel(pixel_at(&frame, 2, 3), BLACK, "mirror vacated block");
assert_pixel(pixel_at(&frame, 7, 7), WHITE, "mirror bottom-right");
assert_pixel(pixel_at(&frame, 0, 7), BLACK, "mirror bottom-left");
}
/// Checkerboard with 4px boxes on an 8x8 frame: the parity of the cell
/// index sum picks the color, with `color1_in` (red) in the cells reaching
/// (0, 0), (3, 3) and (7, 7) and `color2_in` (green) in (7, 0), (0, 7),
/// (0, 4) and (4, 0).
#[test]
fn checkerboard_alternates_colors_by_cell_parity() {
if !gpu() {
eprintln!("no adapter; skipping");
return;
}
let mut row = NodeValueRow::new();
row.insert("size_in".to_string(), NodeValue::Vec2([4.0, 4.0]));
row.insert(
"color1_in".to_string(),
NodeValue::Color([1.0, 0.0, 0.0, 1.0]),
);
row.insert(
"color2_in".to_string(),
NodeValue::Color([0.0, 1.0, 0.0, 1.0]),
);
let frame = eval_node_row(CHECKERBOARD, row, Some((8, 8)));
for (x, y) in [(0, 0), (3, 3), (7, 7)] {
assert_pixel(
pixel_at(&frame, x, y),
[1.0, 0.0, 0.0, 1.0],
&format!("checkerboard color1 ({x},{y})"),
);
}
for (x, y) in [(7, 0), (0, 7), (0, 4), (4, 0)] {
assert_pixel(
pixel_at(&frame, x, y),
[0.0, 1.0, 0.0, 1.0],
&format!("checkerboard color2 ({x},{y})"),
);
}
}
/// Color bars at the default SMPTE 75% standard: the top-left pixel is the
/// 75% white bar, the pixel in the second bar is 75% yellow, and the
/// top-left of the mid strip is the 75% blue bar.
#[test]
fn colorbars_75_percent_white_yellow_and_blue_bars() {
if !gpu() {
eprintln!("no adapter; skipping");
return;
}
let frame = eval_node_row(COLORBARS, NodeValueRow::new(), Some((8, 8)));
assert_pixel(
pixel_at(&frame, 0, 0),
[0.75, 0.75, 0.75, 1.0],
"colorbars 75% white bar",
);
assert_pixel(
pixel_at(&frame, 1, 0),
[0.75, 0.75, 0.0, 1.0],
"colorbars yellow bar",
);
assert_pixel(
pixel_at(&frame, 0, 5),
[0.0, 0.0, 0.75, 1.0],
"colorbars mid-strip blue bar",
);
}
/// Ramp from (default) black at `point0_in` to (default) white at
/// `point1_in`: the gradient is the projection onto the p0->p1 axis, so an
/// axis spanning (-4.5, 0) -> (3.5, 0) gives 0.5 at the pixel whose center
/// is the midpoint, 0.125 one eighth of the way in, and 1.0 at the end.
#[test]
fn ramp_from_black_to_white_is_half_at_the_midpoint() {
if !gpu() {
eprintln!("no adapter; skipping");
return;
}
let mut row = NodeValueRow::new();
row.insert("point0_in".to_string(), NodeValue::Vec2([-4.5, 0.0]));
row.insert("point1_in".to_string(), NodeValue::Vec2([3.5, 0.0]));
let frame = eval_node_row(RAMP, row, Some((8, 8)));
assert_pixel(
pixel_at(&frame, 3, 3),
[0.5, 0.5, 0.5, 1.0],
"ramp midpoint",
);
assert_pixel(
pixel_at(&frame, 0, 3),
[0.125, 0.125, 0.125, 1.0],
"ramp near point0",
);
assert_pixel(pixel_at(&frame, 7, 3), WHITE, "ramp at point1");
}
crates/oak-render/tests/ofxmisc_matrix.rs
+168
View File
@@ -0,0 +1,168 @@
//! GPU pixel tests for the Tier-1 matrix/edge/morphology nodes (skip without GPU).
use oak_core::texture::Texture;
use oak_core::{PixelFormat, Rational};
use oak_node::value::{NodeValue, NodeValueRow, NodeValueTable, ValueType};
fn texture_value(t: Texture) -> NodeValue { NodeValue::Texture(oak_node::handle::make_owned(t)) }
fn gpu() -> bool { oak_core::backend::GpuContext::shared().is_some() }
fn filled_frame(size: (i32, i32), rgba: [f32; 4]) -> Texture {
let mut f = oak_render::eval::generate_frame(Rational::new(0, 1), size, PixelFormat::F32).unwrap();
for px in f.data.chunks_exact_mut(16) { for (c, v) in px.chunks_exact_mut(4).zip(rgba) { c.copy_from_slice(&v.to_le_bytes()); } }
Texture::wrap_frame(f)
}
fn pixel_at(frame: &oak_core::texture::Frame, x: usize, y: usize) -> [f32; 4] {
let stride = frame.linesize_bytes() as usize;
let at = y * stride + x * 16;
let mut out = [0f32; 4];
for c in 0..4 { out[c] = f32::from_le_bytes(frame.data[at + c*4..at + c*4 + 4].try_into().unwrap()); }
out
}
fn eval_node_row(type_id: &str, inputs: NodeValueRow, frame_size: Option<(i32, i32)>) -> oak_core::texture::Frame {
use oak_node::traverser::RenderHooks;
let (core, behavior) = oak_node::factory::Factory::global().create_any(type_id).expect("node type registered");
let mut table = NodeValueTable::default();
behavior.value(&core, &inputs, Rational::new(0, 1), &mut table);
let mut hooks = oak_render::eval::RenderEvalHooks::new();
hooks.frame_size = frame_size;
hooks.resolve(oak_node::id::NodeId::INVALID, &inputs, &mut table);
let Some(NodeValue::Texture(handle)) = table.get(ValueType::Texture) else { panic!("{type_id}: no texture produced") };
if handle.ctx.is_null() { panic!("{type_id}: null texture produced"); }
let tex = unsafe { oak_node::handle::get_checked::<Texture>(handle) }.expect("resolved texture");
assert!(matches!(tex, Texture::Gpu { .. }), "{type_id}: must render on the GPU");
tex.to_frame().expect("readback")
}
const COLORMATRIX: &str = "org.olivevideoeditor.Olive.colormatrix";
const EDGEDETECT: &str = "org.olivevideoeditor.Olive.edgedetect";
const DILATE: &str = "org.olivevideoeditor.Olive.dilate";
const ERODE: &str = "org.olivevideoeditor.Olive.erode";
/// A 16x16 F32 frame painted pixel by pixel from `paint(x, y)`.
fn painted_frame(paint: impl Fn(usize, usize) -> [f32; 4]) -> Texture {
let mut f = oak_render::eval::generate_frame(Rational::new(0, 1), (16, 16), PixelFormat::F32).unwrap();
let stride = f.linesize_bytes() as usize;
for y in 0..16 {
for x in 0..16 {
let at = y * stride + x * 16;
for (c, v) in paint(x, y).iter().enumerate() {
f.data[at + c * 4..at + c * 4 + 4].copy_from_slice(&v.to_le_bytes());
}
}
}
Texture::wrap_frame(f)
}
/// A row carrying just the texture effect input.
fn row_with(texture: Texture) -> NodeValueRow {
let mut row = NodeValueRow::new();
row.insert("tex_in".to_string(), texture_value(texture));
row
}
/// Assert the four channels of a pixel against the expected values.
fn assert_pixel(px: [f32; 4], want: [f32; 4], what: &str) {
for c in 0..4 {
assert!(
(px[c] - want[c]).abs() < 1e-3,
"{what}: channel {c}: got {px:?}, want {want:?}"
);
}
}
/// Identity matrix (the `m0..m15` input defaults): the color passes
/// through unchanged.
#[test]
fn colormatrix_identity_keeps_color() {
if !gpu() { eprintln!("no adapter; skipping"); return; }
let rgba = [0.25, 0.5, 0.75, 1.0];
let out = eval_node_row(COLORMATRIX, row_with(filled_frame((16, 16), rgba)), None);
assert_pixel(pixel_at(&out, 8, 8), rgba, "identity center");
assert_pixel(pixel_at(&out, 0, 0), rgba, "identity corner");
}
/// Red/green swap matrix (`m0..m15` row-major: R <- G and G <- R, the
/// rest identity) maps (1, 0, 0, 1) to (0, 1, 0, 1).
#[test]
fn colormatrix_swap_red_green() {
if !gpu() { eprintln!("no adapter; skipping"); return; }
let mut row = row_with(filled_frame((16, 16), [1.0, 0.0, 0.0, 1.0]));
let swap = [
0.0, 1.0, 0.0, 0.0, // R <- (R, G, B, A)
1.0, 0.0, 0.0, 0.0, // G <- (R, G, B, A)
0.0, 0.0, 1.0, 0.0, // B <- (R, G, B, A)
0.0, 0.0, 0.0, 1.0, // A <- (R, G, B, A)
];
for (i, v) in swap.iter().enumerate() {
row.insert(format!("m{i}"), NodeValue::Float(*v));
}
let out = eval_node_row(COLORMATRIX, row, None);
assert_pixel(pixel_at(&out, 8, 8), [0.0, 1.0, 0.0, 1.0], "swap");
}
/// The Sobel magnitude of a black/white step is 1 + 2 + 1 = 4.0 on the
/// two columns either side of the split (7 and 8) and 0.0 elsewhere in
/// RGB; the alpha channel passes through. A threshold above the
/// magnitude zeroes the whole frame.
#[test]
fn edgedetect_half_black_white_lights_boundary_columns() {
if !gpu() { eprintln!("no adapter; skipping"); return; }
let split = painted_frame(|x, _| {
if x < 8 { [0.0, 0.0, 0.0, 1.0] } else { [1.0, 1.0, 1.0, 1.0] }
});
let mut row = row_with(split);
row.insert("threshold_in".to_string(), NodeValue::Float(0.5));
let out = eval_node_row(EDGEDETECT, row, None);
for y in 0..16 {
for x in 0..16 {
let px = pixel_at(&out, x, y);
let rgb = if x == 7 || x == 8 { 4.0 } else { 0.0 };
assert_pixel(px, [rgb, rgb, rgb, 1.0], &format!("edgedetect ({x},{y})"));
}
}
// Threshold above 4.0: the step drops every magnitude.
let mut row = row_with(painted_frame(|x, _| {
if x < 8 { [0.0, 0.0, 0.0, 1.0] } else { [1.0, 1.0, 1.0, 1.0] }
}));
row.insert("threshold_in".to_string(), NodeValue::Float(10.0));
let out = eval_node_row(EDGEDETECT, row, None);
assert_pixel(pixel_at(&out, 7, 8), [0.0, 0.0, 0.0, 1.0], "edgedetect thresholded");
}
/// A single white pixel grows to its full 3x3 neighborhood at radius 1;
/// the rest of the frame stays black.
#[test]
fn dilate_single_pixel_grows_to_3x3() {
if !gpu() { eprintln!("no adapter; skipping"); return; }
let white = [1.0, 1.0, 1.0, 1.0];
let black = [0.0, 0.0, 0.0, 1.0];
let mut row = row_with(painted_frame(|x, y| if (x, y) == (8, 8) { white } else { black }));
row.insert("radius_in".to_string(), NodeValue::Float(1.0));
let out = eval_node_row(DILATE, row, None);
for y in 0..16 {
for x in 0..16 {
let want = if (7..=9).contains(&x) && (7..=9).contains(&y) { white } else { black };
assert_pixel(pixel_at(&out, x, y), want, &format!("dilate ({x},{y})"));
}
}
}
/// A 3x3 white block shrinks to its center pixel at radius 1; the rest
/// of the frame stays black.
#[test]
fn erode_white_block_shrinks_to_center() {
if !gpu() { eprintln!("no adapter; skipping"); return; }
let white = [1.0, 1.0, 1.0, 1.0];
let black = [0.0, 0.0, 0.0, 1.0];
let mut row = row_with(painted_frame(|x, y| {
if (7..=9).contains(&x) && (7..=9).contains(&y) { white } else { black }
}));
row.insert("radius_in".to_string(), NodeValue::Float(1.0));
let out = eval_node_row(ERODE, row, None);
for y in 0..16 {
for x in 0..16 {
let want = if (x, y) == (8, 8) { white } else { black };
assert_pixel(pixel_at(&out, x, y), want, &format!("erode ({x},{y})"));
}
}
}
crates/oak-render/tests/ofxmisc_merge.rs
+190
View File
@@ -0,0 +1,190 @@
//! GPU pixel tests for the Tier-1 merge nodes (skip without GPU).
use oak_core::texture::Texture;
use oak_core::{PixelFormat, Rational};
use oak_node::value::{NodeValue, NodeValueRow, NodeValueTable, ValueType};
fn texture_value(t: Texture) -> NodeValue { NodeValue::Texture(oak_node::handle::make_owned(t)) }
fn gpu() -> bool { oak_core::backend::GpuContext::shared().is_some() }
fn filled_frame(size: (i32, i32), rgba: [f32; 4]) -> Texture {
let mut f = oak_render::eval::generate_frame(Rational::new(0, 1), size, PixelFormat::F32).unwrap();
for px in f.data.chunks_exact_mut(16) { for (c, v) in px.chunks_exact_mut(4).zip(rgba) { c.copy_from_slice(&v.to_le_bytes()); } }
Texture::wrap_frame(f)
}
fn pixel_at(frame: &oak_core::texture::Frame, x: usize, y: usize) -> [f32; 4] {
let stride = frame.linesize_bytes() as usize;
let at = y * stride + x * 16;
let mut out = [0f32; 4];
for c in 0..4 { out[c] = f32::from_le_bytes(frame.data[at + c*4..at + c*4 + 4].try_into().unwrap()); }
out
}
fn eval_node_row(type_id: &str, inputs: NodeValueRow, frame_size: Option<(i32, i32)>) -> oak_core::texture::Frame {
use oak_node::traverser::RenderHooks;
let (core, behavior) = oak_node::factory::Factory::global().create_any(type_id).expect("node type registered");
let mut table = NodeValueTable::default();
behavior.value(&core, &inputs, Rational::new(0, 1), &mut table);
let mut hooks = oak_render::eval::RenderEvalHooks::new();
hooks.frame_size = frame_size;
hooks.resolve(oak_node::id::NodeId::INVALID, &inputs, &mut table);
let Some(NodeValue::Texture(handle)) = table.get(ValueType::Texture) else { panic!("{type_id}: no texture produced") };
if handle.ctx.is_null() { panic!("{type_id}: null texture produced"); }
let tex = unsafe { oak_node::handle::get_checked::<Texture>(handle) }.expect("resolved texture");
assert!(matches!(tex, Texture::Gpu { .. }), "{type_id}: must render on the GPU");
tex.to_frame().expect("readback")
}
const DISSOLVE: &str = "org.olivevideoeditor.Olive.dissolve";
const KEYMIX: &str = "org.olivevideoeditor.Olive.keymix";
const PREMULT: &str = "org.olivevideoeditor.Olive.premult";
const UNPREMULT: &str = "org.olivevideoeditor.Olive.unpremult";
/// Assert the four channels of a pixel against the expected values.
fn assert_pixel(px: [f32; 4], want: [f32; 4], what: &str) {
for c in 0..4 {
assert!(
(px[c] - want[c]).abs() < 1e-3,
"{what}: channel {c}: got {px:?}, want {want:?}"
);
}
}
/// A row with the two picture inputs (and the mask for keymix) painted
/// over the whole 8x8 frame.
fn merge_row(tex: [f32; 4], blend: [f32; 4]) -> NodeValueRow {
let mut row = NodeValueRow::new();
row.insert("tex_in".to_string(), texture_value(filled_frame((8, 8), tex)));
row.insert("blend_in".to_string(), texture_value(filled_frame((8, 8), blend)));
row
}
/// A row with just the effect input, plus the channel combo.
fn channel_row(rgba: [f32; 4], channel_input: &str, channel: i64) -> NodeValueRow {
let mut row = NodeValueRow::new();
row.insert("tex_in".to_string(), texture_value(filled_frame((8, 8), rgba)));
row.insert(channel_input.to_string(), NodeValue::Combo(channel));
row
}
/// Dissolve at mix 0.5 lerps halfway between red and green; the alpha
/// rides the same lerp (both inputs are opaque here).
#[test]
fn dissolve_half_mix_blends_inputs() {
if !gpu() {
eprintln!("no adapter; skipping");
return;
}
let mut row = merge_row([1.0, 0.0, 0.0, 1.0], [0.0, 1.0, 0.0, 1.0]);
row.insert("mix_in".to_string(), NodeValue::Float(0.5));
let frame = eval_node_row(DISSOLVE, row, Some((8, 8)));
assert_pixel(
pixel_at(&frame, 2, 2),
[0.5, 0.5, 0.0, 1.0],
"dissolve mix 0.5",
);
}
/// Mix 0 must leave the first input untouched.
#[test]
fn dissolve_zero_mix_keeps_first_input() {
if !gpu() {
eprintln!("no adapter; skipping");
return;
}
let mut row = merge_row([1.0, 0.0, 0.0, 1.0], [0.0, 1.0, 0.0, 1.0]);
row.insert("mix_in".to_string(), NodeValue::Float(0.0));
let frame = eval_node_row(DISSOLVE, row, Some((8, 8)));
assert_pixel(
pixel_at(&frame, 2, 2),
[1.0, 0.0, 0.0, 1.0],
"dissolve mix 0",
);
}
/// KeyMix keys on the mask's alpha: a fully transparent mask keeps the
/// input everywhere.
#[test]
fn keymix_transparent_mask_keeps_input() {
if !gpu() {
eprintln!("no adapter; skipping");
return;
}
let mut row = merge_row([1.0, 0.0, 0.0, 1.0], [0.0, 1.0, 0.0, 1.0]);
row.insert(
"mask_in".to_string(),
texture_value(filled_frame((8, 8), [0.0, 0.0, 0.0, 0.0])),
);
let frame = eval_node_row(KEYMIX, row, Some((8, 8)));
assert_pixel(
pixel_at(&frame, 2, 2),
[1.0, 0.0, 0.0, 1.0],
"keymix zero mask",
);
}
/// A fully opaque mask selects the blend everywhere.
#[test]
fn keymix_opaque_mask_takes_blend() {
if !gpu() {
eprintln!("no adapter; skipping");
return;
}
let mut row = merge_row([1.0, 0.0, 0.0, 1.0], [0.0, 1.0, 0.0, 1.0]);
row.insert(
"mask_in".to_string(),
texture_value(filled_frame((8, 8), [1.0, 1.0, 1.0, 1.0])),
);
let frame = eval_node_row(KEYMIX, row, Some((8, 8)));
assert_pixel(
pixel_at(&frame, 2, 2),
[0.0, 1.0, 0.0, 1.0],
"keymix opaque mask",
);
}
/// Premultiply scales RGB by the alpha channel; alpha is untouched.
#[test]
fn premult_scales_rgb_by_alpha() {
if !gpu() {
eprintln!("no adapter; skipping");
return;
}
let row = channel_row([1.0, 0.5, 0.25, 0.5], "premult_channel_in", 4);
let frame = eval_node_row(PREMULT, row, Some((8, 8)));
assert_pixel(
pixel_at(&frame, 2, 2),
[0.5, 0.25, 0.125, 0.5],
"premult alpha",
);
}
/// Unpremultiply is the inverse of premultiply within tolerance.
#[test]
fn unpremult_inverts_premult() {
if !gpu() {
eprintln!("no adapter; skipping");
return;
}
let row = channel_row([0.5, 0.25, 0.125, 0.5], "unpremult_channel_in", 4);
let frame = eval_node_row(UNPREMULT, row, Some((8, 8)));
assert_pixel(
pixel_at(&frame, 2, 2),
[1.0, 0.5, 0.25, 0.5],
"unpremult alpha",
);
}
/// A zero divisor is guarded: the pixel is passed through unchanged
/// rather than blowing up to infinity.
#[test]
fn unpremult_zero_alpha_passes_through() {
if !gpu() {
eprintln!("no adapter; skipping");
return;
}
let row = channel_row([0.5, 0.25, 0.125, 0.0], "unpremult_channel_in", 4);
let frame = eval_node_row(UNPREMULT, row, Some((8, 8)));
assert_pixel(
pixel_at(&frame, 2, 2),
[0.5, 0.25, 0.125, 0.0],
"unpremult zero guard",
);
}
docs/zh/plans/ofx-misc-gpu-cleanroom.md
+155
View File
@@ -0,0 +1,155 @@
# OpenFX-Misc 洁净室 GPU 重写（内置特效扩充）与特效分类/折叠计划
> 面向实现者的任务书（2026-09-10）。本文只描述方案与工作项，不含已执行的代码修改。
> 用户要求："把 OpenFX-Misc 洁净室重写为 GPU 版本，作为内置特效加入进去，并给内置特效
> 加分类和折叠分类的功能。"参考源码已克隆到本机 `/tmp/ofx-misc`（上游
> `github.com/cgvirus/OpenFX-Misc`，GPL2，86 个插件目录，README 有完整清单）。
>
> 法律/工程边界：**洁净室**指不复制其代码——我们只读其算法描述与参数语义，
> GLSL 与节点代码全部自写。仓内节点实现模式已有 60+ 先例（oak-node/src/nodes/*.rs），
> 本计划实质是"参照 OpenFX-Misc 的特效清单，按仓内既有节点模式补齐内置特效"。
## 1. 现状
### 1.1 节点/渲染管线（完全够用）
- 内置特效 = `oak-node/src/nodes/*.rs` 的 `NodeBehavior` 实现：声明输入（`Input`），
`value()` 推 `ShaderJobPayload`（`crates/oak-node/src/jobs.rs`），`shader_code()`
返回 GLSL 片段。渲染端 `crates/oak-render/src/eval.rs::process_shader_job`：
编译（naga→WGSL，**不支持 GLSL switch**——新 shader 一律 if/else，教训见提交
`37df1d3d3`）、按名绑定全部纹理参数、嵌套 payload 递归（深度上限 8）、
`resolution_in` 自动锚定序列分辨率（提交 `fc9060424`）、`iterations` 多轮 +
`previous_iteration_in` 反馈。GPU 像素测试模式：`eval.rs tests::eval_node_row`。
- 坐标/基准约定：像素空间以**画面中心**为原点（transform 语义，提交 `d028a45ff`）；
像素尺寸参数（半径/宽度/距离）按序列分辨率解释。
- 已有同类特效（避免重复）：blur、opacity、transform、crop、flip（Distort 系）、
merge、mrg（生成器 alpha-over）、math、chromakey、colordifferencekey、despill、
solid、polygon、shape、noise、ociobase/lut/grading、whitebalance、threewaycolor、
mask、stroke、dropshadow、displaytransform、cornerpin（假实现，另案）、
tile/swirl/ripple/wave（Distort 系）、trigonometry、volume、pan。
### 1.2 特效库 UI
- `crates/oak-app/src/oakui/effectchain.rs::addable_effects`：内置（`group: None`）
+ OFX 动态条目（`group: Some(子类)`），排序已按组+名字。
- `crates/oak-app/src/panels/effect_library.rs`：渲染时组头已存在
（`group_header()`，内置统一一个 "Built-in" 头），**不可折叠**；有搜索框。
- 检查器"添加特效"菜单（`panels/inspector.rs:157`）吃同一张 `addable_effects` 表。
## 2. 目标
1. 参照 OpenFX-Misc 清单，按 GPU 版本洁净室重写一批常用特效，作为**内置特效**
（oak-node 原生节点，非 OFX 运行时）加入。
2. 内置特效按功能分类（Color / Filter / Keying / Distort / Generator / Merge / Time），
特效库与检查器添加菜单都按分类分组，**分类可折叠**（折叠状态持久化）。
## 3. 特效分批（实现范围）
### Tier 1（本批必做，算法简单、GLSL 直译，全部像素可测）
| 特效（参考） | 分类 | 输入（节点参数） | 算法要点 |
|---|---|---|---|
| ColorCorrectOFX | Color | saturation/contrast/gamma/gain/offset（各 5 组：master/shadows/midtones/highlights）太多了→**简化为全局 5 参数**（saturation/contrast/gamma/gain/offset） | 逐像素 `offset+gain*pow(x,gamma)`，contrast 绕 0.18 灰，saturation 绕 luma |
| GammaOFX | Color | gamma（单值） | `pow(x, 1/g)` |
| SaturationOFX | Color | saturation | luma 插值（与 whitebalance/threeway 不重复：它最简） |
| InvertOFX | Color | channel 开关(RGBA) | `1-x`（按通道掩码） |
| ClampOFX | Color | min/max | clamp 每通道 |
| ColorMatrixOFX | Color | 4x4 矩阵（16 float） | 矩阵×RGBA（uniform mat4 已有先例：transform_in） |
| GradeOFX | Color | blackPoint/whitePoint/blackOut/whiteOut/gamma | 黑白点重映射 |
| DirBlurOFX | Filter | amount/angle | 方向模糊（迭代采样 N=16，角度→方向向量） |
| SharpenCImg | Filter | amount | unsharp mask：x + amount·(x − blur(x))（blur 复用现有迭代模糊，嵌套 payload） |
| EdgeDetectCImg | Filter | threshold/通道 | Sobel 幅值 |
| Dilate/ErodeCImg | Filter | radius/shape(rect) | 3×3~7×7 结构元 max/min（radius 控制迭代轮数） |
| DissolveOFX | Merge | mix(0..1)、第二输入 blend_in | 加权平均（merge.rs 双输入绑定已有先例；转场功能的原子件） |
| KeyMixOFX | Merge | mask_in、blend_in | 按 mask 拷贝（mask 绑定已有先例：chromakey 的 garbage/core matte） |
| PreMult/UnpremultOFX | Merge | channel 选择 | rgb *= a / rgb /= a（0 保护） |
| PositionOFX | Distort | offset xy（整数 px） | 采样偏移（resolution_in 换算） |
| MirrorOFX | Distort | horizontal/vertical | 翻转采样（flip 节点已有？若有重复则跳过——实现时先查 flip.rs 覆盖面） |
| CheckerBoardOFX | Generator | size/color1/color2 | 程序化棋盘格 |
| ColorBarsOFX | Generator | SMPTE/100%/75% | 彩条（分段填色） |
| RampOFX | Generator | point0/point1/color0/color1 | 线性渐变 |
| Rand（噪声已有） | — | — | **跳过**（noise.rs 已覆盖） |
| Constant（solid 已有） | — | — | **跳过** |
合计约 17 个新节点（Mirror 可能合并/跳过）。
### Tier 2（第二批，涉及曲线/对数/卷积/积雨云）
HSVTool（色相替换+keyer 能力）、Quantize（海报化/抖动）、Log2Lin/PLogLin、
ClipTest（斑马纹超范围指示）、Matrix3x3/Matrix5x5（通用卷积）、GodRays（径向
辉光，迭代采样）、ColorLookup（分通道曲线——**复用现有曲线编辑器**
`gpui_widgets::curve_editor` + `oak_plugin::param_curve` 的 JSON 模型，参数为 Text）。
### Tier 3（明确不做，写明理由）
- Roto（要主机遮罩编辑）、TrackerPM（点跟踪，需交互与多帧）、Card3D（3D 投影）、
STMap/IDistort（位移图输入——其实可做，列 Tier 2 备选）、Shadertoy（沙盒运行时）、
全部 Views/立体声（无多视图管线）、CImg 重型族（DenoiseSharpen/Smooth* PDE/Inpaint——
迭代 PDE 不适合实时 GPU 预览）、**全部时间域**（FrameBlend/FrameHold/Retime/
TimeBlur/SlitScan/TimeOffset/AppendClip——`ShaderJobPayload` 只能采当前时刻纹理，
多时刻采样需要 job 管线扩展，**单独立案**，不在本计划）。
## 4. 节点实现模板（所有新节点统一）
每个新节点 = `oak-node/src/nodes/` 一个文件，遵循既有模式（参照 `opacity.rs` /
`colorcorrect` 无、参照 `blur.rs`/`math.rs`）：
1. 常量输入 id + `create()`（输入、默认值、min/max、combo 字符串、`VIDEO_EFFECT` 标志、
`core.effect_input = "tex_in"`；双输入节点参考 merge.rs 的 base/blend）。
2. `value()`：无纹理直通（参考各节点的 `// CPP-PARITY` 注释体例），否则推
`ShaderJobPayload`（`shader_id: ""`，`iterations: 1`）。
3. `shader_code()`：GLSL 片段（ove_texcoord/frag_color；**禁用 switch**；
像素尺寸参数用 `resolution_in`；采样偏移用中心原点像素空间与否按特效语义——
颜色类与坐标无关，几何类参照 transform 的中心原点）。
4. `register()` 进 `nodes/mod.rs` 的注册表。
5. 单元测试（输入默认值/隐藏标志/job 参数）+ **`crates/oak-render/src/eval.rs`
GPU 像素测试**（eval_node_row 模式，无 GPU 自动跳过）。颜色类用纯色输入断言
输出值；几何/模糊类用点/块图案断言位移/扩散。
## 5. 分类与折叠（UI）
1. **内置特效分类**：`addable_effects()` 的内置分支改为 `group: Some(分类)`，
分类取自节点 `categories()` 首个 `Category` 映射：
`Category::Color→"调色"`（或英文 "Color"，跟 i18n key）、`Filter→"滤镜"`、
`Distort→"扭曲"`、`Keyer→"键控"`、`Generator→"生成器"`、`Merge→"合成"`、
`Time→"时间"`、`Math→"数学"`、`Channel→"通道"`。映射函数放
`effectchain.rs`（`node_category_key` 已有类似物，见 engine.rs:206，
但该函数是给节点编辑器菜单的 i18n key，特效库分组可直接复用同一 key 体系）。
i18n：8 语言加 `effect_library.group.<key>`。
2. **折叠**：`effect_library.rs` 组头加点击折叠/展开（箭头 ▶/▼ + 组名）：
- 面板 struct 增加 `collapsed: std::collections::HashSet<String>`（组 key），
点击组头切换；渲染时折叠组跳过其子行。
- 持久化：`oak_core::configstore`（参照现有 `UseProxyMedia` 等键的读写模式），
键 `EffectLibraryCollapsed`（逗号分隔组 key 列表）。
- 检查器的添加菜单（inspector.rs:157 的菜单构建）同样按组分组
（menu.rs 支持子菜单——组做子菜单，比折叠更适合菜单形态；实现时确认
`MenuItem::with_submenu` 用法，与 proxy_submenu 一致）。
3. 搜索时忽略折叠状态（搜索命中强制展开显示，已在循环内自然满足：
搜索非空时不跳过子行）。
## 6. 工作项（可分配给子代理的最小单元）
- **W1 Tier1 颜色组（6 节点）**：ColorCorrect/Gamma/Saturation/Invert/Clamp/Grade。
- **W2 Tier1 矩阵+卷积组（4 节点）**：ColorMatrix/EdgeDetect/Dilate/Erode
（+Tier2 的 Matrix3x3/5x5 若顺利一并）。
- **W3 Tier1 模糊/锐化组（2 节点）**：DirBlur/Sharpen。
- **W4 Tier1 合成组（4 节点）**：Dissolve/KeyMix/PreMult/Unpremult。
- **W5 Tier1 几何+生成器组（4~5 节点）**：Position/Mirror(或跳过)/CheckerBoard/
ColorBars/Ramp。
- **W6 分类与折叠 UI**：§5 全部（addable_effects 分组 + 特效库折叠 + 持久化 +
检查器子菜单 + i18n）。
- **W7 Tier2 批**：HSVTool/Quantize/Log2Lin/ClipTest/ColorLookup/GodRays
（W1-W6 完成并审查后再派）。
W1-W5 互相独立（不同文件），可并行派 5 个子代理；W6 独立；每个子代理须交付：
节点实现 + 单元测试 + GPU 像素测试 + `cargo test -p oak-node -p oak-render` 绿。
**统一禁令**：GLSL 不写 switch；不动 eval.rs/traverser 等管线文件（冲突根）；
遵循 nodes/ 既有文件体例（GPL 头、CPP-PARITY 注释、输入常量文档）。
## 7. 验收标准
1. Tier1 全部节点出现在特效库对应分类下，可加到 clip，画面效果正确（GPU 测试
逐节点覆盖核心算法）。
2. 特效库分类可折叠，重启 app 折叠状态保留；检查器添加菜单按分类分组。
3. 搜索框在任何折叠状态下都能搜到特效。
4. `cargo test --workspace` 全绿。