chore: updates

Author: triniwiz

crates/canvas-2d/src/context/surface_gl.rs

@@ -84,8 +84,6 @@ impl Context {
             frame_buffer.format = GR_GL_RGB565;
         }
 
-        println!("??? {width} {height}");
-
         let target = gpu::backend_render_targets::make_gl(
             (width as i32, height as i32),
             Some(0),

crates/canvas-c/src/buffers.rs

@@ -101,6 +101,10 @@ impl U16Buffer {
     pub fn length(&self) -> usize {
         self.0.len()
     }
+
+    pub fn into_vec(self) -> Vec<u16> {
+        self.0
+    }
 }
 
 impl Default for U16Buffer {
@@ -133,6 +137,10 @@ impl F32Buffer {
     pub fn length(&self) -> usize {
         self.0.len()
     }
+
+    pub fn into_vec(self) -> Vec<f32> {
+        self.0
+    }
 }
 
 impl Default for F32Buffer {
@@ -164,6 +172,10 @@ impl I32Buffer {
     pub fn length(&self) -> usize {
         self.0.len()
     }
+
+    pub fn into_vec(self) -> Vec<i32> {
+        self.0
+    }
 }
 
 impl Default for I32Buffer {
@@ -196,6 +208,10 @@ impl U32Buffer {
     pub fn length(&self) -> usize {
         self.0.len()
     }
+
+    pub fn into_vec(self) -> Vec<u32> {
+        self.0
+    }
 }
 
 impl Default for U32Buffer {

crates/canvas-c/src/text_decoder.rs

@@ -7,6 +7,17 @@ use crate::c2d::CCow;
 #[derive(Clone)]
 pub struct TextDecoder(canvas_2d::context::text_decoder::TextDecoder);
 
+impl TextDecoder {
+    pub fn encoding(&self) -> &str {
+        self.0.encoding()
+    }
+
+    pub fn decode(&self, data: &[u8]) -> String {
+        self.0.decode_to_string(data)
+    }
+}
+
+
 #[no_mangle]
 pub extern "C" fn canvas_native_text_decoder_release(value: *mut TextDecoder) {
     if value.is_null() {

crates/canvas-c/src/text_encoder.rs

@@ -5,6 +5,15 @@ use crate::buffers::U8Buffer;
 
 #[derive(Clone)]
 pub struct TextEncoder(canvas_2d::context::text_encoder::TextEncoder);
+impl TextEncoder {
+    pub fn encoding(&self) -> &str {
+        self.0.encoding()
+    }
+
+    pub fn encode(&self, value: &str) -> Vec<u8> {
+        self.0.encode(value)
+    }
+}
 
 #[no_mangle]
 pub extern "C" fn canvas_native_text_encoder_release(value: *mut TextEncoder) {

crates/canvas-c/src/webgl/gl.rs

@@ -1,12 +1,11 @@
 /* GL */
-use std::ffi::{CStr, CString};
-use std::os::raw::{c_char, c_void};
-use std::ptr::NonNull;
-use canvas_2d::context::SurfaceEngine::CPU;
 use canvas_2d::utils::image::from_image_slice;
 use canvas_core::context_attributes::PowerPreference;
 use canvas_core::gpu::gl::GLContext;
 use canvas_webgl::prelude::WebGLVersion;
+use std::ffi::{CStr, CString};
+use std::os::raw::{c_char, c_void};
+use std::ptr::NonNull;
 
 use crate::buffers::{F32Buffer, I32Buffer, StringBuffer, U32Buffer, U8Buffer};
 use crate::c2d::CanvasRenderingContext2D;
@@ -277,7 +276,7 @@ pub extern "C" fn canvas_native_webgl_state_destroy(state: *mut WebGLState) {
 }
 
 impl WebGLState {
-   #[cfg(target_os = "android")]
+    #[cfg(target_os = "android")]
     pub fn new_with_view(
         view: *mut c_void,
         width: i32,
@@ -534,6 +533,12 @@ impl WebGLShaderPrecisionFormat {
 
 pub struct WebGLExtension(Option<Box<dyn canvas_webgl::prelude::WebGLExtension>>);
 
+impl WebGLExtension {
+    pub fn new(extension: Option<Box<dyn canvas_webgl::prelude::WebGLExtension>>) -> Self {
+        Self(extension)
+    }
+}
+
 #[no_mangle]
 pub extern "C" fn canvas_native_webgl_extension_destroy(value: *mut WebGLExtension) {
     if value.is_null() {
@@ -1193,6 +1198,21 @@ pub extern "C" fn canvas_native_webgl_result_get_i32_array(
     })))
 }
 
+#[no_mangle]
+pub extern "C" fn canvas_native_webgl_result_into_i32_array(
+    result: *mut WebGLResult,
+) -> *mut I32Buffer {
+    if result.is_null() {
+        return std::ptr::null_mut();
+    }
+    let result = unsafe { *Box::from_raw(result) };
+    Box::into_raw(Box::new(I32Buffer::from(match result.0 {
+        canvas_webgl::prelude::WebGLResult::I32Array(value) => value,
+        _ => Vec::new(),
+    })))
+}
+
+
 #[no_mangle]
 pub extern "C" fn canvas_native_webgl_result_get_u32_array(
     result: *const WebGLResult,
@@ -1204,6 +1224,21 @@ pub extern "C" fn canvas_native_webgl_result_get_u32_array(
     })))
 }
 
+#[no_mangle]
+pub extern "C" fn canvas_native_webgl_result_into_u32_array(
+    result: *mut WebGLResult,
+) -> *mut U32Buffer {
+    if result.is_null() {
+        return std::ptr::null_mut();
+    }
+
+    let result = unsafe { *Box::from_raw(result) };
+    Box::into_raw(Box::new(U32Buffer::from(match result.0 {
+        canvas_webgl::prelude::WebGLResult::U32Array(value) => value,
+        _ => Vec::new(),
+    })))
+}
+
 #[no_mangle]
 pub extern "C" fn canvas_native_webgl_result_get_f32_array(
     result: *const WebGLResult,
@@ -1215,6 +1250,22 @@ pub extern "C" fn canvas_native_webgl_result_get_f32_array(
     })))
 }
 
+#[no_mangle]
+pub extern "C" fn canvas_native_webgl_result_into_f32_array(
+    result: *mut WebGLResult,
+) -> *mut F32Buffer {
+    if result.is_null() {
+        return std::ptr::null_mut();
+    }
+    let result = unsafe { *Box::from_raw(result) };
+
+    Box::into_raw(Box::new(F32Buffer::from(match result.0 {
+        canvas_webgl::prelude::WebGLResult::F32Array(value) => value,
+        _ => Vec::new(),
+    })))
+}
+
+
 #[no_mangle]
 pub extern "C" fn canvas_native_webgl_result_get_bool_array(
     result: *const WebGLResult,
@@ -1269,11 +1320,13 @@ pub extern "C" fn canvas_native_webgl_result_get_string(
                 return CString::new("WebGL 2.0 (OpenGL ES 3.0 NativeScript)")
                     .unwrap()
                     .into_raw();
+            } else if val.contains("OpenGL ES 2.") {
+                ret = CString::new("WebGL 1.0 (OpenGL ES 2.0 NativeScript)")
+                    .unwrap()
+                    .into_raw()
+            } else {
+                ret = result.clone().into_raw()
             }
-
-            ret = CString::new("WebGL 1.0 (OpenGL ES 2.0 NativeScript)")
-                .unwrap()
-                .into_raw()
         }
         _ => {
             ret = std::ptr::null_mut();

crates/canvas-core/Cargo.toml

@@ -21,7 +21,7 @@ ash = { version = "0.38.0", optional = true, features = ["libloading"] }
 ash-window = { version = "0.13.0", optional = true }
 
 [target.'cfg(any(target_os = "ios", target_os="macos"))'.dependencies]
-icrate = { version = "0.1.2", features = ["objc2", "Foundation", "Foundation_NSData"] }
+icrate = { version = "0.1.2", features = ["objc2", "Foundation", "Foundation_NSData", "Foundation_NSArray"] }
 core-foundation = "0.10.0"
 objc2-foundation = { version = "0.2.2", features = ["NSGeometry", "NSData", "NSAutoreleasePool"] }
 metal = { version = "0.30.0", optional = true }

crates/canvas-core/src/gpu/gl/mac.rs

@@ -1,13 +1,11 @@
-use std::ffi::c_void;
-use std::ptr::NonNull;
-use std::sync::OnceLock;
-
+use crate::context_attributes::ContextAttributes;
 use icrate::objc2::rc::Id;
 use icrate::objc2::{class, msg_send, msg_send_id};
 use objc2_foundation::NSObject;
 use raw_window_handle::RawWindowHandle;
-
-use crate::context_attributes::ContextAttributes;
+use std::ffi::c_void;
+use std::ptr::NonNull;
+use std::sync::OnceLock;
 
 pub static IS_GL_SYMBOLS_LOADED: OnceLock<bool> = OnceLock::new();
 
@@ -178,15 +176,16 @@ impl NSOpenGLContext {
 pub struct NSOpenGLPixelFormat(Id<NSObject>);
 
 impl NSOpenGLPixelFormat {
-    pub fn init_with_attributes(attribs: &[u32]) -> Self {
+    pub fn init_with_attributes(attribs: &[u32]) -> Option<Self> {
         let cls = class!(NSOpenGLPixelFormat);
-        let instance = unsafe { msg_send_id![cls, alloc] };
-        NSOpenGLPixelFormat(unsafe {
+        let alloc = unsafe { msg_send_id![cls, alloc] };
+        let instance: Option<Id<NSObject>> = unsafe {
             msg_send_id![
-                instance,
+                alloc,
                 initWithAttributes: attribs.as_ptr()
             ]
-        })
+        };
+        instance.map(|id| NSOpenGLPixelFormat(id))
     }
 }
 
@@ -241,16 +240,18 @@ impl NSOpenGLView {
 #[derive(Debug, Default)]
 pub struct GLContext(GLContextInner);
 
-fn parse_context_attributes(context_attrs: &ContextAttributes) -> NSOpenGLPixelFormat {
+fn parse_context_attributes(context_attrs: &ContextAttributes, accelerated: bool) -> Option<NSOpenGLPixelFormat> {
     let mut attributes = vec![
-        NSOpenGLPixelFormatAttribute::NSOpenGLPFAAccelerated as u32,
-        NSOpenGLPixelFormatAttribute::NSOpenGLPFADoubleBuffer as u32,
         NSOpenGLPixelFormatAttribute::NSOpenGLPFAOpenGLProfile as u32,
         NSOpenGLPFAOpenGLProfiles::NSOpenGLProfileVersion3_2Core as u32,
         NSOpenGLPixelFormatAttribute::NSOpenGLPFAColorSize as u32,
         24,
     ];
 
+    if accelerated {
+        attributes.push(NSOpenGLPixelFormatAttribute::NSOpenGLPFAAccelerated as u32);
+    }
+
     if context_attrs.get_alpha() {
         attributes.push(NSOpenGLPixelFormatAttribute::NSOpenGLPFAAlphaSize as u32);
         attributes.push(8);
@@ -274,6 +275,9 @@ fn parse_context_attributes(context_attrs: &ContextAttributes) -> NSOpenGLPixelF
         attributes.push(4);
     }
 
+    attributes.push(NSOpenGLPixelFormatAttribute::NSOpenGLPFADoubleBuffer as u32);
+    attributes.push(0);
+
     NSOpenGLPixelFormat::init_with_attributes(attributes.as_slice())
 }
 
@@ -363,14 +367,26 @@ impl GLContext {
                     NSOpenGLPixelFormatAttribute::NSOpenGLPFAOpenGLProfile as u32,
                     NSOpenGLPFAOpenGLProfiles::NSOpenGLProfileVersion3_2Core as u32,
                     0,
-                ]);
+                ])?;
                 NSOpenGLContext::new(format, None)
             }
         };
 
-        let format = parse_context_attributes(context_attrs);
+        let mut format = parse_context_attributes(context_attrs, true);
 
-        let context = NSOpenGLContext::new(format, share_group.clone());
+        if format.is_none() {
+            if context_attrs.get_antialias() {
+                context_attrs.set_antialias(false);
+            }
+
+            if context_attrs.get_preserve_drawing_buffer() {
+                context_attrs.set_preserve_drawing_buffer(false);
+            }
+
+            format = parse_context_attributes(context_attrs, false);
+        }
+
+        let context = NSOpenGLContext::new(format?, share_group.clone());
 
 
         if context.is_none() {
@@ -393,9 +409,24 @@ impl GLContext {
         width: i32,
         height: i32,
     ) -> Option<Self> {
-        let format = parse_context_attributes(context_attrs);
+        let mut format = parse_context_attributes(context_attrs, true);
+
+        if format.is_none() {
+            if context_attrs.get_antialias() {
+                context_attrs.set_antialias(false);
+            }
+
+            if context_attrs.get_preserve_drawing_buffer() {
+                context_attrs.set_preserve_drawing_buffer(false);
+            }
+
+            format = parse_context_attributes(context_attrs, false);
+        }
+
+
         let view =
-            NSOpenGLView::new_with_frame_pixel_format(0., 0., width as f32, height as f32, format);
+            NSOpenGLView::new_with_frame_pixel_format(0., 0., width as f32, height as f32, format?);
+
 
         GLContext::create_window_context_with_gl_view(context_attrs, view, None)
     }

crates/canvas-webgl/src/prelude.rs

@@ -442,7 +442,6 @@ impl WebGLState {
         if !self.context.make_current() {
             return false;
         }
-
         self.context.swap_buffers()
     }