Basic implementation of emscripten

README.md

@@ -47,6 +47,7 @@ fn main() {
 ### Emscripten
 
  - Work will start when Emscripten gets updated to LLVM 3.5 (which should happen soon)
+ - Compilation must be done by running `rustc -o intermediate.ll --emit ir` then `emcc intermediate.ll`
 
 ### OS/X
 

src/emscripten/ffi.rs

@@ -1,5 +1,5 @@
 #![allow(dead_code)]
-#![allow(non_snake_case_functions)]
+#![allow(non_snake_case)]
 #![allow(non_camel_case_types)]
 
 use libc;
@@ -14,17 +14,17 @@ pub type em_webgl_context_callback = extern fn(libc::c_int, *const libc::c_void,
 
 #[repr(C)]
 pub struct EmscriptenWebGLContextAttributes {
-    alpha: EM_BOOL,
-    depth: EM_BOOL,
-    stencil: EM_BOOL,
-    antialias: EM_BOOL,
-    premultipliedAlpha: EM_BOOL,
-    preserveDrawingBuffer: EM_BOOL,
-    preferLowPowerToHighPerformance: EM_BOOL,
-    failIfMajorPerformanceCaveat: EM_BOOL,
-    majorVersion: libc::c_int,
-    minorVersion: libc::c_int,
-    enableExtensionsByDefault: EM_BOOL,
+    pub alpha: EM_BOOL,
+    pub depth: EM_BOOL,
+    pub stencil: EM_BOOL,
+    pub antialias: EM_BOOL,
+    pub premultipliedAlpha: EM_BOOL,
+    pub preserveDrawingBuffer: EM_BOOL,
+    pub preferLowPowerToHighPerformance: EM_BOOL,
+    pub failIfMajorPerformanceCaveat: EM_BOOL,
+    pub majorVersion: libc::c_int,
+    pub minorVersion: libc::c_int,
+    pub enableExtensionsByDefault: EM_BOOL,
 }
 
 // values for EMSCRIPTEN_RESULT
@@ -41,7 +41,7 @@ pub static EMSCRIPTEN_RESULT_NO_DATA: libc::c_int = -7;
 extern {
     pub fn emscripten_webgl_init_context_attributes(attributes: *mut EmscriptenWebGLContextAttributes);
     pub fn emscripten_webgl_create_context(target: *const libc::c_char,
-        attributes: *const EmscriptenWebGLContextAttributes);
+        attributes: *const EmscriptenWebGLContextAttributes) -> EMSCRIPTEN_WEBGL_CONTEXT_HANDLE;
 
     pub fn emscripten_webgl_make_context_current(context: EMSCRIPTEN_WEBGL_CONTEXT_HANDLE)
     -> EMSCRIPTEN_RESULT;
@@ -62,4 +62,19 @@ extern {
         -> EMSCRIPTEN_RESULT;
 
     pub fn emscripten_is_webgl_context_lost(target: *const libc::c_char) -> EM_BOOL;
+
+    // note: this function is not documented but is used by the ports of glfw, SDL and EGL
+    pub fn emscripten_GetProcAddress(name: *const libc::c_char) -> *const libc::c_void;
+
+
+    pub fn emscripten_request_fullscreen(target: *const libc::c_char,
+        deferUntilInEventHandler: EM_BOOL) -> EMSCRIPTEN_RESULT;
+
+    pub fn emscripten_exit_fullscreen() -> EMSCRIPTEN_RESULT;
+
+    pub fn emscripten_set_element_css_size(target: *const libc::c_char, width: libc::c_double,
+        height: libc::c_double) -> EMSCRIPTEN_RESULT;
+
+    pub fn emscripten_get_element_css_size(target: *const libc::c_char, width: *mut libc::c_double,
+        height: *mut libc::c_double) -> EMSCRIPTEN_RESULT;
 }

src/emscripten/mod.rs

@@ -1,8 +1,11 @@
+use libc;
 use {Event, WindowBuilder};
 
 mod ffi;
 
-pub struct Window;
+pub struct Window {
+    context: ffi::EMSCRIPTEN_WEBGL_CONTEXT_HANDLE,
+}
 
 pub struct MonitorID;
 
@@ -25,36 +28,83 @@ impl MonitorID {
 }
 
 impl Window {
-    pub fn new(_builder: WindowBuilder) -> Result<Window, String> {
-        unimplemented!()
+    pub fn new(builder: WindowBuilder) -> Result<Window, String> {
+        // getting the default values of attributes
+        let mut attributes = unsafe {
+            use std::mem;
+            let mut attributes: ffi::EmscriptenWebGLContextAttributes = mem::uninitialized();
+            ffi::emscripten_webgl_init_context_attributes(&mut attributes);
+            attributes
+        };
+
+        // setting the attributes
+        match builder.gl_version {
+            Some((major, minor)) => {
+                attributes.majorVersion = major as libc::c_int;
+                attributes.minorVersion = minor as libc::c_int;
+            },
+            None => ()
+        };
+
+        // creating the context
+        let context = unsafe {
+            use std::{mem, ptr};
+            let context = ffi::emscripten_webgl_create_context(ptr::null(), &attributes);
+            if context <= 0 {
+                return Err(format!("Error while calling emscripten_webgl_create_context: {}",
+                    error_to_str(mem::transmute(context))));
+            }
+            context
+        };
+
+        // TODO: emscripten_set_webglcontextrestored_callback
+
+        Ok(Window {
+            context: context
+        })
     }
 
     pub fn is_closed(&self) -> bool {
-        unimplemented!()
+        use std::ptr;
+        unsafe { ffi::emscripten_is_webgl_context_lost(ptr::null()) != 0 }
     }
 
     pub fn set_title(&self, _title: &str) {
-        unimplemented!()
     }
 
     pub fn get_position(&self) -> Option<(int, int)> {
-        unimplemented!()
+        Some((0, 0))
     }
 
-    pub fn set_position(&self, _x: int, _y: int) {
-        unimplemented!()
+    pub fn set_position(&self, _: int, _: int) {
     }
 
     pub fn get_inner_size(&self) -> Option<(uint, uint)> {
-        unimplemented!()
+        unsafe {
+            use std::{mem, ptr};
+            let mut width = mem::uninitialized();
+            let mut height = mem::uninitialized();
+
+            if ffi::emscripten_get_element_css_size(ptr::null(), &mut width, &mut height)
+                != ffi::EMSCRIPTEN_RESULT_SUCCESS
+            {
+                None
+            } else {
+                Some((width as uint, height as uint))
+            }
+        }
     }
 
     pub fn get_outer_size(&self) -> Option<(uint, uint)> {
-        unimplemented!()
+        self.get_inner_size()
     }
 
-    pub fn set_inner_size(&self, _x: uint, _y: uint) {
-        unimplemented!()
+    pub fn set_inner_size(&self, width: uint, height: uint) {
+        unsafe {
+            use std::ptr;
+            ffi::emscripten_set_element_css_size(ptr::null(), width as libc::c_double, height
+                as libc::c_double);
+        }
     }
 
     pub fn poll_events(&self) -> Vec<Event> {
@@ -66,14 +116,44 @@ impl Window {
     }
 
     pub unsafe fn make_current(&self) {
-        unimplemented!()
+        // TOOD: check if == EMSCRIPTEN_RESULT
+        ffi::emscripten_webgl_make_context_current(self.context);
     }
 
-    pub fn get_proc_address(&self, _addr: &str) -> *const () {
-        unimplemented!()
+    pub fn get_proc_address(&self, addr: &str) -> *const () {
+        addr.with_c_str(|s| {
+            unsafe { ffi::emscripten_GetProcAddress(s) as *const () }
+        })
     }
 
     pub fn swap_buffers(&self) {
-        unimplemented!()
+        // there is no need to swap buffers in webgl
+        // the browser avoids drawing our buffer as long as we continue to execute code
+    }
+}
+
+impl Drop for Window {
+    fn drop(&mut self) {
+        unsafe {
+            ffi::emscripten_exit_fullscreen();
+            ffi::emscripten_webgl_destroy_context(self.context);
+        }
+    }
+}
+
+fn error_to_str(code: ffi::EMSCRIPTEN_RESULT) -> &'static str {
+    match code {
+        ffi::EMSCRIPTEN_RESULT_SUCCESS | ffi::EMSCRIPTEN_RESULT_DEFERRED
+            => "Internal error in the library (success detected as failure)",
+
+        ffi::EMSCRIPTEN_RESULT_NOT_SUPPORTED => "Not supported",
+        ffi::EMSCRIPTEN_RESULT_FAILED_NOT_DEFERRED => "Failed not deferred",
+        ffi::EMSCRIPTEN_RESULT_INVALID_TARGET => "Invalid target",
+        ffi::EMSCRIPTEN_RESULT_UNKNOWN_TARGET => "Unknown target",
+        ffi::EMSCRIPTEN_RESULT_INVALID_PARAM => "Invalid parameter",
+        ffi::EMSCRIPTEN_RESULT_FAILED => "Failed",
+        ffi::EMSCRIPTEN_RESULT_NO_DATA => "No data",
+
+        _ => "Undocumented error"
     }
 }