digital_clock

A seven-segment clock. Segment geometry is generated on the CPU in examples/digital_clock_shared.rs and drawn as coloured triangles each frame.

cargo run --features examples --example digital_clock

What it demonstrates

• Dynamic CPU-generated geometry
• Sharing helper modules between examples

Controls

Source

examples/digital_clock.rs:

//! Digital Clock example - render an animated 7-segment clock in a window.
//!
//! Uses retained scheme with offscreen render pass → copy-to-present.
//!
//! Run with: `cargo run --example digital_clock`

mod digital_clock_shared;

use digital_clock_shared::{generate_clock_vertices, ClockState, ClockVertex, TimeData};
use goldy::{
    Buffer, BufferFlags, BufferKind, Color, DepositTarget, DepositTransaction, Instance, Lease, LeaseRenderTarget,
    MemoryExchange, NodeAccess, RenderPipeline, RenderPipelineDesc, RequestAdapterOptions, RuntimeDescriptor, Scheme,
    ShaderModule, SurfaceConfig, SurfaceExchange, TargetLoad, Texture, TextureFormat, Transaction, VertexBufferLayout,
};
use std::ops::Shr;
use std::sync::Arc;
use std::time::Instant;
use winit::{
    application::ApplicationHandler,
    event::WindowEvent,
    event_loop::{ActiveEventLoop, ControlFlow, EventLoop},
    keyboard::{Key, NamedKey},
    window::{Window, WindowId},
};
mod common;
use common::CaptureDump;

/// Upper bound on seven-segment clock vertices (8 glyphs × 7 segments × 6 verts).
const MAX_CLOCK_VERTICES: usize = 384;

const SHADER_SOURCE: &str = r#"
struct VertexInput {
    float2 position : POSITION;
    float4 color : COLOR;
};

struct VertexOutput {
    float4 position : SV_Position;
    float4 color : COLOR;
};

[shader("vertex")]
VertexOutput vs_main(VertexInput input) {
    VertexOutput output;
    output.position = float4(input.position, 0.0, 1.0);
    output.color = input.color;
    return output;
}

[shader("fragment")]
float4 fs_main(VertexOutput input) : SV_Target {
    return input.color;
}
"#;

fn clock_vertex_layout() -> VertexBufferLayout {
    ClockVertex::GPU_TYPE
        .vertex_buffer_layout()
        .expect("clock vertex layout")
}

struct App {
    instance: Instance,
    ctx: Option<goldy::Context>,
    device: Option<Arc<goldy::Runtime>>,
    pipeline: Option<RenderPipeline>,
    shader: Option<ShaderModule>,
    vertex_parcel: Option<Buffer>,
    upload_scheme: Option<Scheme>,
    vertex_deposit: Option<DepositTransaction>,

    window: Option<Arc<Window>>,
    surface: Option<SurfaceExchange>,
    present: Option<Transaction>,
    capture: Option<CaptureDump>,
    readback: Option<Texture>,
    scene_rt: Option<Lease<LeaseRenderTarget>>,
    scheme: Option<Scheme>,

    start_time: Instant,
    perf_start: Instant,
    frame_count: u32,
    clock_state: ClockState,
    recorded_vertex_count: u32,
    recorded_bg_color: Color,
}

impl App {
    fn new() -> anyhow::Result<Self> {
        let instance = Instance::new()?;
        Ok(Self {
            instance,
            ctx: None,
            device: None,
            pipeline: None,
            shader: None,
            window: None,
            surface: None,
            present: None,
            capture: None,
            readback: None,
            scene_rt: None,
            scheme: None,
            start_time: Instant::now(),
            perf_start: Instant::now(),
            frame_count: 0,
            clock_state: ClockState::default(),
            vertex_parcel: None,
            upload_scheme: None,
            vertex_deposit: None,
            recorded_vertex_count: 0,
            recorded_bg_color: Color::BLACK,
        })
    }

    fn create_pipeline(
        device: &goldy::Runtime,
        shader: &ShaderModule,
        format: TextureFormat,
    ) -> anyhow::Result<RenderPipeline> {
        common::render_pipeline(
            device,
            shader,
            format,
            RenderPipelineDesc {
                vertex_layout: clock_vertex_layout(),
                ..Default::default()
            },
        )
    }

    fn record_pass(
        scheme: &mut Scheme,
        pipeline: &RenderPipeline,
        vertex_parcel: &Buffer,
        vertex_count: u32,
        bg_color: Color,
        scene_rt: &Lease<LeaseRenderTarget>,
    ) {
        let mut pass = scheme.render_pass("digital_clock", scene_rt, TargetLoad::Clear(bg_color));
        pass.with_parcel(vertex_parcel, NodeAccess::Read);
        pass.set_pipeline(pipeline);
        pass.set_vertex_buffer(0, vertex_parcel);
        pass.draw(0..vertex_count, 0..1);
        pass.finish();
    }

    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 output_size(&self) -> Option<(TextureFormat, u32, u32)> {
        if let Some(surface) = self.surface.as_ref() {
            let (width, height) = surface.size();
            Some((surface.format(), width, height))
        } else {
            let capture = self.capture.as_ref()?;
            Some((CaptureDump::format(), capture.width(), capture.height()))
        }
    }

    fn rerecord_scheme_if_needed(&mut self, vertex_count: u32, bg_color: Color) {
        if vertex_count == self.recorded_vertex_count && bg_color == self.recorded_bg_color {
            return;
        }
        let Some((format, width, height)) = self.output_size() else {
            return;
        };
        if let (Some(ctx), Some(pipeline), Some(vertex_parcel)) =
            (self.ctx.as_ref(), self.pipeline.as_ref(), self.vertex_parcel.as_ref())
        {
            let mut scheme = Scheme::new(ctx);
            if let Ok(rt) = ctx.lease_render_target(width.max(1), height.max(1), format, None) {
                Self::record_pass(&mut scheme, pipeline, vertex_parcel, vertex_count, bg_color, &rt);
                if let Ok(present) = Self::bind_frame(&mut scheme, &rt, self.surface.as_ref(), self.readback.as_ref()) {
                    self.present = present;
                    self.scheme = Some(scheme);
                    self.recorded_vertex_count = vertex_count;
                    self.recorded_bg_color = bg_color;
                    self.scene_rt = Some(rt);
                }
            }
        }
    }

    fn init_gpu(&mut self, window: Option<&Window>) -> anyhow::Result<()> {
        let device = Arc::new(
            self.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 {
            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 shader = ShaderModule::from_slang(&device, SHADER_SOURCE)?;
        let pipeline = Self::create_pipeline(&device, &shader, format)?;

        let vertex_parcel = device.acquire_buffer_sized::<ClockVertex>(
            MAX_CLOCK_VERTICES as u64,
            BufferKind::Scattered,
            BufferFlags::empty(),
        )?;

        let bg_color = self.clock_state.background_color();
        let mut scheme = Scheme::new(&ctx);
        let scene_rt = ctx.lease_render_target(width.max(1), height.max(1), format, None)?;
        Self::record_pass(&mut scheme, &pipeline, &vertex_parcel, 1, bg_color, &scene_rt);
        let present = Self::bind_frame(&mut scheme, &scene_rt, surface.as_ref(), readback.as_ref())?;

        self.ctx = Some(ctx);
        let ctx = self.ctx.as_ref().unwrap();
        self.device = Some(device);
        self.shader = Some(shader);
        self.pipeline = Some(pipeline);
        self.vertex_parcel = Some(vertex_parcel);
        let vertex_parcel = self.vertex_parcel.as_ref().unwrap();
        let mut upload_scheme = Scheme::new(ctx);
        let vertex_deposit = MemoryExchange::new(ctx).bind_deposit(
            &mut upload_scheme,
            DepositTarget::buffer_elements::<ClockVertex>(vertex_parcel, MAX_CLOCK_VERTICES as u64),
        )?;
        self.upload_scheme = Some(upload_scheme);
        self.vertex_deposit = Some(vertex_deposit);
        self.surface = surface;
        self.present = present;
        self.capture = capture;
        self.readback = readback;
        self.scene_rt = Some(scene_rt);
        self.scheme = Some(scheme);
        self.recorded_vertex_count = 1;
        self.recorded_bg_color = bg_color;
        Ok(())
    }

    fn elapsed_secs(&self) -> u64 {
        if let Some(capture) = self.capture.as_ref() {
            return capture.time() as u64;
        }
        if self.clock_state.paused {
            self.clock_state.accumulated_secs
        } else {
            self.start_time.elapsed().as_secs() + self.clock_state.accumulated_secs
        }
    }

    fn toggle_pause(&mut self) {
        let current = self.elapsed_secs();
        if self.clock_state.paused {
            self.start_time = Instant::now();
        }
        self.clock_state.toggle_pause(current);
    }

    fn render_frame(&mut self) -> anyhow::Result<()> {
        self.frame_count += 1;

        let (width, height) = if let Some(window) = self.window.as_ref() {
            let size = window.inner_size();
            (size.width, size.height)
        } else {
            self.capture.as_ref().unwrap().size()
        };

        if width == 0 || height == 0 {
            return Ok(());
        }

        let elapsed = self.elapsed_secs();
        let time = TimeData::from_elapsed_secs(elapsed);
        let color = self.clock_state.color();
        let bg_color = self.clock_state.background_color();
        let vertices = generate_clock_vertices(time, color, width, height);
        let vertex_count = vertices.len() as u32;

        self.rerecord_scheme_if_needed(vertex_count, bg_color);

        let upload = self.upload_scheme.as_mut().unwrap();
        (self.vertex_deposit.as_ref().unwrap() << vertices.as_slice())?;
        upload.submit()?;

        let scheme = self.scheme.as_mut().unwrap();
        let mut submission = 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)?;
        }
        Ok(())
    }

    fn capture_done(&self) -> bool {
        self.capture.as_ref().is_none_or(CaptureDump::finished)
    }

    fn handle_resize(&mut self, new_size: winit::dpi::PhysicalSize<u32>) {
        if new_size.width == 0 || new_size.height == 0 {
            return;
        }
        let Some(surface) = self.surface.as_mut() else {
            return;
        };
        let _ = surface.resize(new_size.width, new_size.height);
        let format = surface.format();
        let (width, height) = surface.size();
        if let (Some(ctx), Some(device), Some(shader), Some(vertex_parcel)) = (
            self.ctx.as_ref(),
            self.device.as_ref(),
            self.shader.as_ref(),
            self.vertex_parcel.as_ref(),
        ) {
            if let Ok(pipeline) = Self::create_pipeline(device, shader, format) {
                self.pipeline = Some(pipeline);
                if let Some(pipeline) = self.pipeline.as_ref() {
                    let bg_color = self.clock_state.background_color();
                    let vertex_count = self.recorded_vertex_count.max(1);
                    let mut scheme = Scheme::new(ctx);
                    if let Ok(rt) = ctx.lease_render_target(width.max(1), height.max(1), format, None) {
                        Self::record_pass(&mut scheme, pipeline, vertex_parcel, vertex_count, bg_color, &rt);
                        if let Ok(present) =
                            Self::bind_frame(&mut scheme, &rt, self.surface.as_ref(), self.readback.as_ref())
                        {
                            self.present = present;
                            self.scheme = Some(scheme);
                            self.recorded_vertex_count = vertex_count;
                            self.recorded_bg_color = bg_color;
                            self.scene_rt = Some(rt);
                        }
                    }
                }
            }
        }
    }
}

impl Drop for App {
    fn drop(&mut self) {
        let elapsed = self.perf_start.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
        );
    }
}

impl ApplicationHandler for App {
    fn resumed(&mut self, event_loop: &ActiveEventLoop) {
        if self.window.is_none() {
            let attrs = common::hidden_window(
                "Goldy - Clock (Scheme + Present, Space: pause, Click: color)",
                1280,
                720,
            );

            let window = Arc::new(event_loop.create_window(attrs).unwrap());
            self.window = Some(window.clone());

            if let Err(e) = self.init_gpu(Some(window.as_ref())) {
                tracing::error!("Failed to initialize GPU: {}", e);
            } else if let Err(e) = self.render_frame() {
                tracing::error!("First frame error: {e}");
            }
            common::reveal_window(&window);
            window.request_redraw();
        }
    }

    fn about_to_wait(&mut self, event_loop: &ActiveEventLoop) {
        common::exit_if_timed_out(event_loop, self.perf_start);
    }

    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() => match event.logical_key {
                Key::Named(NamedKey::Escape) => event_loop.exit(),
                Key::Named(NamedKey::Space) => self.toggle_pause(),
                Key::Character(ref c) if c == "c" || c == "C" => self.clock_state.next_color(),
                _ => {}
            },
            WindowEvent::MouseInput { state, .. } if state.is_pressed() => {
                self.clock_state.next_color();
            }
            WindowEvent::RedrawRequested => {
                if let Err(e) = self.render_frame() {
                    tracing::error!("Render error: {}", e);
                }
                if let Some(window) = &self.window {
                    window.request_redraw();
                }
            }
            WindowEvent::Resized(new_size) => {
                self.handle_resize(new_size);
                if let Some(window) = &self.window {
                    window.request_redraw();
                }
            }
            _ => {}
        }
    }
}

fn main() -> anyhow::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 app = App::new()?;
        app.init_gpu(None)?;
        while !app.capture_done() {
            app.render_frame()?;
        }
        return Ok(());
    }

    println!("Goldy Clock Example (retained scheme)");
    println!("==================================================================");
    println!("Controls:");
    println!("  Space - Toggle pause");
    println!("  Click - Change color");
    println!("  Escape - Exit\n");

    let event_loop = EventLoop::new()?;
    event_loop.set_control_flow(ControlFlow::Poll);

    let mut app = App::new()?;
    event_loop.run_app(&mut app)?;

    Ok(())
}

The example pulls in examples/common.rs, examples/digital_clock_shared.rs — see Shared Helpers.

The Slang source is inline in the example above.