fix(canvas): gl release

Author: triniwiz

crates/canvas-android/src/jni_compat/org_nativescript_canvas_NSCCanvas.rs

@@ -469,17 +469,15 @@ pub extern "system" fn nativeReleaseWebGL(context: jlong) {
     if context == 0 {
         return;
     }
-    let context = context as *mut WebGLState;
-    let _ = unsafe { Box::from_raw(context) };
+    canvas_c::canvas_native_webgl_state_destroy(context as *mut WebGLState);
 }
 
 #[no_mangle]
 pub extern "system" fn nativeReleaseWebGLNormal(_env: JNIEnv, _: JClass, context: jlong) {
     if context == 0 {
         return;
     }
-    let context = context as *mut WebGLState;
-    let _ = unsafe { Box::from_raw(context) };
+    canvas_c::canvas_native_webgl_state_destroy(context as *mut WebGLState);
 }
 
 #[no_mangle]

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

@@ -10,9 +10,11 @@ use canvas_2d::utils::image::from_image_slice;
 use canvas_core::context_attributes::{ColorSpace, PowerPreference};
 use canvas_core::gpu::gl::GLContext;
 use canvas_webgl::prelude::WebGLVersion;
+use std::collections::HashSet;
 use std::ffi::{CStr, CString};
 use std::os::raw::{c_char, c_void};
 use std::ptr::NonNull;
+use std::sync::{Mutex, OnceLock};
 
 /* GL */
 
@@ -275,12 +277,41 @@ impl WebGLState {
     }
 }
 
-#[no_mangle]
-pub extern "C" fn canvas_native_webgl_state_destroy(state: *mut WebGLState) {
-    if state.is_null() {
+// keeps track of all live WebGLState handles so we can avoid double-freeing them
+// todo : this is a bit of a hack, but it works for now. We should probably use a more robust solution in the future.
+fn webgl_state_live() -> &'static Mutex<HashSet<usize>> {
+    static LIVE: OnceLock<Mutex<HashSet<usize>>> = OnceLock::new();
+    LIVE.get_or_init(|| Mutex::new(HashSet::new()))
+}
+
+#[inline]
+fn webgl_state_register(ptr: *mut WebGLState) -> *mut WebGLState {
+    if !ptr.is_null() {
+        webgl_state_live()
+            .lock()
+            .unwrap_or_else(|e| e.into_inner())
+            .insert(ptr as usize);
+    }
+    ptr
+}
+
+
+fn webgl_state_free(ptr: *mut WebGLState) {
+    if ptr.is_null() {
         return;
     }
-    let _ = unsafe { Box::from_raw(state) };
+    let present = webgl_state_live()
+        .lock()
+        .unwrap_or_else(|e| e.into_inner())
+        .remove(&(ptr as usize));
+    if present {
+        let _ = unsafe { Box::from_raw(ptr) };
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn canvas_native_webgl_state_destroy(state: *mut WebGLState) {
+    webgl_state_free(state);
 }
 
 impl WebGLState {
@@ -1671,7 +1702,7 @@ pub extern "C" fn canvas_native_webgl_create(
                 false,
             ) {
                 None => std::ptr::null_mut(),
-                Some(state) => Box::into_raw(Box::new(state)),
+                Some(state) => webgl_state_register(Box::into_raw(Box::new(state))),
             }
         }
         _ => std::ptr::null_mut(),
@@ -1715,7 +1746,7 @@ pub extern "C" fn canvas_native_webgl_create(
                 false,
             ) {
                 None => std::ptr::null_mut(),
-                Some(state) => Box::into_raw(Box::new(state)),
+                Some(state) => webgl_state_register(Box::into_raw(Box::new(state))),
             }
         }
         _ => std::ptr::null_mut(),
@@ -1761,7 +1792,7 @@ pub extern "C" fn canvas_native_webgl_create_no_window(
                 is_canvas,
             ) {
                 None => std::ptr::null_mut(),
-                Some(state) => Box::into_raw(Box::new(state)),
+                Some(state) => webgl_state_register(Box::into_raw(Box::new(state))),
             }
         }
         _ => std::ptr::null_mut(),

crates/canvas-ios/src/lib.rs

@@ -196,8 +196,7 @@ pub extern "C" fn canvas_native_ios_release_webgl(context: i64) {
     if context == 0 {
         return;
     }
-    let context = context as *mut WebGLState;
-    let _ = unsafe { Box::from_raw(context) };
+    canvas_c::canvas_native_webgl_state_destroy(context as *mut WebGLState);
 }
 
 #[no_mangle]

crates/canvas-webgl/src/prelude.rs

@@ -1,6 +1,7 @@
 #![allow(dead_code)]
 #![allow(non_snake_case)]
 #![allow(non_camel_case_types)]
+#![allow(clippy::too_many_arguments)]
 
 use std::cell::{Ref, RefCell, RefMut};
 use std::collections::HashMap;
@@ -9,8 +10,8 @@ use std::os::raw::c_void;
 use std::ptr::NonNull;
 use std::rc::Rc;
 
-use canvas_core::context_attributes::{ColorSpace, ContextAttributes};
 use canvas_core::context_attributes::PowerPreference;
+use canvas_core::context_attributes::{ColorSpace, ContextAttributes};
 
 pub fn get_sdk_version() -> i32 {
     18
@@ -143,19 +144,19 @@ impl WebGLState {
         //state.gl_context = GLContext::get_current();
     }
 
-    fn get_state(&self) -> Ref<WebGLStateInner> {
+    fn get_state(&'_ self) -> Ref<'_, WebGLStateInner> {
         Ref::map(self.state.borrow(), |v| v)
     }
 
-    fn get_state_mut(&self) -> RefMut<WebGLStateInner> {
+    fn get_state_mut(&'_ self) -> RefMut<'_, WebGLStateInner> {
         RefMut::map(self.state.borrow_mut(), |v| v)
     }
 
-    fn get_attributes(&self) -> Ref<ContextAttributes> {
+    fn get_attributes(&'_ self) -> Ref<'_, ContextAttributes> {
         Ref::map(self.attributes.borrow(), |v| v)
     }
 
-    fn get_attributes_mut(&self) -> RefMut<ContextAttributes> {
+    fn get_attributes_mut(&'_ self) -> RefMut<'_, ContextAttributes> {
         RefMut::map(self.attributes.borrow_mut(), |v| v)
     }
 
@@ -220,7 +221,7 @@ impl WebGLState {
                 false,
                 false,
                 version == WebGLVersion::V1,
-                ColorSpace::Srgb
+                ColorSpace::Srgb,
             ))),
             state: Rc::new(RefCell::new(WebGLStateInner {
                 version,
@@ -285,7 +286,7 @@ impl WebGLState {
                 xr_compatible,
                 is_canvas,
                 gl_legacy,
-                ColorSpace::Srgb
+                ColorSpace::Srgb,
             ))),
             state: Rc::new(RefCell::new(WebGLStateInner {
                 version,
@@ -509,28 +510,44 @@ impl WebGLState {
 
         // MAX_COMBINED_TEXTURE_IMAGE_UNITS is available in GLES2 and GLES3
         let mut max_units: i32 = 0;
-        unsafe { gl_bindings::GetIntegerv(gl_bindings::MAX_COMBINED_TEXTURE_IMAGE_UNITS, &mut max_units) }
+        unsafe {
+            gl_bindings::GetIntegerv(
+                gl_bindings::MAX_COMBINED_TEXTURE_IMAGE_UNITS,
+                &mut max_units,
+            )
+        }
         self.state.borrow_mut().max_combined_texture_image_units = max_units;
 
         if self.get_version() == WebGLVersion::V2 {
             let mut max_ub: i32 = 0;
-            unsafe { gl_bindings::GetIntegerv(gl_bindings::MAX_UNIFORM_BUFFER_BINDINGS, &mut max_ub) }
+            unsafe {
+                gl_bindings::GetIntegerv(gl_bindings::MAX_UNIFORM_BUFFER_BINDINGS, &mut max_ub)
+            }
             self.state.borrow_mut().max_uniform_buffer_bindings = max_ub;
 
             let mut max_vub: i32 = 0;
-            unsafe { gl_bindings::GetIntegerv(gl_bindings::MAX_VERTEX_UNIFORM_BLOCKS, &mut max_vub) }
+            unsafe {
+                gl_bindings::GetIntegerv(gl_bindings::MAX_VERTEX_UNIFORM_BLOCKS, &mut max_vub)
+            }
             self.state.borrow_mut().max_vertex_uniform_blocks = max_vub;
 
             let mut max_fub: i32 = 0;
-            unsafe { gl_bindings::GetIntegerv(gl_bindings::MAX_FRAGMENT_UNIFORM_BLOCKS, &mut max_fub) }
+            unsafe {
+                gl_bindings::GetIntegerv(gl_bindings::MAX_FRAGMENT_UNIFORM_BLOCKS, &mut max_fub)
+            }
             self.state.borrow_mut().max_fragment_uniform_blocks = max_fub;
 
             // Quick runtime UBO smoke-test: create a small UBO, bind base, check for GL errors
             let mut buf: u32 = 0;
             unsafe {
                 gl_bindings::GenBuffers(1, &mut buf);
                 gl_bindings::BindBuffer(gl_bindings::UNIFORM_BUFFER, buf);
-                gl_bindings::BufferData(gl_bindings::UNIFORM_BUFFER, 16, std::ptr::null(), gl_bindings::DYNAMIC_DRAW);
+                gl_bindings::BufferData(
+                    gl_bindings::UNIFORM_BUFFER,
+                    16,
+                    std::ptr::null(),
+                    gl_bindings::DYNAMIC_DRAW,
+                );
                 gl_bindings::BindBufferBase(gl_bindings::UNIFORM_BUFFER, 0, buf);
             }
             let err = unsafe { gl_bindings::GetError() };
@@ -542,7 +559,10 @@ impl WebGLState {
             }
             self.state.borrow_mut().gpu_safe = err == gl_bindings::NO_ERROR;
             if !self.state.borrow().gpu_safe {
-                log::warn!("GPU safety probe failed (GetError = {}). Disabling GPU-only paths.", err);
+                log::warn!(
+                    "GPU safety probe failed (GetError = {}). Disabling GPU-only paths.",
+                    err
+                );
             }
         }
     }
@@ -565,30 +585,46 @@ impl WebGLState {
     /// Get cached active uniform-block count for a program. If not cached and
     /// the context is WebGL2, the value is queried from GL and cached.
     pub fn get_program_active_uniform_blocks(&self, program: u32) -> Option<i32> {
-        if let Some(v) = self.state.borrow().program_active_uniform_blocks.get(&program) {
+        if let Some(v) = self
+            .state
+            .borrow()
+            .program_active_uniform_blocks
+            .get(&program)
+        {
             return Some(*v);
         }
         if self.get_version() != WebGLVersion::V2 {
             return None;
         }
         self.context.make_current();
         let mut active_blocks: i32 = 0;
-        unsafe { gl_bindings::GetProgramiv(program, gl_bindings::ACTIVE_UNIFORM_BLOCKS, &mut active_blocks) }
-        self.state.borrow_mut().program_active_uniform_blocks.insert(program, active_blocks);
+        unsafe {
+            gl_bindings::GetProgramiv(
+                program,
+                gl_bindings::ACTIVE_UNIFORM_BLOCKS,
+                &mut active_blocks,
+            )
+        }
+        self.state
+            .borrow_mut()
+            .program_active_uniform_blocks
+            .insert(program, active_blocks);
         Some(active_blocks)
     }
 
     /// Set the cached active uniform-block count for a program (used after linking)
     pub fn set_program_active_uniform_blocks(&mut self, program: u32, count: i32) {
-        self.state.borrow_mut().program_active_uniform_blocks.insert(program, count);
+        self.state
+            .borrow_mut()
+            .program_active_uniform_blocks
+            .insert(program, count);
     }
 
     /// Remove the current context if it's the stored context. Returns true if it was removed.
     pub fn remove_if_current(&mut self) -> bool {
         // Delegate to the GLContext's portable helper which returns a bool consistently
         self.context.remove_if_current()
     }
-
 }
 
 #[derive(Clone)]

packages/canvas/platforms/ios/CanvasNative.xcframework/Info.plist

@@ -44,34 +44,34 @@
 			<key>DebugSymbolsPath</key>
 			<string>dSYMs</string>
 			<key>LibraryIdentifier</key>
-			<string>ios-arm64</string>
+			<string>ios-arm64_x86_64-simulator</string>
 			<key>LibraryPath</key>
 			<string>CanvasNative.framework</string>
 			<key>SupportedArchitectures</key>
 			<array>
 				<string>arm64</string>
+				<string>x86_64</string>
 			</array>
 			<key>SupportedPlatform</key>
 			<string>ios</string>
+			<key>SupportedPlatformVariant</key>
+			<string>simulator</string>
 		</dict>
 		<dict>
 			<key>BinaryPath</key>
 			<string>CanvasNative.framework/CanvasNative</string>
 			<key>DebugSymbolsPath</key>
 			<string>dSYMs</string>
 			<key>LibraryIdentifier</key>
-			<string>ios-arm64_x86_64-simulator</string>
+			<string>ios-arm64</string>
 			<key>LibraryPath</key>
 			<string>CanvasNative.framework</string>
 			<key>SupportedArchitectures</key>
 			<array>
 				<string>arm64</string>
-				<string>x86_64</string>
 			</array>
 			<key>SupportedPlatform</key>
 			<string>ios</string>
-			<key>SupportedPlatformVariant</key>
-			<string>simulator</string>
 		</dict>
 	</array>
 	<key>CFBundlePackageType</key>