max/nodarium
1
0
Fork 0
Code Issues 12 Pull Requests 2 Actions Packages Projects Releases 3 Wiki Activity

feat: make all nodes work with new runtime

Browse Source
This commit is contained in:
Max Richter
2026-01-23 01:14:09 +01:00
parent 47882a832d
commit a497a46674
23 changed files with 494 additions and 244 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
nodes/max/plantarium/box/src/lib.rs
View File

@@ -3,18 +3,17 @@ use nodarium_macros::nodarium_execute;
use nodarium_utils::{
encode_float, evaluate_float, geometry::calculate_normals,log,
split_args, wrap_arg,
read_i32_slice
};
nodarium_definition_file!("src/input.json");
#[nodarium_execute]
pub fn execute(input: &[i32]) -> Vec<i32> {
pub fn execute(size: (i32, i32)) -> Vec<i32> {
let args = split_args(input);
let args = read_i32_slice(size);
log!("WASM(cube): input: {:?} -> {:?}", input, args);
let size = evaluate_float(args[0]);
let size = evaluate_float(&args);
let p = encode_float(size);
let n = encode_float(-size);
@@ -77,8 +76,6 @@ pub fn execute(input: &[i32]) -> Vec<i32> {
let res = wrap_arg(&cube_geometry);
log!("WASM(box): output: {:?}", res);
res
}

38
nodes/max/plantarium/branch/src/lib.rs
View File

@@ -1,5 +1,6 @@
use nodarium_macros::nodarium_definition_file;
use nodarium_macros::nodarium_execute;
use nodarium_utils::read_i32_slice;
use nodarium_utils::{
concat_arg_vecs, evaluate_float, evaluate_int,
geometry::{
@@ -13,15 +14,25 @@ use std::f32::consts::PI;
nodarium_definition_file!("src/input.json");
#[nodarium_execute]
pub fn execute(input: &[i32]) -> Vec<i32> {
let args = split_args(input);
let paths = split_args(args[0]);
pub fn execute(
path: (i32, i32),
length: (i32, i32),
thickness: (i32, i32),
offset_single: (i32, i32),
lowest_branch: (i32, i32),
highest_branch: (i32, i32),
depth: (i32, i32),
amount: (i32, i32),
resolution_curve: (i32, i32),
rotation: (i32, i32),
) -> Vec<i32> {
let arg = read_i32_slice(path);
let paths = split_args(arg.as_slice());
let mut output: Vec<Vec<i32>> = Vec::new();
let resolution = evaluate_int(args[8]).max(4) as usize;
let depth = evaluate_int(args[6]);
let resolution = evaluate_int(read_i32_slice(resolution_curve).as_slice()).max(4) as usize;
let depth = evaluate_int(read_i32_slice(depth).as_slice());
let mut max_depth = 0;
for path_data in paths.iter() {
@@ -40,18 +51,18 @@ pub fn execute(input: &[i32]) -> Vec<i32> {
let path = wrap_path(path_data);
let branch_amount = evaluate_int(args[7]).max(1);
let branch_amount = evaluate_int(read_i32_slice(amount).as_slice()).max(1);
let lowest_branch = evaluate_float(args[4]);
let highest_branch = evaluate_float(args[5]);
let lowest_branch = evaluate_float(read_i32_slice(lowest_branch).as_slice());
let highest_branch = evaluate_float(read_i32_slice(highest_branch).as_slice());
for i in 0..branch_amount {
let a = i as f32 / (branch_amount - 1).max(1) as f32;
let length = evaluate_float(args[1]);
let thickness = evaluate_float(args[2]);
let length = evaluate_float(read_i32_slice(length).as_slice());
let thickness = evaluate_float(read_i32_slice(thickness).as_slice());
let offset_single = if i % 2 == 0 {
evaluate_float(args[3])
evaluate_float(read_i32_slice(offset_single).as_slice())
} else {
0.0
};
@@ -65,7 +76,8 @@ pub fn execute(input: &[i32]) -> Vec<i32> {
root_alpha + (offset_single - 0.5) * 6.0 / resolution as f32,
);
let rotation_angle = (evaluate_float(args[9]) * PI / 180.0) * i as f32;
let rotation_angle =
(evaluate_float(read_i32_slice(rotation).as_slice()) * PI / 180.0) * i as f32;
// check if diration contains NaN
if orthogonal[0].is_nan() || orthogonal[1].is_nan() || orthogonal[2].is_nan() {

8
nodes/max/plantarium/float/src/lib.rs
View File

@@ -1,11 +1,11 @@
use nodarium_macros::nodarium_definition_file;
use nodarium_macros::nodarium_execute;
use nodarium_utils::log;
use nodarium_utils::{ log, read_f32, encode_float };
nodarium_definition_file!("src/input.json");
#[nodarium_execute]
pub fn execute(_value: *const i32) -> Vec<i32> {
log!("Duuuude");
vec![32]
pub fn execute(a: (i32, i32)) -> Vec<i32> {
let a_val = read_f32(a.0);
vec![encode_float(a_val)]
}

21
nodes/max/plantarium/gravity/src/lib.rs
View File

@@ -1,6 +1,7 @@
use glam::Vec3;
use nodarium_macros::nodarium_definition_file;
use nodarium_macros::nodarium_execute;
use nodarium_utils::read_i32_slice;
use nodarium_utils::{
concat_args, evaluate_float, evaluate_int,
geometry::{wrap_path, wrap_path_mut},
@@ -14,13 +15,17 @@ fn lerp_vec3(a: Vec3, b: Vec3, t: f32) -> Vec3 {
}
#[nodarium_execute]
pub fn execute(input: &[i32]) -> Vec<i32> {
pub fn execute(
plant: (i32, i32),
strength: (i32, i32),
curviness: (i32, i32),
depth: (i32, i32),
) -> Vec<i32> {
reset_call_count();
let args = split_args(input);
let plants = split_args(args[0]);
let depth = evaluate_int(args[3]);
let arg = read_i32_slice(plant);
let plants = split_args(arg.as_slice());
let depth = evaluate_int(read_i32_slice(depth).as_slice());
let mut max_depth = 0;
for path_data in plants.iter() {
@@ -55,9 +60,9 @@ pub fn execute(input: &[i32]) -> Vec<i32> {
let length = direction.length();
let curviness = evaluate_float(args[2]);
let strength =
evaluate_float(args[1]) / curviness.max(0.0001) * evaluate_float(args[1]);
let str = evaluate_float(read_i32_slice(strength).as_slice());
let curviness = evaluate_float(read_i32_slice(curviness).as_slice());
let strength = str / curviness.max(0.0001) * str;
log!(
"length: {}, curviness: {}, strength: {}",

30
nodes/max/plantarium/instance/src/lib.rs
View File

@@ -1,23 +1,29 @@
use glam::{Mat4, Quat, Vec3};
use nodarium_macros::nodarium_execute;
use nodarium_macros::nodarium_definition_file;
use nodarium_macros::nodarium_execute;
use nodarium_utils::read_i32_slice;
use nodarium_utils::{
concat_args, evaluate_float, evaluate_int,
geometry::{
create_instance_data, wrap_geometry_data, wrap_instance_data, wrap_path,
},
geometry::{create_instance_data, wrap_geometry_data, wrap_instance_data, wrap_path},
log, split_args,
};
nodarium_definition_file!("src/input.json");
#[nodarium_execute]
pub fn execute(input: &[i32]) -> Vec<i32> {
let args = split_args(input);
let mut inputs = split_args(args[0]);
pub fn execute(
plant: (i32, i32),
geometry: (i32, i32),
amount: (i32, i32),
lowest_instance: (i32, i32),
highest_instance: (i32, i32),
depth: (i32, i32),
) -> Vec<i32> {
let arg = read_i32_slice(plant);
let mut inputs = split_args(arg.as_slice());
log!("WASM(instance): inputs: {:?}", inputs);
let mut geo_data = args[1].to_vec();
let mut geo_data = read_i32_slice(geometry);
let geo = wrap_geometry_data(&mut geo_data);
let mut transforms: Vec<Mat4> = Vec::new();
@@ -30,17 +36,17 @@ pub fn execute(input: &[i32]) -> Vec<i32> {
max_depth = max_depth.max(path_data[3]);
}
let depth = evaluate_int(args[5]);
let depth = evaluate_int(read_i32_slice(depth).as_slice());
for path_data in inputs.iter() {
if path_data[3] < (max_depth - depth + 1) {
continue;
}
let amount = evaluate_int(args[2]);
let amount = evaluate_int(read_i32_slice(amount).as_slice());
let lowest_instance = evaluate_float(args[3]);
let highest_instance = evaluate_float(args[4]);
let lowest_instance = evaluate_float(read_i32_slice(lowest_instance).as_slice());
let highest_instance = evaluate_float(read_i32_slice(highest_instance).as_slice());
let path = wrap_path(path_data);

23
nodes/max/plantarium/math/src/lib.rs
View File

@@ -1,24 +1,13 @@
use nodarium_macros::nodarium_definition_file;
use nodarium_macros::nodarium_execute;
use nodarium_utils::{read_f32, read_i32, log};
use nodarium_utils::{concat_arg_vecs, encode_float, log, read_i32_slice};
nodarium_definition_file!("src/input.json");
#[nodarium_execute]
pub fn execute(op_type: *const i32, a: *const i32, b: *const i32) -> Vec<i32> {
let op = unsafe { read_i32(op_type) };
let a_val = unsafe { read_f32(a) };
let b_val = unsafe { read_f32(b) };
log!("op_type: {:?}", op);
let result = match op {
0 => a_val + b_val,
1 => a_val - b_val,
2 => a_val * b_val,
3 => a_val / b_val,
_ => 0.0,
};
vec![result.to_bits() as i32]
pub fn execute(op_type: (i32, i32), a: (i32, i32), b: (i32, i32)) -> Vec<i32> {
let op = read_i32_slice(op_type);
let a_val = read_i32_slice(a);
let b_val = read_i32_slice(b);
concat_arg_vecs(vec![vec![0], op, a_val, b_val])
}

33
nodes/max/plantarium/noise/src/lib.rs
View File

@@ -1,7 +1,8 @@
use nodarium_macros::nodarium_definition_file;
use nodarium_macros::nodarium_execute;
use nodarium_utils::read_i32_slice;
use nodarium_utils::{
concat_args, evaluate_float, evaluate_int, evaluate_vec3, geometry::wrap_path_mut,
concat_args, evaluate_float, evaluate_int, evaluate_vec3, geometry::wrap_path_mut, read_i32,
reset_call_count, split_args,
};
use noise::{HybridMulti, MultiFractal, NoiseFn, OpenSimplex};
@@ -13,23 +14,31 @@ fn lerp(a: f32, b: f32, t: f32) -> f32 {
}
#[nodarium_execute]
pub fn execute(input: &[i32]) -> Vec<i32> {
pub fn execute(
plant: (i32, i32),
scale: (i32, i32),
strength: (i32, i32),
fix_bottom: (i32, i32),
seed: (i32, i32),
directional_strength: (i32, i32),
depth: (i32, i32),
octaves: (i32, i32),
) -> Vec<i32> {
reset_call_count();
let args = split_args(input);
let arg = read_i32_slice(plant);
let plants = split_args(arg.as_slice());
let scale = (evaluate_float(read_i32_slice(scale).as_slice()) * 0.1) as f64;
let strength = evaluate_float(read_i32_slice(strength).as_slice());
let fix_bottom = evaluate_float(read_i32_slice(fix_bottom).as_slice());
let plants = split_args(args[0]);
let scale = (evaluate_float(args[1]) * 0.1) as f64;
let strength = evaluate_float(args[2]);
let fix_bottom = evaluate_float(args[3]);
let seed = read_i32(seed.0);
let seed = args[4][0];
let directional_strength = evaluate_vec3(read_i32_slice(directional_strength).as_slice());
let directional_strength = evaluate_vec3(args[5]);
let depth = evaluate_int(read_i32_slice(depth).as_slice());
let depth = evaluate_int(args[6]);
let octaves = evaluate_int(args[7]);
let octaves = evaluate_int(read_i32_slice(octaves).as_slice());
let noise_x: HybridMulti<OpenSimplex> =
HybridMulti::new(seed as u32 + 1).set_octaves(octaves as usize);

9
nodes/max/plantarium/output/src/lib.rs
View File

@@ -1,9 +1,14 @@
use nodarium_macros::nodarium_definition_file;
use nodarium_macros::nodarium_execute;
use nodarium_utils::log;
use nodarium_utils::read_i32_slice;
nodarium_definition_file!("src/input.json");
#[nodarium_execute]
pub fn execute(_input: *const i32, _res: *const i32) -> Vec<i32> {
return vec![0];
pub fn execute(input: (i32, i32), _res: (i32, i32)) -> Vec<i32> {
log!("HERE");
let mut vecs = read_i32_slice(input);
vecs.push(42);
vecs
}

0
nodes/max/plantarium/random/src/definition.json → nodes/max/plantarium/random/src/input.json
View File

15
nodes/max/plantarium/random/src/lib.rs
View File

@@ -1,11 +1,16 @@
use nodarium_macros::nodarium_definition_file;
use nodarium_macros::nodarium_execute;
use nodarium_utils::{concat_args, split_args};
use nodarium_utils::concat_arg_vecs;
use nodarium_utils::read_i32_slice;
nodarium_definition_file!("src/definition.json");
nodarium_definition_file!("src/input.json");
#[nodarium_execute]
pub fn execute(args: &[i32]) -> Vec<i32> {
let args = split_args(args);
concat_args(vec![&[1], args[0], args[1], args[2]])
pub fn execute(min: (i32, i32), max: (i32, i32), seed: (i32, i32)) -> Vec<i32> {
concat_arg_vecs(vec![
vec![1],
read_i32_slice(min),
read_i32_slice(max),
read_i32_slice(seed),
])
}

25
nodes/max/plantarium/rotate/src/lib.rs
View File

@@ -1,23 +1,26 @@
use glam::{Mat4, Vec3};
use nodarium_macros::nodarium_definition_file;
use nodarium_macros::nodarium_execute;
use nodarium_utils::read_i32_slice;
use nodarium_utils::{
concat_args, evaluate_float, evaluate_int, geometry::wrap_path_mut, log,
split_args,
concat_args, evaluate_float, evaluate_int, geometry::wrap_path_mut, log, split_args,
};
nodarium_definition_file!("src/input.json");
#[nodarium_execute]
pub fn execute(input: &[i32]) -> Vec<i32> {
pub fn execute(
plant: (i32, i32),
axis: (i32, i32),
angle: (i32, i32),
spread: (i32, i32),
) -> Vec<i32> {
log!("DEBUG args: {:?}", plant);
log!("DEBUG args: {:?}", input);
let args = split_args(input);
let plants = split_args(args[0]);
let axis = evaluate_int(args[1]); // 0 =x, 1 = y, 2 = z
let spread = evaluate_int(args[3]);
let arg = read_i32_slice(plant);
let plants = split_args(arg.as_slice());
let axis = evaluate_int(read_i32_slice(axis).as_slice()); // 0 =x, 1 = y, 2 = z
let spread = evaluate_int(read_i32_slice(spread).as_slice());
let output: Vec<Vec<i32>> = plants
.iter()
@@ -32,7 +35,7 @@ pub fn execute(input: &[i32]) -> Vec<i32> {
let path = wrap_path_mut(&mut path_data);
let angle = evaluate_float(args[2]);
let angle = evaluate_float(read_i32_slice(angle).as_slice());
let origin = [path.points[0], path.points[1], path.points[2]];

17
nodes/max/plantarium/stem/src/lib.rs
View File

@@ -4,29 +4,28 @@ use nodarium_utils::{
evaluate_float, evaluate_int, evaluate_vec3,
geometry::{create_multiple_paths, wrap_multiple_paths},
log, reset_call_count, split_args,
read_i32_slice, read_i32,
};
nodarium_definition_file!("src/input.json");
#[nodarium_execute]
pub fn execute(input: &[i32]) -> Vec<i32> {
pub fn execute(origin: (i32, i32), _amount: (i32,i32), length: (i32, i32), thickness: (i32, i32), resolution_curve: (i32, i32)) -> Vec<i32> {
reset_call_count();
let args = split_args(input);
let amount = evaluate_int(read_i32_slice(_amount).as_slice()) as usize;
let path_resolution = read_i32(resolution_curve.0) as usize;
let amount = evaluate_int(args[1]) as usize;
let path_resolution = evaluate_int(args[4]) as usize;
log!("stem args: {:?}", args);
log!("stem args: amount={:?}", amount);
let mut stem_data = create_multiple_paths(amount, path_resolution, 1);
let mut stems = wrap_multiple_paths(&mut stem_data);
for stem in stems.iter_mut() {
let origin = evaluate_vec3(args[0]);
let length = evaluate_float(args[2]);
let thickness = evaluate_float(args[3]);
let origin = evaluate_vec3(read_i32_slice(origin).as_slice());
let length = evaluate_float(read_i32_slice(length).as_slice());
let thickness = evaluate_float(read_i32_slice(thickness).as_slice());
let amount_points = stem.points.len() / 4;
for i in 0..amount_points {

55
nodes/max/plantarium/triangle/src/lib.rs
View File

@@ -1,45 +1,48 @@
use nodarium_macros::nodarium_definition_file;
use nodarium_macros::nodarium_execute;
use nodarium_utils::{
decode_float, encode_float, evaluate_int, split_args, wrap_arg, log
};
use nodarium_utils::read_i32_slice;
use nodarium_utils::{decode_float, encode_float, evaluate_int, log, split_args, wrap_arg};
nodarium_definition_file!("src/input.json");
#[nodarium_execute]
pub fn execute(input: &[i32]) -> Vec<i32> {
let args = split_args(input);
let size = evaluate_int(args[0]);
pub fn execute(size: (i32, i32)) -> Vec<i32> {
let size = evaluate_int(read_i32_slice(size).as_slice());
let decoded = decode_float(size);
let negative_size = encode_float(-decoded);
log!("WASM(triangle): input: {:?} -> {}", args[0],decoded);
log!("WASM(triangle): input: {:?} -> {}", size, decoded);
// [[1,3, x, y, z, x, y,z,x,y,z]];
wrap_arg(&[
1, // 1: geometry
3, // 3 vertices
1, // 1 face
1, // 1: geometry
3, // 3 vertices
1, // 1 face
// this are the indeces for the face
0, 2, 1,
0,
2,
1,
//
negative_size, // x -> point 1
0, // y
0, // z
negative_size, // x -> point 1
0, // y
0, // z
//
size, // x -> point 2
0, // y
0, // z
size, // x -> point 2
0, // y
0, // z
//
0, // x -> point 3
0, // y
size, // z
0, // x -> point 3
0, // y
size, // z
// this is the normal for the single face 1065353216 == 1.0f encoded is i32
0, 1065353216, 0,
0, 1065353216, 0,
0, 1065353216, 0,
0,
1065353216,
0,
0,
1065353216,
0,
0,
1065353216,
0,
])
}

13
nodes/max/plantarium/vec3/src/lib.rs
View File

@@ -1,13 +1,16 @@
use nodarium_macros::nodarium_definition_file;
use nodarium_macros::nodarium_execute;
use nodarium_utils::concat_arg_vecs;
use nodarium_utils::read_i32_slice;
use nodarium_utils::{concat_args, log, split_args};
nodarium_definition_file!("src/input.json");
#[nodarium_execute]
pub fn execute(input: &[i32]) -> Vec<i32> {
let args = split_args(input);
log!("vec3 input: {:?}", input);
log!("vec3 args: {:?}", args);
concat_args(args)
pub fn execute(x: (i32, i32), y: (i32, i32), z: (i32, i32)) -> Vec<i32> {
concat_arg_vecs(vec![
read_i32_slice(x),
read_i32_slice(y),
read_i32_slice(z),
])
}