lexsdl 0.3.0

A wrapper for SDL2 to abstract away annoying parts
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

// C
pub mod sys;
pub use sys::*;

pub mod types;
pub use types::*;

pub mod particle;
pub use particle::*;


/// Parameters for initializing lexsdl.
#[derive(Clone,PartialEq)]
pub struct LexSdlOptions {
	/// use vsync
	pub vsync: bool,
	/// [`None`] will let sdl decide what to do.
	pub hardware_acceleration: Option<bool>,
	/// fullscreen.
	pub fullscreen: bool,
	/// title of the window/program.
	pub title: String,
	/// size of the window where `x` is width and `y` height
	pub window_size: lexlib::Vec2,
	/// allow the window to be resizable.
	pub window_resizable: bool,
	/// use window decorations.
	pub window_decorations: bool,
}

impl Default for LexSdlOptions {
	fn default() -> Self {
		Self {
			vsync: true,
			hardware_acceleration: None,
			fullscreen: false,
			title: "lexSDL window".to_owned(),
			window_size: lexlib::Vec2::new(800,600),
			window_resizable: true,
			window_decorations: true,
		}
	}
}

/// Initializes lexsdl and internally sdl with the desired options.
pub fn init(options: &LexSdlOptions) -> Result<(),i32> {
	// initialize sdl
	unsafe {
		let err = LEXSDL_Init(0);
		if err != 0 {
			return Err(err);}
	}
	
	// initialize sdl_image
	unsafe {
		let err = LEXSDL_InitIMG(0);
		if err != 0 {
			return Err(err);}
	}
	
	unsafe {
		let mut window_flags = 0;
		if options.fullscreen {
			window_flags |= 0x00000001;}
		if !options.window_decorations {
			window_flags |= 0x00000010;}
			
		#[allow(temporary_cstring_as_ptr)] //this should be safe
		let err = LEXSDL_CreateWindowSized(std::ffi::CString::new(&*options.title).expect("invalid window title, does it contain a 0 byte?").as_ptr(), options.window_size.x,options.window_size.y, window_flags);
		
		if err.is_null() {
			return Err(-1);}
	}
	
	unsafe {
		let mut renderer_flags = 0;
		if options.vsync {
			renderer_flags |= 0x00000004;}
		match options.hardware_acceleration {
			Some(v)	=> if v {
					renderer_flags |= 0x00000002;
				} else {
					renderer_flags |= 0x00000001;
				}
			None => {}
		}
		
		let err = LEXSDL_CreateRenderer(renderer_flags);
		if err.is_null(){
			return Err(-2);}
	}
	
	Ok(())
}

/// quits LEXSDL and internally SDL.
pub fn quit(){
	unsafe{
		LEXSDL_Terminate();
		LEXSDL_Quit();
	}
}

/// run in a loop until [`LEXSDL_EventQuit`] is triggered.
pub fn run<F>(instructions: F) 
where F: Fn() {
	while unsafe {LEXSDL_EventQuit()} == 0 {
		unsafe {
			LEXSDL_HandleEvents();
			LEXSDL_NewFrame();
		}
	
		instructions();
	
		unsafe {
			LEXSDL_ShowFrame();
		}
	}
}