Piston Developers 🍿🥤🐸
@pistondeveloper.bsky.social
A modular game engine written in Rust https://piston.rs
Research branch: https://advancedresearch.github.io
Discord (Piston): https://discord.gg/TkDnS9x
Discord (AdvancedResearch): https://discord.gg/JkrhJJRBR2
Research branch: https://advancedresearch.github.io
Discord (Piston): https://discord.gg/TkDnS9x
Discord (AdvancedResearch): https://discord.gg/JkrhJJRBR2
I've figured out a way to improve run-length compression on masks in Turbine-Process3D over 10x faster using pre-masks:
Compression: 21.360625982284546 sec (79.224%)
Avg per tile: 0.008900260825951894 sec
Compression: 1.4767029285430908 sec (21.383%)
Avg per tile: 0.0006152928868929545 sec
Compression: 21.360625982284546 sec (79.224%)
Avg per tile: 0.008900260825951894 sec
Compression: 1.4767029285430908 sec (21.383%)
Avg per tile: 0.0006152928868929545 sec
November 25, 2025 at 1:26 PM
I've figured out a way to improve run-length compression on masks in Turbine-Process3D over 10x faster using pre-masks:
Compression: 21.360625982284546 sec (79.224%)
Avg per tile: 0.008900260825951894 sec
Compression: 1.4767029285430908 sec (21.383%)
Avg per tile: 0.0006152928868929545 sec
Compression: 21.360625982284546 sec (79.224%)
Avg per tile: 0.008900260825951894 sec
Compression: 1.4767029285430908 sec (21.383%)
Avg per tile: 0.0006152928868929545 sec
Today I made a new goblet Dyon script, and I added support for snow in my planet generator (in voxels).
November 24, 2025 at 9:51 PM
Today I made a new goblet Dyon script, and I added support for snow in my planet generator (in voxels).
Here's the Dyon code:
![pyramid() = link {
"palette ["
"0:000000a0;1:ffffffa0;"
"]\n"
"voxels ["
n := 200
link i n, j n {
fx := n - (abs(i - (n-1)/2) + (n-1)/2)
fy := n - (abs(j - (n-1)/2) + (n-1)/2)
h := round(min([fx, fy]))
if ((i + j) % 2) == 0 {1} else {0}":"i" "h" "j";"
}
"]"
}](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:olippfg4rukwzrkxsdwpd5bc/bafkreic7xrro3rio2gc6twjg2mfhdpxfbq55wpkqpkvhh46g2zby7r2qgm@jpeg)
November 24, 2025 at 4:25 PM
Here's the Dyon code:
This is a pyramid with semi-transparent voxels in chess pattern, 200x200 (40 000 voxels):
It took just a few seconds to run the Dyon script and render.
File size? 469 KB (95 KB compressed).
Memory usage? 56.4 MB.
Turbine-Process3D is amazing. ON THE CPU!
It took just a few seconds to run the Dyon script and render.
File size? 469 KB (95 KB compressed).
Memory usage? 56.4 MB.
Turbine-Process3D is amazing. ON THE CPU!
November 24, 2025 at 4:15 PM
This is a pyramid with semi-transparent voxels in chess pattern, 200x200 (40 000 voxels):
It took just a few seconds to run the Dyon script and render.
File size? 469 KB (95 KB compressed).
Memory usage? 56.4 MB.
Turbine-Process3D is amazing. ON THE CPU!
It took just a few seconds to run the Dyon script and render.
File size? 469 KB (95 KB compressed).
Memory usage? 56.4 MB.
Turbine-Process3D is amazing. ON THE CPU!
Yup, shrinking the Aabb on voxels removes the artifacts:
November 24, 2025 at 11:15 AM
Yup, shrinking the Aabb on voxels removes the artifacts:
You can now work with volumetric fog for voxels (or closed volumes in general). If two surfaces overlap and share the same color, then you can use an Accumulator that takes a union of the two volumes.
However,be aware that fog-to-fog (two different semi-transparent colors) produces some noise:
However,be aware that fog-to-fog (two different semi-transparent colors) produces some noise:
November 24, 2025 at 2:04 AM
You can now work with volumetric fog for voxels (or closed volumes in general). If two surfaces overlap and share the same color, then you can use an Accumulator that takes a union of the two volumes.
However,be aware that fog-to-fog (two different semi-transparent colors) produces some noise:
However,be aware that fog-to-fog (two different semi-transparent colors) produces some noise:
Finally, the code for TileRgbaSemiFogAcc:
![/// Accumulator for tile rendering, using Rgba colors and semi-fog effect for alpha over blending.
///
/// This is used to compose colors from triangles into a final color.
pub struct TileRgbaSemiFogAcc<const TILE_SIZE: usize, const ACC: usize> {
pub buf: [[[(f32, Rgba); ACC]; TILE_SIZE]; TILE_SIZE],
pub len: [[u8; TILE_SIZE]; TILE_SIZE],
}
impl<const TILE_SIZE: usize, const ACC: usize> Acc for TileRgbaSemiFogAcc<TILE_SIZE, ACC> {
type Data = ();
type In = Rgba;
type Out = Rgba;
fn new(_: ()) -> Self {
Self {
buf: [[[(0.0, [0.0; 4]); ACC]; TILE_SIZE]; TILE_SIZE],
len: [[0; TILE_SIZE]; TILE_SIZE],
}
}
fn clear(&mut self) {
self.buf = [[[(0.0, [0.0; 4]); ACC]; TILE_SIZE]; TILE_SIZE];
self.len = [[0; TILE_SIZE]; TILE_SIZE];
}
fn upd(&mut self, i: u32, j: u32, depth: f32, color: Rgba) {
let len = {
let len = &mut self.len[j as usize][i as usize];
if *len as usize >= ACC {return};
*len += 1;
*len
};
self.ins(len, i, j, depth, color);
}
fn acc(&self, i: u32, j: u32) -> Rgba {
let len = self.len[j as usize][i as usize];
let buf = &self.buf[j as usize][i as usize];
let mut color = [0.0; 4];
let mut fog = FogState::None;
for k in 0..len {
let (d, c) = buf[k as usize];
fog = fog.update(d, c);
fog.acc_alpha_blend_over(d, c, &mut color);
}
fog.acc_end_alpha_blend_over(&mut color);
color
}
}
impl<const TILE_SIZE: usize, const ACC: usize> TileRgbaSemiFogAcc<TILE_SIZE, ACC> {
pub fn ins(&mut self, len: u8, i: u32, j: u32, mut depth: f32, mut color: Rgba) {
let buf = &mut self.buf[j as usize][i as usize];
for k in 0..len {
let (d, c) = buf[k as usize];
if d == 0.0 {
buf[k as usize] = (depth, color);
return;
} else if …](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:olippfg4rukwzrkxsdwpd5bc/bafkreic2ll7vc5qklo4thsdnj7hsynbnshokpdqwdughdf2eyuyfrzs37m@jpeg)
November 23, 2025 at 2:32 PM
Finally, the code for TileRgbaSemiFogAcc:
Two basic functions to calculate the volumetric fog effect:
November 23, 2025 at 2:27 PM
Two basic functions to calculate the volumetric fog effect:
This a new Acc trait that will be added to Turbine-Process3D for Accumulators, together with FogState, plus a simple tile color accumulator using volumetric fog:
November 23, 2025 at 2:25 PM
This a new Acc trait that will be added to Turbine-Process3D for Accumulators, together with FogState, plus a simple tile color accumulator using volumetric fog:
Despite this seemingly simple effect, it has a lot of edge cases.
This is the FogState code:
This is the FogState code:
![#[derive(Copy, Clone)]
pub enum FogState {
None,
Start {color: Rgba, depth: f32, distance: f32},
End {color: Rgba, distance: f32},
Commit {color: Rgba, distance: f32},
}
impl FogState {
pub fn update(self, d: f32, c: Rgba) -> FogState {
use FogState::*;
match self {
None | Commit {..} =>
if c[3] < 1.0 {Start {color: c, depth: d, distance: 0.0}} else {None},
End {color, distance} => {
if c == color {Start {color, depth: d, distance}}
else {Commit {color, distance}}
}
Start {color, depth, distance} => {
let distance = (d - depth).abs() + distance;
if c == color {End {color, distance}}
else {Commit {color, distance}}
}
}
}
pub fn acc_alpha_blend_over(&mut self, d: f32, c: Rgba, acc_color: &mut Rgba) {
use turbine_process3d::color::rgba_alpha_blending_srgb_over;
match self {
FogState::None => {
*acc_color = rgba_alpha_blending_srgb_over(*acc_color, c);
}
FogState::Start{..} |
FogState::End{..} => {}
FogState::Commit {color: fog_color, distance} => {
let fx = volumetric_fog_fx(fog_color[3], *distance);
let [r, g, b, a] = *fog_color;
let c2 = [r, g, b, volumetric_fog_alpha(a, fx, *distance)];
*acc_color = rgba_alpha_blending_srgb_over(*acc_color, c2);
if c[3] < 1.0 {
*self = FogState::Start {color: c, depth: d, distance: 0.0};
} else {
*self = FogState::None;
*acc_color = rgba_alpha_blending_srgb_over(*acc_color, c);
}
}
}
}
pub fn acc_end_alpha_blend_over(&mut self, acc_color: &mut Rgba) {
use turbine_process3d::color::rgba_alpha_blending_srgb_over;
match self…](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:olippfg4rukwzrkxsdwpd5bc/bafkreiaghhmvlnopj65jf5aaohrgakvylw6htrpdvnhhez5mso7hlsr6sq@jpeg)
November 23, 2025 at 2:20 PM
Despite this seemingly simple effect, it has a lot of edge cases.
This is the FogState code:
This is the FogState code:
Finally, I got an Accumulator working that does seamless transition from opaque to semi-transparent voxels, using a variant of volumetric fog, that retreats to opaque for high alpha values:
November 23, 2025 at 1:55 PM
Finally, I got an Accumulator working that does seamless transition from opaque to semi-transparent voxels, using a variant of volumetric fog, that retreats to opaque for high alpha values:
I've added a new `RayHitAll` to Turbine-Process3D.
I figured out that `RayHit` is too limited when you want to render semi-transparent objects. `RayHitAll` uses a new `IndexFlag` structure that wraps `usize` and `bool` into `i64`.
I figured out that `RayHit` is too limited when you want to render semi-transparent objects. `RayHitAll` uses a new `IndexFlag` structure that wraps `usize` and `bool` into `i64`.
November 22, 2025 at 8:05 PM
I've added a new `RayHitAll` to Turbine-Process3D.
I figured out that `RayHit` is too limited when you want to render semi-transparent objects. `RayHitAll` uses a new `IndexFlag` structure that wraps `usize` and `bool` into `i64`.
I figured out that `RayHit` is too limited when you want to render semi-transparent objects. `RayHitAll` uses a new `IndexFlag` structure that wraps `usize` and `bool` into `i64`.
It kind of works:
November 22, 2025 at 6:07 AM
It kind of works:
Got semi-transparent objects working:
I use an finite accumulator that sorts colors by depth and calculates the final color. Here, it can only render 64 layers.
I use an finite accumulator that sorts colors by depth and calculates the final color. Here, it can only render 64 layers.
November 22, 2025 at 4:07 AM
Got semi-transparent objects working:
I use an finite accumulator that sorts colors by depth and calculates the final color. Here, it can only render 64 layers.
I use an finite accumulator that sorts colors by depth and calculates the final color. Here, it can only render 64 layers.
I'm tempted to add a new method to the `Produce` trait that translates addresses from produced memory to internal memory:
November 21, 2025 at 7:51 PM
I'm tempted to add a new method to the `Produce` trait that translates addresses from produced memory to internal memory:
I've made it work with Aabb and it reduce memory usage down to 150 MB. Point is next.
I use a simple trait `IntoCubes` to reuse code. Taking advantage of 1-to-1 correspondence between Aabb and Cube.
Finally, I added a `TransformProducer` to transform Aabbs properly.
I use a simple trait `IntoCubes` to reuse code. Taking advantage of 1-to-1 correspondence between Aabb and Cube.
Finally, I added a `TransformProducer` to transform Aabbs properly.
![/// Converts into cubes.
pub trait IntoCube: Copy {
/// Convert into cube.
fn into_cube(self) -> Cube;
}
impl IntoCube for Cube {
#[inline(always)]
fn into_cube(self) -> Cube {self}
}
impl IntoCube for Aabb {
#[inline(always)]
fn into_cube(self) -> Cube {crate::cube::aabb_to_cube(self)}
}
impl IntoCube for Point {
#[inline(always)]
fn into_cube(self) -> Cube {crate::cube::aabb_to_cube((
self,
vecmath::vec3_add(self, [1.0; 3])
))}
}](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:olippfg4rukwzrkxsdwpd5bc/bafkreiegmoqdmyrhaw72qcsm5svhz2blrk2v77rnb2dg27qyksxgajdy6i@jpeg)
![/// Transforms chunk of triangles using a matrix.
pub struct TransformProducer<'a, T: ?Sized> {
/// The matrix transform.
pub matrix: Matrix4,
/// The inner producer.
pub inner: &'a T,
}
impl<'a, T> Produce<Triangle> for TransformProducer<'a, T>
where T: Produce<Triangle> + ?Sized
{
#[inline(always)]
fn virtual_length(&self) -> usize {self.inner.virtual_length()}
#[inline(always)]
fn produce(&self, offset: usize) -> Chunk<Triangle> {
let mut chunk = self.inner.produce(offset);
crate::math::transform_chunk(&self.matrix, &mut chunk);
chunk
}
}](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:olippfg4rukwzrkxsdwpd5bc/bafkreie4h6cqaddshc5ob2a7mlcroomtlnkd4pockxpj5i3fyqmtfzfpx4@jpeg)
November 21, 2025 at 6:30 PM
I've made it work with Aabb and it reduce memory usage down to 150 MB. Point is next.
I use a simple trait `IntoCubes` to reuse code. Taking advantage of 1-to-1 correspondence between Aabb and Cube.
Finally, I added a `TransformProducer` to transform Aabbs properly.
I use a simple trait `IntoCubes` to reuse code. Taking advantage of 1-to-1 correspondence between Aabb and Cube.
Finally, I added a `TransformProducer` to transform Aabbs properly.
It works! Now, instead of 1 GB memory, it uses 655 MB.
November 21, 2025 at 4:05 PM
It works! Now, instead of 1 GB memory, it uses 655 MB.
Next step: Make a list of Quads produce virtual triangles.
The code is a bit complex, because there is an even and odd case.
The code is a bit complex, because there is an even and odd case.
![impl Produce<Triangle> for [Quad] {
#[inline(always)]
fn virtual_length(&self) -> usize {self.len() * 2}
fn produce(&self, offset: usize) -> Chunk<Triangle> {
use crate::quad::quad_to_triangles;
let j = offset / 2;
let mut chunk = [Default::default(); 64];
if offset % 2 == 0 {
// Even case.
let list = &self[j..];
let n = list.len().min(32);
for i in 0..n {
let (a, b) = quad_to_triangles(list[i]);
chunk[i * 2] = a;
chunk[i * 2 + 1] = b;
}
} else {
// Odd case.
let list = &self[j..];
if list.len() == 0 {return chunk};
let (_, b) = quad_to_triangles(list[0]);
chunk[0] = b;
let n = (list.len() - 1).min(30);
for i in 0..n {
let (a, b) = quad_to_triangles(list[i]);
chunk[i * 2 + 1] = a;
chunk[i * 2 + 2] = b;
}
if list.len() >= 32 {
let (a, _) = quad_to_triangles(list[31]);
chunk[63] = a;
}
}
chunk
}
}](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:olippfg4rukwzrkxsdwpd5bc/bafkreifeatj2vp4ewigdhpwayuxbbjkr5e7dzjmisdw47gryq6tlodpzfi@jpeg)
November 21, 2025 at 3:26 PM
Next step: Make a list of Quads produce virtual triangles.
The code is a bit complex, because there is an even and odd case.
The code is a bit complex, because there is an even and odd case.
Finally, I fix `masks`:
Notice that I need to add a `Sync` requirement, because it uses Rayon for multi-threading.
Notice that I need to add a `Sync` requirement, because it uses Rayon for multi-threading.
![pub fn masks<T: Produce<Triangle> + ?Sized + Sync>(
persp: &CameraPerspective,
dim: PixelPos,
n_tile_size: u32,
list: &T,
masks: &mut [CompressedMasks]
) {
use rayon::prelude::*;
let w = tile_grid(dim, n_tile_size)[0];
let ndim = near_dim(&persp);
masks.par_iter_mut().enumerate().for_each(|(k, masks)| {
masks.clear();
let i = k as u32 % w;
let j = k as u32 / w;
let tpos = tile_pos(dim, [i, j], n_tile_size);
let tsize = tile_size(dim, [i, j], n_tile_size);
tile_mask(persp, ndim, tpos, tsize, list, masks);
});
}](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:olippfg4rukwzrkxsdwpd5bc/bafkreidwgyqclvz6oheeqgv2weq5la6lxq3dyv6cnhiz5crqqjaccc5dby@jpeg)
November 21, 2025 at 3:05 PM
Finally, I fix `masks`:
Notice that I need to add a `Sync` requirement, because it uses Rayon for multi-threading.
Notice that I need to add a `Sync` requirement, because it uses Rayon for multi-threading.
I fix `tile_mask` to work with any Producer:
November 21, 2025 at 3:03 PM
I fix `tile_mask` to work with any Producer:
Now, since the offset is also in virtual address space, I need to add a parameter and fix the downstream code:
November 21, 2025 at 2:58 PM
Now, since the offset is also in virtual address space, I need to add a parameter and fix the downstream code:
When I use `list: Vec<Triangle>`, the Rust compiler isn't able to reduce `&list` to `&[Triangle]`. I can fix this by using `&*list`, however, it's not very ergonomic.
So, I add the following impl:
So, I add the following impl:
![impl<T> Produce<T> for Vec<T>
where [T]: Produce<T>
{
#[inline(always)]
fn virtual_length(&self) -> usize {
<[T] as Produce::<T>>::virtual_length(self)
}
#[inline(always)]
fn produce(&self, offset: usize) -> Chunk<T> {
<[T] as Produce::<T>>::produce(self, offset)
}
}](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:olippfg4rukwzrkxsdwpd5bc/bafkreifpketpvkp5eznigkb6p26xsov4i45uz2ubxkue2ple4hfn6qrxgq@jpeg)
November 21, 2025 at 2:51 PM
When I use `list: Vec<Triangle>`, the Rust compiler isn't able to reduce `&list` to `&[Triangle]`. I can fix this by using `&*list`, however, it's not very ergonomic.
So, I add the following impl:
So, I add the following impl:
A small change makes it more generic: Implement for [T] instead of &[T].
Next, make triangle_chunk work with any Producer:
Next, make triangle_chunk work with any Producer:
![#[inline(always)]
pub fn triangle_chunk<T>(list: &T) -> (Chunk<Triangle>, u64)
where T: Produce<Triangle> + ?Sized
{
(list.produce(0), init_chunk_mask((&*list).virtual_length(), 0))
}](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:olippfg4rukwzrkxsdwpd5bc/bafkreibdegtws2lnikfhnv2qohxfgrw2zfat6igmbiqviig47t63x44f5i@jpeg)
November 21, 2025 at 2:46 PM
A small change makes it more generic: Implement for [T] instead of &[T].
Next, make triangle_chunk work with any Producer:
Next, make triangle_chunk work with any Producer:
I can now replace `triangle_chunk` with a one-liner:
![pub fn triangle_chunk(list: &[Triangle]) -> (Chunk<Triangle>, u64) {
(list.produce(0), init_chunk_mask(list.len(), 0))
}](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:olippfg4rukwzrkxsdwpd5bc/bafkreibenm6cj56bfox6yk3w3fqrm4krvmukvue77vcxrrrs4kabdwnqcu@jpeg)
November 21, 2025 at 2:26 PM
I can now replace `triangle_chunk` with a one-liner:
This trait has a simpler return type for `produce` than `triangle_chunk`, which has both a chunk and an initial mask.
So, I'll add a function to calculate initial mask and implement the trait for `&[T]`:
So, I'll add a function to calculate initial mask and implement the trait for `&[T]`:
![/// Gets the initial chunk mask.
pub fn init_chunk_mask(len: usize, offset: usize) -> u64 {
let n = (len - offset).min(64);
1_u64.checked_shl(n as u32).unwrap_or(0).wrapping_sub(1)
}
impl<T: Default + Copy> Produce<T> for &[T] {
fn virtual_length(&self) -> usize {self.len()}
fn produce(&self, offset: usize) -> Chunk<T> {
let list = &self[offset..];
let mut chunk = [Default::default(); 64];
let n = list.len().min(64);
for i in 0..n {
chunk[i] = list[i];
}
chunk
}
}](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:olippfg4rukwzrkxsdwpd5bc/bafkreibxsz3l4cxakkufwmphnamzr6svpl4b4mh745yp5hxwwfqpfpq5za@jpeg)
November 21, 2025 at 2:22 PM
This trait has a simpler return type for `produce` than `triangle_chunk`, which has both a chunk and an initial mask.
So, I'll add a function to calculate initial mask and implement the trait for `&[T]`:
So, I'll add a function to calculate initial mask and implement the trait for `&[T]`: