starfield
A 3D starfield flying towards the viewer. A compute pass advances and recycles stars; the raster pass scales each point by its depth.
cargo run --features examples --example starfield
What it demonstrates
- Compute-driven particle recycling
- Depth-scaled point rendering
Source
examples/starfield.rs:
//! Starfield example - classic 3D starfield flying through space.
//!
//! Demonstrates retained scheme with compute dispatch → offscreen render → copy-to-present.
//!
//! Run with: `cargo run --example starfield`
use anyhow::Result;
use goldy::{
Buffer, BufferFlags, BufferKind, Color, ComputePipeline, DepositTarget, DepositTransaction, Instance, Lease,
LeaseRenderTarget, MemoryExchange, NodeAccess, PrimitiveTopology, RenderPipeline, RenderPipelineDesc,
RequestAdapterOptions, RuntimeDescriptor, Scheme, ShaderModule, SurfaceConfig, SurfaceExchange, TargetLoad,
Texture, TextureFormat, Transaction, VertexBufferLayout,
};
use std::ops::Shr;
use std::sync::Arc;
use winit::{
application::ApplicationHandler,
event::WindowEvent,
event_loop::{ActiveEventLoop, ControlFlow, EventLoop},
keyboard::{Key, NamedKey},
window::{Window, WindowId},
};
mod common;
use common::CaptureDump;
const NUM_STARS: u32 = 500;
const STAR_TYPE_NORMAL: f32 = 0.0;
const STAR_TYPE_GALAXY: f32 = 1.0;
const STAR_TYPE_QUASAR: f32 = 2.0;
const STAR_TYPE_WHITE_DWARF: f32 = 3.0;
#[goldy::gpu]
struct Star {
x: f32,
y: f32,
z: f32,
star_type: f32,
}
#[goldy::gpu]
struct StarfieldParams {
speed: f32,
frame: f32,
}
static mut SEED: u32 = 12345;
fn rand_f32() -> f32 {
unsafe {
SEED = SEED.wrapping_mul(1103515245).wrapping_add(12345);
SEED as f32 / u32::MAX as f32
}
}
fn main() -> Result<()> {
tracing_subscriber::fmt()
.with_env_filter(
tracing_subscriber::EnvFilter::try_from_default_env()
.unwrap_or_else(|_| tracing_subscriber::EnvFilter::new("warn")),
)
.init();
if common::capture_requested() {
let mut state = RenderState::new(None)?;
while !state.capture_done() {
state.render()?;
}
return Ok(());
}
println!("Goldy Starfield Example");
println!(" Up/Down - Change speed");
println!(" Escape - Exit");
let event_loop = EventLoop::new()?;
event_loop.set_control_flow(ControlFlow::Poll);
let mut app = App::default();
event_loop.run_app(&mut app)?;
Ok(())
}
#[derive(Default)]
struct App {
state: Option<RenderState>,
}
struct RenderState {
window: Option<Arc<Window>>,
device: Arc<goldy::Runtime>,
ctx: goldy::Context,
surface: Option<SurfaceExchange>,
capture: Option<CaptureDump>,
readback: Option<Texture>,
present: Option<Transaction>,
scheme: Scheme,
scene_rt: Lease<LeaseRenderTarget>,
compute_pipeline: ComputePipeline,
render_shader: ShaderModule,
render_pipeline: RenderPipeline,
star_buffer: Buffer,
params_buffer: Buffer,
upload_scheme: Scheme,
params_deposit: DepositTransaction,
speed: f32,
frame_count: f32,
start_time: std::time::Instant,
}
impl RenderState {
fn create_render_pipeline(
device: &goldy::Runtime,
render_shader: &ShaderModule,
format: TextureFormat,
) -> Result<RenderPipeline> {
common::render_pipeline(
device,
render_shader,
format,
RenderPipelineDesc {
vertex_layout: VertexBufferLayout::empty(),
topology: PrimitiveTopology::TriangleList,
..Default::default()
},
)
}
fn bind_frame(
scheme: &mut Scheme,
scene_rt: &Lease<LeaseRenderTarget>,
surface: Option<&SurfaceExchange>,
readback: Option<&Texture>,
) -> anyhow::Result<Option<Transaction>> {
if let Some(surface) = surface {
let present = surface.bind_render_target(scheme, scene_rt)?;
Ok(Some(present))
} else {
let readback = readback.expect("capture readback");
scheme.copy_to_texture(scene_rt, readback)?;
Ok(None)
}
}
fn record_scheme(
scheme: &mut Scheme,
compute_pipeline: &ComputePipeline,
render_pipeline: &RenderPipeline,
star_buffer: &Buffer,
params_buffer: &Buffer,
scene_rt: &Lease<LeaseRenderTarget>,
) {
scheme
.node("update_stars", compute_pipeline)
.with_parcel(star_buffer, NodeAccess::ReadWrite)
.with_parcel(params_buffer, NodeAccess::Read)
.dispatch(NUM_STARS.div_ceil(64), 1, 1);
let mut pass = scheme.render_pass("starfield", scene_rt, TargetLoad::Clear(Color::BLACK));
pass.with_parcel(star_buffer, NodeAccess::Read);
pass.set_pipeline(render_pipeline);
pass.draw(0..6, 0..NUM_STARS);
pass.finish();
}
fn target(&self) -> (TextureFormat, u32, u32) {
if let Some(surface) = &self.surface {
let (width, height) = surface.size();
(surface.format(), width, height)
} else {
let capture = self.capture.as_ref().expect("capture dump");
let (width, height) = capture.size();
(CaptureDump::format(), width, height)
}
}
fn capture_done(&self) -> bool {
self.capture.as_ref().is_none_or(CaptureDump::finished)
}
fn rerecord_scheme(&mut self) {
let mut scheme = Scheme::new(&self.ctx);
let (format, width, height) = self.target();
if let Ok(rt) = self.ctx.lease_render_target(width.max(1), height.max(1), format, None) {
self.scene_rt = rt;
Self::record_scheme(
&mut scheme,
&self.compute_pipeline,
&self.render_pipeline,
&self.star_buffer,
&self.params_buffer,
&self.scene_rt,
);
if let Ok(present) = Self::bind_frame(
&mut scheme,
&self.scene_rt,
self.surface.as_ref(),
self.readback.as_ref(),
) {
self.present = present;
self.scheme = scheme;
}
}
}
fn new(window: Option<Arc<Window>>) -> Result<Self> {
let instance = Instance::new()?;
let device = Arc::new(
instance
.request_adapter(&RequestAdapterOptions::default())?
.request_runtime(&RuntimeDescriptor::default())?,
);
let ctx = device.create_context()?;
let (surface, capture, readback, format, width, height) = if let Some(window) = window.as_deref() {
let surface = SurfaceExchange::new(&ctx, window, SurfaceConfig::default())?;
let format = surface.format();
let (width, height) = surface.size();
(Some(surface), None, None, format, width, height)
} else {
let capture = CaptureDump::from_env()?;
let (width, height) = capture.size();
let readback = common::capture_readback(&device, width, height)?;
(
None,
Some(capture),
Some(readback),
CaptureDump::format(),
width,
height,
)
};
let compute_shader = ShaderModule::from_slang_with_gpu_types(
&device,
include_str!("../shaders/starfield_update.slang"),
&[Star::GPU_TYPE, StarfieldParams::GPU_TYPE],
)?;
let render_shader = ShaderModule::from_slang_with_gpu_types(
&device,
include_str!("../shaders/starfield_render.slang"),
&[Star::GPU_TYPE],
)?;
let mut stars = Vec::with_capacity(NUM_STARS as usize);
for _ in 0..NUM_STARS {
let type_roll = rand_f32();
let star_type = if type_roll < 0.70 {
STAR_TYPE_NORMAL
} else if type_roll < 0.85 {
STAR_TYPE_GALAXY
} else if type_roll < 0.90 {
STAR_TYPE_QUASAR
} else {
STAR_TYPE_WHITE_DWARF
};
stars.push(Star {
x: (rand_f32() - 0.5) * 0.8,
y: (rand_f32() - 0.5) * 0.8,
z: 0.5 + rand_f32() * 0.5,
star_type,
});
}
let star_buffer = device.acquire_buffer_with_data(&stars, BufferKind::Scattered)?;
let params_buffer =
device.acquire_buffer_sized::<StarfieldParams>(1, BufferKind::Broadcast, BufferFlags::empty())?;
let compute_pipeline = ComputePipeline::new(&device, &compute_shader)?;
let render_pipeline = Self::create_render_pipeline(&device, &render_shader, format)?;
let mut scheme = Scheme::new(&ctx);
let scene_rt = ctx.lease_render_target(width.max(1), height.max(1), format, None)?;
Self::record_scheme(
&mut scheme,
&compute_pipeline,
&render_pipeline,
&star_buffer,
¶ms_buffer,
&scene_rt,
);
let present = Self::bind_frame(&mut scheme, &scene_rt, surface.as_ref(), readback.as_ref())?;
let mut upload_scheme = Scheme::new(&ctx);
let params_deposit = MemoryExchange::new(&ctx).bind_deposit(
&mut upload_scheme,
DepositTarget::buffer_elements::<StarfieldParams>(¶ms_buffer, 1),
)?;
println!("Created starfield with {NUM_STARS} stars (Scheme + Present)");
Ok(Self {
window,
device,
ctx,
surface,
capture,
readback,
present,
scheme,
scene_rt,
compute_pipeline,
render_shader,
render_pipeline,
star_buffer,
params_buffer,
upload_scheme,
params_deposit,
speed: 0.01,
frame_count: 0.0,
start_time: std::time::Instant::now(),
})
}
fn render(&mut self) -> Result<()> {
self.frame_count += 1.0;
let params = StarfieldParams {
speed: self.speed,
frame: self.frame_count,
};
(&self.params_deposit << ¶ms)?;
self.upload_scheme.submit()?;
let mut submission = self.scheme.submit()?;
if let Some(present) = &self.present {
(&mut submission >> present).take()?;
} else {
let pixels = (&mut submission >> self.readback.as_ref().unwrap())
.take::<u8>()?
.to_vec();
self.capture.as_mut().unwrap().write_rgba(&pixels)?;
}
if let Some(window) = &self.window {
window.request_redraw();
}
Ok(())
}
fn change_speed(&mut self, delta: f32) {
self.speed = (self.speed + delta).clamp(0.001, 0.1);
if let Some(window) = &self.window {
window.set_title(&format!("Goldy - Starfield (speed: {:.1})", self.speed));
}
}
}
impl Drop for RenderState {
fn drop(&mut self) {
let elapsed = self.start_time.elapsed().as_secs_f64();
let fps = if elapsed > 0.0 {
self.frame_count as f64 / elapsed
} else {
0.0
};
println!(
"GOLDY_PERF: frames={} elapsed={elapsed:.2}s avg_fps={fps:.1}",
self.frame_count as u64
);
}
}
impl ApplicationHandler for App {
fn resumed(&mut self, event_loop: &ActiveEventLoop) {
if self.state.is_none() {
let window = Arc::new(
event_loop
.create_window(common::hidden_window("Goldy - Starfield", 1024, 768))
.expect("Failed to create window"),
);
match RenderState::new(Some(window.clone())) {
Ok(mut state) => {
if let Err(e) = state.render() {
tracing::error!("First frame error: {e}");
}
common::reveal_window(&window);
self.state = Some(state);
window.request_redraw();
}
Err(e) => {
tracing::error!("Failed to create render state: {e}");
event_loop.exit();
}
}
}
}
fn about_to_wait(&mut self, event_loop: &ActiveEventLoop) {
if let Some(state) = &self.state {
common::exit_if_timed_out(event_loop, state.start_time);
}
}
fn window_event(&mut self, event_loop: &ActiveEventLoop, _id: WindowId, event: WindowEvent) {
match event {
WindowEvent::CloseRequested => event_loop.exit(),
WindowEvent::KeyboardInput { event, .. } if event.state.is_pressed() => {
if let Some(state) = &mut self.state {
match event.logical_key {
Key::Named(NamedKey::Escape) => event_loop.exit(),
Key::Named(NamedKey::ArrowUp) => state.change_speed(0.005),
Key::Named(NamedKey::ArrowDown) => state.change_speed(-0.005),
_ => {}
}
}
}
WindowEvent::Resized(size) => {
if let Some(state) = &mut self.state {
if size.width > 0 && size.height > 0 {
let Some(surface) = state.surface.as_ref() else {
return;
};
let (prev_w, prev_h) = surface.size();
if size.width == prev_w && size.height == prev_h {
return;
}
let _ = surface.resize(size.width, size.height);
let format = surface.format();
if let Ok(pipeline) =
RenderState::create_render_pipeline(&state.device, &state.render_shader, format)
{
state.render_pipeline = pipeline;
}
state.rerecord_scheme();
}
}
}
WindowEvent::RedrawRequested => {
if let Some(state) = &mut self.state {
if let Err(e) = state.render() {
tracing::error!("Render error: {e}");
}
}
}
_ => {}
}
}
}The example pulls in examples/common.rs — see Shared Helpers.
Shaders
shaders/starfield_update.slang:
// Starfield compute shader - updates star z-positions for 3D flying effect
import goldy_exp;
static const float STAR_TYPE_NORMAL = 0.0;
static const float STAR_TYPE_GALAXY = 1.0;
static const float STAR_TYPE_QUASAR = 2.0;
static const float STAR_TYPE_WHITE_DWARF = 3.0;
static const uint NUM_STARS = 500;
float hash(float p) {
return frac(sin(p * 127.1) * 43758.5453);
}
[goldy_compute]
[numthreads(64, 1, 1)]
void cs_main(Scattered<Star> STARS, StarfieldParams params, ThreadId id) {
uint idx = id.x;
if (idx >= NUM_STARS) return;
Star s = STARS[idx];
s.z -= params.speed;
if (s.z <= 0.01) {
float seed = float(idx) + params.frame * 0.01;
s.x = (hash(seed) - 0.5) * 2.0;
s.y = (hash(seed + 100.0) - 0.5) * 2.0;
s.z = 1.0;
float type_roll = hash(seed + 200.0);
if (type_roll < 0.6) {
s.star_type = STAR_TYPE_NORMAL;
} else if (type_roll < 0.8) {
s.star_type = STAR_TYPE_GALAXY;
} else if (type_roll < 0.95) {
s.star_type = STAR_TYPE_QUASAR;
} else {
s.star_type = STAR_TYPE_WHITE_DWARF;
}
}
STARS[idx] = s;
}
shaders/starfield_render.slang:
// Starfield rendering shader
// Visualizes different celestial objects using instancing
import goldy_exp;
static const float STAR_TYPE_NORMAL = 0.0;
static const float STAR_TYPE_GALAXY = 1.0;
static const float STAR_TYPE_QUASAR = 2.0;
static const float STAR_TYPE_WHITE_DWARF = 3.0;
struct VSOutput {
float4 position : SV_Position;
float4 color : COLOR;
float2 uv : TEXCOORD0;
float star_type : TEXCOORD1;
};
static const float2 quadVerts[6] = {
float2(-1, -1), float2( 1, -1), float2( 1, 1),
float2(-1, -1), float2( 1, 1), float2(-1, 1)
};
[goldy_vertex]
VSOutput vs_main(Scattered<Star> STARS, VertexId vertexID, InstanceId instanceID) {
VSOutput output;
Star s = STARS[instanceID.value];
float2 screenPos = float2(s.x, s.y) / max(s.z, 0.01);
float baseSize = 0.005 + 0.02 * (1.0 - s.z);
float size = baseSize;
float3 baseColor = float3(1.0, 1.0, 1.0);
float hash1 = frac(sin(float(instanceID.value) * 127.1) * 43758.5453);
float hash2 = frac(sin(float(instanceID.value) * 269.5) * 43758.5453);
if (s.star_type == STAR_TYPE_NORMAL) {
float temp = hash1;
if (temp < 0.15) {
baseColor = float3(0.7, 0.85, 1.0);
} else if (temp < 0.4) {
baseColor = float3(1.0, 1.0, 0.95);
} else if (temp < 0.7) {
baseColor = float3(1.0, 0.95, 0.8);
} else if (temp < 0.9) {
baseColor = float3(1.0, 0.8, 0.6);
} else {
baseColor = float3(1.0, 0.6, 0.5);
}
}
else if (s.star_type == STAR_TYPE_GALAXY) {
size = baseSize * 2.5;
float hue = hash1 * 6.0;
int colorIdx = int(hue);
float blend = frac(hue);
float3 galaxyColors[7] = {
float3(1.0, 0.5, 0.7),
float3(0.7, 0.5, 1.0),
float3(0.5, 0.7, 1.0),
float3(0.5, 1.0, 0.9),
float3(0.7, 1.0, 0.6),
float3(1.0, 0.9, 0.5),
float3(1.0, 0.5, 0.7)
};
baseColor = lerp(galaxyColors[colorIdx], galaxyColors[colorIdx + 1], blend);
}
else if (s.star_type == STAR_TYPE_QUASAR) {
size = baseSize * 1.8;
float quasarHue = hash1;
if (quasarHue < 0.33) {
baseColor = float3(0.4, 1.0, 1.0);
} else if (quasarHue < 0.66) {
baseColor = float3(0.7, 0.6, 1.0);
} else {
baseColor = float3(1.0, 0.7, 1.0);
}
}
else if (s.star_type == STAR_TYPE_WHITE_DWARF) {
size = baseSize * 0.7;
baseColor = lerp(float3(0.85, 0.9, 1.0), float3(1.0, 1.0, 1.0), hash1);
}
float2 localPos = quadVerts[vertexID.value] * size;
output.position = float4(screenPos + localPos, 0.0, 1.0);
float brightness = 1.0 - s.z;
output.color = float4(baseColor * brightness, 1.0);
output.uv = quadVerts[vertexID.value];
output.star_type = s.star_type;
return output;
}
[goldy_fragment]
float4 fs_main(VSOutput input) : SV_Target {
float2 uv = input.uv;
float dist = length(uv);
float4 color = input.color;
if (input.star_type == STAR_TYPE_NORMAL) {
float2 absUV = abs(uv);
float hBar = max(0.0, 1.0 - absUV.y * 4.0) * (1.0 - smoothstep(0.0, 1.0, absUV.x));
float vBar = max(0.0, 1.0 - absUV.x * 4.0) * (1.0 - smoothstep(0.0, 1.0, absUV.y));
float cross = max(hBar, vBar);
float core = 1.0 - smoothstep(0.0, 0.25, dist);
float glow = max(cross * 0.8, core);
color.rgb *= glow;
color.a = glow;
}
else if (input.star_type == STAR_TYPE_GALAXY) {
float2 rotUV = float2(uv.x * 0.7 + uv.y * 0.3, uv.y * 0.8 - uv.x * 0.2);
float ellipseDist = length(rotUV * float2(1.0, 1.5));
float glow = 1.0 - smoothstep(0.0, 0.8, ellipseDist);
float angle = atan2(uv.y, uv.x);
float spiral = sin(angle * 2.0 + dist * 6.0) * 0.15 + 0.85;
color.rgb *= glow * spiral;
color.a = glow * 0.9;
}
else if (input.star_type == STAR_TYPE_QUASAR) {
float core = 1.0 - smoothstep(0.0, 0.3, dist);
float jet = max(0.0, 1.0 - abs(uv.x) * 4.0) * (1.0 - smoothstep(0.0, 1.0, abs(uv.y)));
float glow = max(core, jet * 0.5);
color.rgb *= glow * 1.5;
color.a = glow;
}
else if (input.star_type == STAR_TYPE_WHITE_DWARF) {
float glow = 1.0 - smoothstep(0.0, 0.5, dist);
glow = pow(glow, 2.0);
color.rgb *= glow * 1.3;
color.a = glow;
}
if (color.a < 0.01) discard;
return color;
}