SDL3 Renderer + 2)primitives

Cargo.toml

@@ -149,6 +149,15 @@ name = "renderer-target"
 [[example]]
 name = "events"
 
+[[example]]
+name = "renderer_01_change_the_color"
+path = "examples/renderer/a01_change_the_color.rs"
+
+[[example]]
+# required-dependency = "rand"
+name = "renderer_02_primitives"
+path = "examples/renderer/a02_primitives.rs"
+
 [[example]]
 name = "renderer-texture"
 

examples/renderer/README.md

@@ -0,0 +1,11 @@
+- https://docs.rs/sdl3/latest/sdl3/#getting-started
+
+- https://github.com/libsdl-org/SDL/tree/main/examples/renderer
+
+<hr />
+
+# Run
+
+- `cargo r --example renderer_01_change_the_color`
+
+- `cargo r --example renderer_02_primitives`

examples/renderer/a01_change_the_color.rs

@@ -0,0 +1,57 @@
+use sdl3::{event::Event, pixels::Color};
+
+use std::f64::consts::PI;
+use std::time::Instant;
+
+const WINDOW_WIDTH: u32 = 640;
+const WINDOW_HEIGHT: u32 = 480;
+
+fn main() -> Result<(), String> {
+    let sdl_context = sdl3::init()?;
+    let video_subsystem = sdl_context.video()?;
+    let window = video_subsystem
+        .window(
+            "Change the color of the rust-sdl3 screen to a sine wave pattern",
+            WINDOW_WIDTH,
+            WINDOW_HEIGHT,
+        )
+        .position_centered()
+        .build()
+        .unwrap();
+
+    let mut canvas = window.into_canvas();
+
+    let mut event_pump = sdl_context.event_pump()?;
+    let start_time = Instant::now();
+
+    'running: loop {
+        for event in event_pump.poll_iter() {
+            match event {
+                Event::Quit { .. } => break 'running,
+                _ => {}
+            }
+        }
+
+        let elapsed_time = start_time.elapsed().as_secs_f64();
+
+        // Calculate color values using sine wave
+        let red = 0.5 + 0.5 * (elapsed_time * 2.0 * PI).sin();
+        let green = 0.5 + 0.5 * ((elapsed_time * 2.0 * PI) + (2.0 * PI / 3.0)).sin();
+        let blue = 0.5 + 0.5 * ((elapsed_time * 2.0 * PI) + (4.0 * PI / 3.0)).sin();
+
+        // Set render color
+        canvas.set_draw_color(Color::RGB(
+            (red * 255.0) as u8,
+            (green * 255.0) as u8,
+            (blue * 255.0) as u8,
+        ));
+
+        // Clear the canvas
+        canvas.clear();
+
+        // Present the rendered frame
+        canvas.present();
+    }
+
+    Ok(())
+}

examples/renderer/a02_primitives.rs

@@ -0,0 +1,86 @@
+// https://github.com/libsdl-org/SDL/tree/main/examples/renderer
+extern crate sdl3;
+
+use rand::Rng;
+use sdl3::rect::Rect;
+use sdl3::render::FRect;
+use sdl3::{event::Event, pixels::Color, rect::Point};
+
+const WINDOW_WIDTH: u32 = 640;
+const WINDOW_HEIGHT: u32 = 480;
+const NUM_POINTS: usize = 500;
+
+fn main() -> Result<(), String> {
+    let sdl_context = sdl3::init()?;
+    let video_subsystem = sdl_context.video()?;
+    let window = video_subsystem
+        .window(
+            "SDL3 Renderer Primitives Example",
+            WINDOW_WIDTH,
+            WINDOW_HEIGHT,
+        )
+        .position_centered()
+        .build()
+        .unwrap();
+
+    let mut canvas = window.into_canvas();
+
+    let mut event_pump = sdl_context.event_pump()?;
+
+    let mut points: Vec<Point> = Vec::with_capacity(NUM_POINTS);
+    let mut rng = rand::thread_rng(); // Using thread_rng instead of just rng
+
+    for _ in 0..NUM_POINTS {
+        let x = rng.gen_range(100..540); // Generating random numbers within the bounds
+        let y = rng.gen_range(100..380);
+        points.push(Point::new(x, y));
+    }
+
+    loop {
+        for event in event_pump.poll_iter() {
+            match event {
+                Event::Quit { .. } => return Ok(()),
+                _ => {}
+            }
+        }
+
+        // Clear the canvas
+        canvas.set_draw_color(Color::BLACK);
+        canvas.clear();
+
+        // Draw red points
+        canvas.set_draw_color(Color::RED);
+        for point in &points {
+            canvas.draw_point(*point)?;
+        }
+
+        // Draw blue rectangle
+        canvas.set_draw_color(Color::BLUE);
+        let rect = Rect::new(100, 100, 440, 280);
+        canvas.fill_rect(rect)?;
+
+        // Draw green unfilled rectangle
+        canvas.set_draw_color(Color::GREEN);
+        let inner_rect = FRect::new(
+            (rect.x() + 30) as f32,
+            (rect.y() + 30) as f32,
+            (rect.width() - 60) as f32,
+            (rect.height() - 60) as f32,
+        );
+        let _ = canvas.draw_rect(inner_rect);
+
+        // Draw yellow lines
+        canvas.set_draw_color(Color::YELLOW);
+        canvas.draw_line(
+            Point::new(0, 0),
+            Point::new(WINDOW_WIDTH as i32, WINDOW_HEIGHT as i32),
+        )?;
+        canvas.draw_line(
+            Point::new(0, WINDOW_HEIGHT as i32),
+            Point::new(WINDOW_WIDTH as i32, 0),
+        )?;
+
+        // Present the rendered frame
+        canvas.present();
+    }
+}

examples/spinning_cube.rs

@@ -77,46 +77,39 @@ fn main() -> Result<(), String> {
     let mut canvas = window.into_canvas();
     let mut event_pump = sdl_context.event_pump()?;
 
+    #[rustfmt::skip]
     let vertices = [
+        // vertex 0
         Vertex {
-            x: -CUBE_SIZE,
-            y: -CUBE_SIZE,
-            z: -CUBE_SIZE,
+            x: -CUBE_SIZE, y: -CUBE_SIZE, z: -CUBE_SIZE,
         },
+        // vertex 1
         Vertex {
-            x: CUBE_SIZE,
-            y: -CUBE_SIZE,
-            z: -CUBE_SIZE,
+            x: CUBE_SIZE, y: -CUBE_SIZE, z: -CUBE_SIZE,
         },
+        // vertex 2
         Vertex {
-            x: CUBE_SIZE,
-            y: CUBE_SIZE,
-            z: -CUBE_SIZE,
+            x: CUBE_SIZE, y: CUBE_SIZE, z: -CUBE_SIZE,
         },
+        // vertex 3
         Vertex {
-            x: -CUBE_SIZE,
-            y: CUBE_SIZE,
-            z: -CUBE_SIZE,
+            x: -CUBE_SIZE, y: CUBE_SIZE, z: -CUBE_SIZE,
         },
+        // vertex 4
         Vertex {
-            x: -CUBE_SIZE,
-            y: -CUBE_SIZE,
-            z: CUBE_SIZE,
+            x: -CUBE_SIZE, y: -CUBE_SIZE, z: CUBE_SIZE,
         },
+        // vertex 5
         Vertex {
-            x: CUBE_SIZE,
-            y: -CUBE_SIZE,
-            z: CUBE_SIZE,
+            x: CUBE_SIZE, y: -CUBE_SIZE, z: CUBE_SIZE,
         },
+        // vertex 6
         Vertex {
-            x: CUBE_SIZE,
-            y: CUBE_SIZE,
-            z: CUBE_SIZE,
+            x: CUBE_SIZE, y: CUBE_SIZE, z: CUBE_SIZE,
         },
+        // vertex 7
         Vertex {
-            x: -CUBE_SIZE,
-            y: CUBE_SIZE,
-            z: CUBE_SIZE,
+            x: -CUBE_SIZE, y: CUBE_SIZE, z: CUBE_SIZE,
         },
     ];