main.rs

extern crate sdl2;

use sdl2::pixels::Color;
use sdl2::event::Event;
use sdl2::keyboard::Keycode;
use sdl2::rect::Rect;

const BORDER: i32 = 32;
const WIDTH: i32 = 1024;
const HEIGHT: i32 = 768;

trait Updatable
{
	fn update(&mut self, delta: f32);
}

fn update<T: Updatable>(t: &mut T, delta: f32)
{
	t.update(delta);
}


trait Drawable
{
	fn draw(&self, renderer: &mut sdl2::render::Renderer);
}

fn draw<T: Drawable>(t: &T, renderer: &mut sdl2::render::Renderer)
{
	t.draw(renderer);
}


/**
 * Ball.
 */
struct Ball
{
	x: f32,
	y: f32,
	radius: f32,
	dx: f32,
	dy: f32,
}

impl Ball
{
	fn new (x: f32, y: f32, radius: f32) -> Ball
	{
		Ball
		{
			x: x,
			y: y,
			radius: radius,
			dx: 1.0,
			dy: 1.0,
		}
	}
}

impl Updatable for Ball
{
	fn update(&mut self, delta: f32)
	{
		self.x += self.dx * delta;
		self.y += self.dy * delta;

		if self.x > (WIDTH - BORDER) as f32 || self.x < BORDER as f32
		{
			self.dx = -self.dx;
		}
		if self.y > (HEIGHT - BORDER) as f32 || self.y < BORDER as f32
		{
			self.dy = -self.dy;
		}
	}
}

impl Drawable for Ball
{
	fn draw(&self, renderer: &mut sdl2::render::Renderer)
	{
		let draw_rect = Rect::new(self.x as i32, self.y as i32, self.radius as u32, self.radius as u32);
		renderer.set_draw_color(Color::RGB(0, 255, 0));
		match renderer.draw_rect(draw_rect)
		{
			_ => {}
		}
	}
}


fn main()
{
	let ctx = sdl2::init().unwrap();
	let video_ctx = ctx.video().unwrap();

	let window = match video_ctx.window("sdl2_test", WIDTH as u32, HEIGHT as u32).position_centered().opengl().build()
	{
		Ok(window) => window,
		Err(err) => panic!("Failed to create window: {}", err)
	};

	let mut renderer = window.renderer().build().unwrap();

	renderer.set_draw_color(Color::RGB(0, 0, 0));
	renderer.clear();
	renderer.present();

	let mut event_pump = ctx.event_pump().unwrap();


	let mut test_ball = Ball::new((WIDTH / 2) as f32, (HEIGHT / 2) as f32, 8.0);

	'running: loop
	{
		for event in event_pump.poll_iter()
		{
			match event
			{
				Event::Quit {..} => break 'running,
				Event::KeyDown { keycode: Some(Keycode::Escape), .. } => break 'running,
				_ => {}
			}
		}

		// Clear screen.
		renderer.set_draw_color(Color::RGB(0, 0, 0));
		renderer.clear();

		// 
		let draw_rect = Rect::new(BORDER, BORDER, (WIDTH - BORDER * 2) as u32, (HEIGHT - BORDER * 2) as u32);
		renderer.set_draw_color(Color::RGB(255, 0, 255));
		match renderer.draw_rect(draw_rect)
		{
			_ => {}
		}

		update(&mut test_ball, 0.01);
		draw(&test_ball, &mut renderer);

		// Do present.
		renderer.present();
	}
}