crates/khronos-egl/examples/wayland-static.rs - platform/external/rust/android-crates-io - Git at Google

 extern crate khronos_egl as egl;

 use egl::API as egl;
 use gl::types::{GLboolean, GLchar, GLenum, GLint, GLuint, GLvoid};
 use std::ffi::CStr;
 use std::ptr;
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::Arc;

 use wayland_client::{
 	protocol::{wl_compositor::WlCompositor, wl_surface::WlSurface},
 	DispatchData, Display, EventQueue, Main,
 };

 use wayland_protocols::xdg_shell::client::{
 	xdg_surface::{self, XdgSurface},
 	xdg_wm_base::{self, XdgWmBase},
 };

 fn process_xdg_event(xdg: Main<XdgWmBase>, event: xdg_wm_base::Event, _dd: DispatchData) {
 	use xdg_wm_base::Event::*;

 	match event {
 		Ping { serial } => xdg.pong(serial),
 		_ => (),
 	}
 }

 struct DisplayConnection {
 	display: Display,
 	event_queue: EventQueue,
 	compositor: Main<WlCompositor>,
 	xdg: Main<XdgWmBase>,
 }

 fn setup_wayland() -> DisplayConnection {
 	let display =
 		wayland_client::Display::connect_to_env().expect("unable to connect to the wayland server");
 	let mut event_queue = display.create_event_queue();
 	let attached_display = display.clone().attach(event_queue.token());

 	let globals = wayland_client::GlobalManager::new(&attached_display);

 	// Roundtrip to retrieve the globals list
 	event_queue
 		.sync_roundtrip(&mut (), |_, _, _| unreachable!())
 		.unwrap();

 	// Get the compositor.
 	let compositor: Main<WlCompositor> = globals.instantiate_exact(1).unwrap();

 	// Xdg protocol.
 	let xdg: Main<XdgWmBase> = globals.instantiate_exact(1).unwrap();
 	xdg.quick_assign(process_xdg_event);

 	DisplayConnection {
 		display,
 		event_queue,
 		compositor,
 		xdg,
 	}
 }

 fn setup_egl(display: &Display) -> egl::Display {
 	let egl_display = unsafe {
 		egl.get_display(display.get_display_ptr() as *mut std::ffi::c_void)
 			.unwrap()
 	};

 	egl.initialize(egl_display).unwrap();
 	egl_display
 }

 fn create_context(display: egl::Display) -> (egl::Context, egl::Config) {
 	let attributes = [
 		egl::RED_SIZE,
 		8,
 		egl::GREEN_SIZE,
 		8,
 		egl::BLUE_SIZE,
 		8,
 		egl::NONE,
 	];

 	let config = egl
 		.choose_first_config(display, &attributes)
 		.expect("unable to choose an EGL configuration")
 		.expect("no EGL configuration found");

 	let context_attributes = [
 		egl::CONTEXT_MAJOR_VERSION,
 		4,
 		egl::CONTEXT_MINOR_VERSION,
 		0,
 		egl::CONTEXT_OPENGL_PROFILE_MASK,
 		egl::CONTEXT_OPENGL_CORE_PROFILE_BIT,
 		egl::NONE,
 	];

 	let context = egl
 		.create_context(display, config, None, &context_attributes)
 		.expect("unable to create an EGL context");

 	(context, config)
 }

 struct Surface {
 	handle: Main<WlSurface>,
 	initialized: AtomicBool,
 }

 fn create_surface(
 	ctx: &DisplayConnection,
 	egl_display: egl::Display,
 	egl_context: egl::Context,
 	egl_config: egl::Config,
 	width: i32,
 	height: i32,
 ) -> Arc<Surface> {
 	let wl_surface = ctx.compositor.create_surface();
 	let xdg_surface = ctx.xdg.get_xdg_surface(&wl_surface);

 	let xdg_toplevel = xdg_surface.get_toplevel();
 	xdg_toplevel.set_app_id("khronos-egl-test".to_string());
 	xdg_toplevel.set_title("Test".to_string());

 	wl_surface.commit();
 	ctx.display.flush().unwrap();

 	let surface = Arc::new(Surface {
 		handle: wl_surface,
 		initialized: AtomicBool::new(false),
 	});

 	let weak_surface = Arc::downgrade(&surface);

 	xdg_surface.quick_assign(
 		move |xdg_surface: Main<XdgSurface>, event: xdg_surface::Event, _dd: DispatchData| {
 			use xdg_surface::Event::*;

 			match event {
 				Configure { serial } => {
 					if let Some(surface) = weak_surface.upgrade() {
 						if !surface.initialized.swap(true, Ordering::Relaxed) {
 							let wl_egl_surface =
 								wayland_egl::WlEglSurface::new(&surface.handle, width, height);

 							let egl_surface = unsafe {
 								egl.create_window_surface(
 									egl_display,
 									egl_config,
 									wl_egl_surface.ptr() as egl::NativeWindowType,
 									None,
 								)
 								.expect("unable to create an EGL surface")
 							};

 							egl.make_current(
 								egl_display,
 								Some(egl_surface),
 								Some(egl_surface),
 								Some(egl_context),
 							)
 							.expect("unable to bind the context");

 							render();

 							egl.swap_buffers(egl_display, egl_surface)
 								.expect("unable to post the surface content");

 							xdg_surface.ack_configure(serial);
 						}
 					}
 				}
 				_ => (),
 			}
 		},
 	);

 	surface
 }

 fn main() {
 	// Setup Open GL.
 	egl.bind_api(egl::OPENGL_API)
 		.expect("unable to select OpenGL API");
 	gl::load_with(|name| egl.get_proc_address(name).unwrap() as *const std::ffi::c_void);

 	// Setup the Wayland client.
 	let mut ctx = setup_wayland();

 	// Setup EGL.
 	let egl_display = setup_egl(&ctx.display);
 	let (egl_context, egl_config) = create_context(egl_display);

 	// Create a surface.
 	// Note that it must be kept alive to the end of execution.
 	let _surface = create_surface(&ctx, egl_display, egl_context, egl_config, 800, 600);

 	loop {
 		ctx.event_queue
 			.dispatch(&mut (), |_, _, _| { /* we ignore unfiltered messages */ })
 			.unwrap();
 	}
 }

 const VERTEX: &'static [GLint; 8] = &[-1, -1, 1, -1, 1, 1, -1, 1];

 const INDEXES: &'static [GLuint; 4] = &[0, 1, 2, 3];

 const VERTEX_SHADER: &[u8] = b"#version 400
 in vec2 position;

 void main() {
 	gl_Position = vec4(position, 0.0f, 1.0f);
 }
 \0";

 const FRAGMENT_SHADER: &[u8] = b"#version 400
 out vec4 color;

 void main() {
 	color = vec4(1.0f, 0.0f, 0.0f, 1.0f);
 }
 \0";

 fn render() {
 	unsafe {
 		let vertex_shader = gl::CreateShader(gl::VERTEX_SHADER);
 		check_gl_errors();
 		let src = CStr::from_bytes_with_nul_unchecked(VERTEX_SHADER).as_ptr();
 		gl::ShaderSource(vertex_shader, 1, (&[src]).as_ptr(), ptr::null());
 		check_gl_errors();
 		gl::CompileShader(vertex_shader);
 		check_shader_status(vertex_shader);

 		let fragment_shader = gl::CreateShader(gl::FRAGMENT_SHADER);
 		check_gl_errors();
 		let src = CStr::from_bytes_with_nul_unchecked(FRAGMENT_SHADER).as_ptr();
 		gl::ShaderSource(fragment_shader, 1, (&[src]).as_ptr(), ptr::null());
 		check_gl_errors();
 		gl::CompileShader(fragment_shader);
 		check_shader_status(fragment_shader);

 		let program = gl::CreateProgram();
 		check_gl_errors();
 		gl::AttachShader(program, vertex_shader);
 		check_gl_errors();
 		gl::AttachShader(program, fragment_shader);
 		check_gl_errors();
 		gl::LinkProgram(program);
 		check_gl_errors();
 		gl::UseProgram(program);
 		check_gl_errors();

 		let mut buffer = 0;
 		gl::GenBuffers(1, &mut buffer);
 		check_gl_errors();
 		gl::BindBuffer(gl::ARRAY_BUFFER, buffer);
 		check_gl_errors();
 		gl::BufferData(
 			gl::ARRAY_BUFFER,
 			8 * 4,
 			VERTEX.as_ptr() as *const std::ffi::c_void,
 			gl::STATIC_DRAW,
 		);
 		check_gl_errors();

 		let mut vertex_input = 0;
 		gl::GenVertexArrays(1, &mut vertex_input);
 		check_gl_errors();
 		gl::BindVertexArray(vertex_input);
 		check_gl_errors();
 		gl::EnableVertexAttribArray(0);
 		check_gl_errors();
 		gl::VertexAttribPointer(0, 2, gl::INT, gl::FALSE as GLboolean, 0, 0 as *const GLvoid);
 		check_gl_errors();

 		let mut indexes = 0;
 		gl::GenBuffers(1, &mut indexes);
 		check_gl_errors();
 		gl::BindBuffer(gl::ELEMENT_ARRAY_BUFFER, indexes);
 		check_gl_errors();
 		gl::BufferData(
 			gl::ELEMENT_ARRAY_BUFFER,
 			4 * 4,
 			INDEXES.as_ptr() as *const std::ffi::c_void,
 			gl::STATIC_DRAW,
 		);
 		check_gl_errors();

 		gl::DrawElements(gl::TRIANGLE_FAN, 4, gl::UNSIGNED_INT, std::ptr::null());
 		check_gl_errors();
 	}
 }

 fn format_error(e: GLenum) -> &'static str {
 	match e {
 		gl::NO_ERROR => "No error",
 		gl::INVALID_ENUM => "Invalid enum",
 		gl::INVALID_VALUE => "Invalid value",
 		gl::INVALID_OPERATION => "Invalid operation",
 		gl::INVALID_FRAMEBUFFER_OPERATION => "Invalid framebuffer operation",
 		gl::OUT_OF_MEMORY => "Out of memory",
 		gl::STACK_UNDERFLOW => "Stack underflow",
 		gl::STACK_OVERFLOW => "Stack overflow",
 		_ => "Unknown error",
 	}
 }

 pub fn check_gl_errors() {
 	unsafe {
 		match gl::GetError() {
 			gl::NO_ERROR => (),
 			e => {
 				panic!("OpenGL error: {}", format_error(e))
 			}
 		}
 	}
 }

 unsafe fn check_shader_status(shader: GLuint) {
 	let mut status = gl::FALSE as GLint;
 	gl::GetShaderiv(shader, gl::COMPILE_STATUS, &mut status);
 	if status != (gl::TRUE as GLint) {
 		let mut len = 0;
 		gl::GetProgramiv(shader, gl::INFO_LOG_LENGTH, &mut len);
 		if len > 0 {
 			let mut buf = Vec::with_capacity(len as usize);
 			buf.set_len((len as usize) - 1); // subtract 1 to skip the trailing null character
 			gl::GetProgramInfoLog(
 				shader,
 				len,
 				ptr::null_mut(),
 				buf.as_mut_ptr() as *mut GLchar,
 			);

 			let log = String::from_utf8(buf).unwrap();
 			eprintln!("shader compilation log:\n{}", log);
 		}

 		panic!("shader compilation failed");
 	}
 }
	extern crate khronos_egl as egl;

	use egl::API as egl;
	use gl::types::{GLboolean, GLchar, GLenum, GLint, GLuint, GLvoid};
	use std::ffi::CStr;
	use std::ptr;
	use std::sync::atomic::{AtomicBool, Ordering};
	use std::sync::Arc;

	use wayland_client::{
	protocol::{wl_compositor::WlCompositor, wl_surface::WlSurface},
	DispatchData, Display, EventQueue, Main,
	};

	use wayland_protocols::xdg_shell::client::{
	xdg_surface::{self, XdgSurface},
	xdg_wm_base::{self, XdgWmBase},
	};

	fn process_xdg_event(xdg: Main<XdgWmBase>, event: xdg_wm_base::Event, _dd: DispatchData) {
	use xdg_wm_base::Event::*;

	match event {
	Ping { serial } => xdg.pong(serial),
	_ => (),
	}
	}

	struct DisplayConnection {
	display: Display,
	event_queue: EventQueue,
	compositor: Main<WlCompositor>,
	xdg: Main<XdgWmBase>,
	}

	fn setup_wayland() -> DisplayConnection {
	let display =
	wayland_client::Display::connect_to_env().expect("unable to connect to the wayland server");
	let mut event_queue = display.create_event_queue();
	let attached_display = display.clone().attach(event_queue.token());

	let globals = wayland_client::GlobalManager::new(&attached_display);

	// Roundtrip to retrieve the globals list
	event_queue
	.sync_roundtrip(&mut (), \|_, _, _\| unreachable!())
	.unwrap();

	// Get the compositor.
	let compositor: Main<WlCompositor> = globals.instantiate_exact(1).unwrap();

	// Xdg protocol.
	let xdg: Main<XdgWmBase> = globals.instantiate_exact(1).unwrap();
	xdg.quick_assign(process_xdg_event);

	DisplayConnection {
	display,
	event_queue,
	compositor,
	xdg,
	}
	}

	fn setup_egl(display: &Display) -> egl::Display {
	let egl_display = unsafe {
	egl.get_display(display.get_display_ptr() as *mut std::ffi::c_void)
	.unwrap()
	};

	egl.initialize(egl_display).unwrap();
	egl_display
	}

	fn create_context(display: egl::Display) -> (egl::Context, egl::Config) {
	let attributes = [
	egl::RED_SIZE,
	8,
	egl::GREEN_SIZE,
	8,
	egl::BLUE_SIZE,
	8,
	egl::NONE,
	];

	let config = egl
	.choose_first_config(display, &attributes)
	.expect("unable to choose an EGL configuration")
	.expect("no EGL configuration found");

	let context_attributes = [
	egl::CONTEXT_MAJOR_VERSION,
	4,
	egl::CONTEXT_MINOR_VERSION,
	0,
	egl::CONTEXT_OPENGL_PROFILE_MASK,
	egl::CONTEXT_OPENGL_CORE_PROFILE_BIT,
	egl::NONE,
	];

	let context = egl
	.create_context(display, config, None, &context_attributes)
	.expect("unable to create an EGL context");

	(context, config)
	}

	struct Surface {
	handle: Main<WlSurface>,
	initialized: AtomicBool,
	}

	fn create_surface(
	ctx: &DisplayConnection,
	egl_display: egl::Display,
	egl_context: egl::Context,
	egl_config: egl::Config,
	width: i32,
	height: i32,
	) -> Arc<Surface> {
	let wl_surface = ctx.compositor.create_surface();
	let xdg_surface = ctx.xdg.get_xdg_surface(&wl_surface);

	let xdg_toplevel = xdg_surface.get_toplevel();
	xdg_toplevel.set_app_id("khronos-egl-test".to_string());
	xdg_toplevel.set_title("Test".to_string());

	wl_surface.commit();
	ctx.display.flush().unwrap();

	let surface = Arc::new(Surface {
	handle: wl_surface,
	initialized: AtomicBool::new(false),
	});

	let weak_surface = Arc::downgrade(&surface);

	xdg_surface.quick_assign(
	move \|xdg_surface: Main<XdgSurface>, event: xdg_surface::Event, _dd: DispatchData\| {
	use xdg_surface::Event::*;

	match event {
	Configure { serial } => {
	if let Some(surface) = weak_surface.upgrade() {
	if !surface.initialized.swap(true, Ordering::Relaxed) {
	let wl_egl_surface =
	wayland_egl::WlEglSurface::new(&surface.handle, width, height);

	let egl_surface = unsafe {
	egl.create_window_surface(
	egl_display,
	egl_config,
	wl_egl_surface.ptr() as egl::NativeWindowType,
	None,
	)
	.expect("unable to create an EGL surface")
	};

	egl.make_current(
	egl_display,
	Some(egl_surface),
	Some(egl_surface),
	Some(egl_context),
	)
	.expect("unable to bind the context");

	render();

	egl.swap_buffers(egl_display, egl_surface)
	.expect("unable to post the surface content");

	xdg_surface.ack_configure(serial);
	}
	}
	}
	_ => (),
	}
	},
	);

	surface
	}

	fn main() {
	// Setup Open GL.
	egl.bind_api(egl::OPENGL_API)
	.expect("unable to select OpenGL API");
	gl::load_with(\|name\| egl.get_proc_address(name).unwrap() as *const std::ffi::c_void);

	// Setup the Wayland client.
	let mut ctx = setup_wayland();

	// Setup EGL.
	let egl_display = setup_egl(&ctx.display);
	let (egl_context, egl_config) = create_context(egl_display);

	// Create a surface.
	// Note that it must be kept alive to the end of execution.
	let _surface = create_surface(&ctx, egl_display, egl_context, egl_config, 800, 600);

	loop {
	ctx.event_queue
	.dispatch(&mut (), \|_, _, _\| { /* we ignore unfiltered messages */ })
	.unwrap();
	}
	}

	const VERTEX: &'static [GLint; 8] = &[-1, -1, 1, -1, 1, 1, -1, 1];

	const INDEXES: &'static [GLuint; 4] = &[0, 1, 2, 3];

	const VERTEX_SHADER: &[u8] = b"#version 400
	in vec2 position;

	void main() {
	gl_Position = vec4(position, 0.0f, 1.0f);
	}
	\0";

	const FRAGMENT_SHADER: &[u8] = b"#version 400
	out vec4 color;

	void main() {
	color = vec4(1.0f, 0.0f, 0.0f, 1.0f);
	}
	\0";

	fn render() {
	unsafe {
	let vertex_shader = gl::CreateShader(gl::VERTEX_SHADER);
	check_gl_errors();
	let src = CStr::from_bytes_with_nul_unchecked(VERTEX_SHADER).as_ptr();
	gl::ShaderSource(vertex_shader, 1, (&[src]).as_ptr(), ptr::null());
	check_gl_errors();
	gl::CompileShader(vertex_shader);
	check_shader_status(vertex_shader);

	let fragment_shader = gl::CreateShader(gl::FRAGMENT_SHADER);
	check_gl_errors();
	let src = CStr::from_bytes_with_nul_unchecked(FRAGMENT_SHADER).as_ptr();
	gl::ShaderSource(fragment_shader, 1, (&[src]).as_ptr(), ptr::null());
	check_gl_errors();
	gl::CompileShader(fragment_shader);
	check_shader_status(fragment_shader);

	let program = gl::CreateProgram();
	check_gl_errors();
	gl::AttachShader(program, vertex_shader);
	check_gl_errors();
	gl::AttachShader(program, fragment_shader);
	check_gl_errors();
	gl::LinkProgram(program);
	check_gl_errors();
	gl::UseProgram(program);
	check_gl_errors();

	let mut buffer = 0;
	gl::GenBuffers(1, &mut buffer);
	check_gl_errors();
	gl::BindBuffer(gl::ARRAY_BUFFER, buffer);
	check_gl_errors();
	gl::BufferData(
	gl::ARRAY_BUFFER,
	8 * 4,
	VERTEX.as_ptr() as *const std::ffi::c_void,
	gl::STATIC_DRAW,
	);
	check_gl_errors();

	let mut vertex_input = 0;
	gl::GenVertexArrays(1, &mut vertex_input);
	check_gl_errors();
	gl::BindVertexArray(vertex_input);
	check_gl_errors();
	gl::EnableVertexAttribArray(0);
	check_gl_errors();
	gl::VertexAttribPointer(0, 2, gl::INT, gl::FALSE as GLboolean, 0, 0 as *const GLvoid);
	check_gl_errors();

	let mut indexes = 0;
	gl::GenBuffers(1, &mut indexes);
	check_gl_errors();
	gl::BindBuffer(gl::ELEMENT_ARRAY_BUFFER, indexes);
	check_gl_errors();
	gl::BufferData(
	gl::ELEMENT_ARRAY_BUFFER,
	4 * 4,
	INDEXES.as_ptr() as *const std::ffi::c_void,
	gl::STATIC_DRAW,
	);
	check_gl_errors();

	gl::DrawElements(gl::TRIANGLE_FAN, 4, gl::UNSIGNED_INT, std::ptr::null());
	check_gl_errors();
	}
	}

	fn format_error(e: GLenum) -> &'static str {
	match e {
	gl::NO_ERROR => "No error",
	gl::INVALID_ENUM => "Invalid enum",
	gl::INVALID_VALUE => "Invalid value",
	gl::INVALID_OPERATION => "Invalid operation",
	gl::INVALID_FRAMEBUFFER_OPERATION => "Invalid framebuffer operation",
	gl::OUT_OF_MEMORY => "Out of memory",
	gl::STACK_UNDERFLOW => "Stack underflow",
	gl::STACK_OVERFLOW => "Stack overflow",
	_ => "Unknown error",
	}
	}

	pub fn check_gl_errors() {
	unsafe {
	match gl::GetError() {
	gl::NO_ERROR => (),
	e => {
	panic!("OpenGL error: {}", format_error(e))
	}
	}
	}
	}

	unsafe fn check_shader_status(shader: GLuint) {
	let mut status = gl::FALSE as GLint;
	gl::GetShaderiv(shader, gl::COMPILE_STATUS, &mut status);
	if status != (gl::TRUE as GLint) {
	let mut len = 0;
	gl::GetProgramiv(shader, gl::INFO_LOG_LENGTH, &mut len);
	if len > 0 {
	let mut buf = Vec::with_capacity(len as usize);
	buf.set_len((len as usize) - 1); // subtract 1 to skip the trailing null character
	gl::GetProgramInfoLog(
	shader,
	len,
	ptr::null_mut(),
	buf.as_mut_ptr() as *mut GLchar,
	);

	let log = String::from_utf8(buf).unwrap();
	eprintln!("shader compilation log:\n{}", log);
	}

	panic!("shader compilation failed");
	}
	}