use cubecl::prelude::*;
pub const CUBE_DIM: u32 = 256;
pub const STRIDE: u32 = 4;
#[cube(launch_unchecked)]
pub fn repulse(
positions: &[f32],
forces: &mut [f32],
n: u32,
repulsion: f32,
min_distance: f32,
#[comptime] tile_floats: usize,
) {
let mut tile = Shared::<[f32]>::new_slice(tile_floats);
let stride = STRIDE as usize;
let width = CUBE_DIM as usize;
let count_n = n as usize;
let i = ABSOLUTE_POS;
let unit = UNIT_POS as usize;
let last = count_n - 1;
let mut mine = i;
if mine > last {
mine = last;
}
let base_i = mine * stride;
let px = positions[base_i];
let py = positions[base_i + 1];
let pz = positions[base_i + 2];
let softening = min_distance * min_distance;
let mut fx = 0.0f32;
let mut fy = 0.0f32;
let mut fz = 0.0f32;
let tiles = count_n.div_ceil(width);
let mut t = 0usize;
while t < tiles {
let mut j = t * width + unit;
if j > last {
j = last;
}
let src = j * stride;
let dst = unit * stride;
tile[dst] = positions[src];
tile[dst + 1] = positions[src + 1];
tile[dst + 2] = positions[src + 2];
sync_cube();
let start = t * width;
let mut count = width;
if count_n - start < width {
count = count_n - start;
}
let mut k = 0usize;
while k < count {
let other = k * stride;
let dx = px - tile[other];
let dy = py - tile[other + 1];
let dz = pz - tile[other + 2];
let d2 = dx * dx + dy * dy + dz * dz + softening;
let inv = repulsion / (d2 * f32::sqrt(d2));
fx += dx * inv;
fy += dy * inv;
fz += dz * inv;
k += 1;
}
sync_cube();
t += 1;
}
if i < count_n {
let out = i * stride;
forces[out] = fx;
forces[out + 1] = fy;
forces[out + 2] = fz;
forces[out + 3] = 0.0f32;
}
}
#[cube(launch_unchecked)]
pub fn springs(
positions: &[f32],
forces: &mut [f32],
offsets: &[u32],
targets: &[u32],
n: u32,
spring_k: f32,
rest_length: f32,
) {
let stride = STRIDE as usize;
let i = ABSOLUTE_POS;
if i < n as usize {
let base = i * stride;
let px = positions[base];
let py = positions[base + 1];
let pz = positions[base + 2];
let mut fx = forces[base];
let mut fy = forces[base + 1];
let mut fz = forces[base + 2];
let mut e = offsets[i] as usize;
let end = offsets[i + 1] as usize;
while e < end {
let target = targets[e] as usize * stride;
let dx = positions[target] - px;
let dy = positions[target + 1] - py;
let dz = positions[target + 2] - pz;
let mut len = f32::sqrt(dx * dx + dy * dy + dz * dz);
if len < 1.0e-4f32 {
len = 1.0e-4f32;
}
let scale = spring_k * (len - rest_length) / len;
fx += dx * scale;
fy += dy * scale;
fz += dz * scale;
e += 1;
}
forces[base] = fx;
forces[base + 1] = fy;
forces[base + 2] = fz;
}
}
#[cube(launch_unchecked)]
pub fn integrate(
positions: &mut [f32],
velocities: &mut [f32],
forces: &[f32],
settle: &mut [Atomic<u32>],
n: u32,
dt: f32,
damping: f32,
centering: f32,
) {
let stride = STRIDE as usize;
let i = ABSOLUTE_POS;
if i < n as usize {
let base = i * stride;
let px = positions[base];
let py = positions[base + 1];
let pz = positions[base + 2];
let ax = forces[base] - px * centering;
let ay = forces[base + 1] - py * centering;
let az = forces[base + 2] - pz * centering;
let vx = (velocities[base] + ax * dt) * damping;
let vy = (velocities[base + 1] + ay * dt) * damping;
let vz = (velocities[base + 2] + az * dt) * damping;
positions[base] = px + vx * dt;
positions[base + 1] = py + vy * dt;
positions[base + 2] = pz + vz * dt;
velocities[base] = vx;
velocities[base + 1] = vy;
velocities[base + 2] = vz;
velocities[base + 3] = 0.0f32;
let speed = f32::sqrt(vx * vx + vy * vy + vz * vz);
Atomic::fetch_max(&settle[0], u32::reinterpret(speed));
}
}
#[cube(launch_unchecked)]
pub fn clear_settle(settle: &mut [Atomic<u32>]) {
if ABSOLUTE_POS < 1 {
Atomic::store(&settle[0], 0u32);
}
}