From 46d932b167e73360288f3c7d191d5edfcfe29564 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Felix=20Sch=C3=BCtt?= Date: Thu, 13 Feb 2025 21:08:52 +0100 Subject: [PATCH] Share processing logic between Mac / Windows --- Cargo.lock | 8 + Cargo.toml | 1 + azul-core/src/window.rs | 118 +- azul-desktop/Cargo.toml | 1 + azul-desktop/src/app.rs | 2 +- azul-desktop/src/shell/appkit/gl.rs | 958 +++++++++++++++ azul-desktop/src/shell/appkit/menu.rs | 323 +++++ azul-desktop/src/shell/appkit/mod.rs | 894 ++++++++++++-- azul-desktop/src/shell/mod.rs | 57 +- azul-desktop/src/shell/process.rs | 340 ++++++ azul-desktop/src/shell/win32/gl.rs | 1085 +++++++++++++++++ azul-desktop/src/shell/win32/mod.rs | 1570 +------------------------ azul-desktop/src/wr_translate.rs | 2 +- examples/rust/android/Cargo.toml | 0 examples/rust/android/src/main.rs | 3 + examples/rust/ios/Cargo.toml | 19 + examples/rust/ios/README.md | 27 + examples/rust/ios/src/lib.rs | 52 + 18 files changed, 3770 insertions(+), 1690 deletions(-) create mode 100644 azul-desktop/src/shell/appkit/gl.rs create mode 100644 azul-desktop/src/shell/appkit/menu.rs create mode 100644 azul-desktop/src/shell/process.rs create mode 100644 azul-desktop/src/shell/win32/gl.rs create mode 100644 examples/rust/android/Cargo.toml create mode 100644 examples/rust/android/src/main.rs create mode 100644 examples/rust/ios/Cargo.toml create mode 100644 examples/rust/ios/README.md create mode 100644 examples/rust/ios/src/lib.rs diff --git a/Cargo.lock b/Cargo.lock index dffafd9f8..41ce494c8 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -208,6 +208,7 @@ dependencies = [ "azulc", "backtrace", "bitflags 2.8.0", + "block2", "cgl", "clipboard2", "dispatch2", @@ -248,6 +249,13 @@ dependencies = [ "serde_json", ] +[[package]] +name = "azul-ios" +version = "0.1.0" +dependencies = [ + "azul", +] + [[package]] name = "azul-layout" version = "0.0.4" diff --git a/Cargo.toml b/Cargo.toml index 767454d9b..a1445bb1d 100755 --- a/Cargo.toml +++ b/Cargo.toml @@ -10,6 +10,7 @@ members = [ "azul-text-layout", "azul-css-parser", "examples/rust", + "examples/rust/ios" ] [profile.dev] diff --git a/azul-core/src/window.rs b/azul-core/src/window.rs index e442aa5e7..9df614cc3 100644 --- a/azul-core/src/window.rs +++ b/azul-core/src/window.rs @@ -28,6 +28,7 @@ use azul_css::{ AzString, ColorU, CssPath, CssProperty, LayoutPoint, LayoutRect, LayoutSize, OptionAzString, OptionF32, OptionI32, U8Vec, FloatValue, }; +use core::sync::atomic::AtomicI64; use core::{ cmp::Ordering, ffi::c_void, @@ -39,21 +40,19 @@ use rust_fontconfig::FcFontCache; pub const DEFAULT_TITLE: &str = "Azul App"; -static LAST_WINDOW_ID: AtomicUsize = AtomicUsize::new(0); +static LAST_WINDOW_ID: AtomicI64 = AtomicI64::new(0); /// Each default callback is identified by its ID (not by it's function pointer), /// since multiple IDs could point to the same function. #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, Ord, PartialOrd)] -#[repr(C)] +#[repr(transparent)] pub struct WindowId { - id: usize, + pub id: i64, } impl WindowId { pub fn new() -> Self { - WindowId { - id: LAST_WINDOW_ID.fetch_add(1, AtomicOrdering::SeqCst), - } + WindowId { id: LAST_WINDOW_ID.fetch_add(1, AtomicOrdering::SeqCst) } } } @@ -158,6 +157,51 @@ impl HwAcceleration { } } +#[derive(Debug, Copy, Clone, PartialEq, Eq)] +pub enum ProcessEventResult { + DoNothing = 0, + ShouldReRenderCurrentWindow = 1, + ShouldUpdateDisplayListCurrentWindow = 2, + // GPU transforms changed: do another hit-test and recurse + // until nothing has changed anymore + UpdateHitTesterAndProcessAgain = 3, + // Only refresh the display (in case of pure scroll or GPU-only events) + ShouldRegenerateDomCurrentWindow = 4, + ShouldRegenerateDomAllWindows = 5, +} + +impl ProcessEventResult { + pub fn order(&self) -> usize { + use self::ProcessEventResult::*; + match self { + DoNothing => 0, + ShouldReRenderCurrentWindow => 1, + ShouldUpdateDisplayListCurrentWindow => 2, + UpdateHitTesterAndProcessAgain => 3, + ShouldRegenerateDomCurrentWindow => 4, + ShouldRegenerateDomAllWindows => 5, + } + } +} + +impl PartialOrd for ProcessEventResult { + fn partial_cmp(&self, other: &Self) -> Option { + self.order().partial_cmp(&other.order()) + } +} + +impl Ord for ProcessEventResult { + fn cmp(&self, other: &Self) -> std::cmp::Ordering { + self.order().cmp(&other.order()) + } +} + +impl ProcessEventResult { + pub fn max_self(self, other: Self) -> Self { + self.max(other) + } +} + #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C, u8)] pub enum RawWindowHandle { @@ -2630,6 +2674,16 @@ impl WindowCreateOptions { ..WindowCreateOptions::default() } } + pub fn renderer_types(&self) -> Vec { + match self.renderer.into_option() { + Some(s) => match s.hw_accel { + HwAcceleration::DontCare => vec![RendererType::Hardware, RendererType::Software], + HwAcceleration::Enabled => vec![RendererType::Hardware], + HwAcceleration::Disabled => vec![RendererType::Software], + }, + None => vec![RendererType::Hardware, RendererType::Software], + } + } } #[repr(C)] @@ -3282,6 +3336,58 @@ pub enum VirtualKeyCode { Cut, } +impl VirtualKeyCode { + pub fn get_lowercase(&self) -> Option { + use self::VirtualKeyCode::*; + match self { + A => Some('a'), + B => Some('b'), + C => Some('c'), + D => Some('d'), + E => Some('e'), + F => Some('f'), + G => Some('g'), + H => Some('h'), + I => Some('i'), + J => Some('j'), + K => Some('k'), + L => Some('l'), + M => Some('m'), + N => Some('n'), + O => Some('o'), + P => Some('p'), + Q => Some('q'), + R => Some('r'), + S => Some('s'), + T => Some('t'), + U => Some('u'), + V => Some('v'), + W => Some('w'), + X => Some('x'), + Y => Some('y'), + Z => Some('z'), + Key0 | Numpad0 => Some('0'), + Key1 | Numpad1 => Some('1'), + Key2 | Numpad2 => Some('2'), + Key3 | Numpad3 => Some('3'), + Key4 | Numpad4 => Some('4'), + Key5 | Numpad5 => Some('5'), + Key6 | Numpad6 => Some('6'), + Key7 | Numpad7 => Some('7'), + Key8 | Numpad8 => Some('8'), + Key9 | Numpad9 => Some('9'), + Minus => Some('-'), + Asterisk => Some('´'), + At => Some('@'), + Period => Some('.'), + Semicolon => Some(';'), + Slash => Some('/'), + Caret => Some('^'), + _ => None, + } + } +} + /// 16x16x4 bytes icon #[derive(Debug, Clone)] #[repr(C)] diff --git a/azul-desktop/Cargo.toml b/azul-desktop/Cargo.toml index 240f500a0..881fb09df 100644 --- a/azul-desktop/Cargo.toml +++ b/azul-desktop/Cargo.toml @@ -33,6 +33,7 @@ webrender = { version = "0.62.2", package = "azul-webrender", defa once_cell = "1.17.1" dispatch2 = "0.2.0" bitflags = "2.8.0" +block2 = "0.6.0" [target.'cfg(target_os = "windows")'.dependencies] winapi = { version = "0.3.9", default-features = false, features = ["windowsx", "libloaderapi", "errhandlingapi", "winuser", "uxtheme", "dwmapi", "wingdi", "commdlg"] } diff --git a/azul-desktop/src/app.rs b/azul-desktop/src/app.rs index 424044d87..2ca1264ee 100644 --- a/azul-desktop/src/app.rs +++ b/azul-desktop/src/app.rs @@ -175,7 +175,7 @@ impl App { let err = crate::shell::x11::run(self, root_window); #[cfg(target_os = "macos")] - let err = crate::shell::appkit::run(root_window); + let err = crate::shell::appkit::run(self, root_window); if let Err(e) = err { crate::dialogs::msg_box(&format!("{:?}", e)); diff --git a/azul-desktop/src/shell/appkit/gl.rs b/azul-desktop/src/shell/appkit/gl.rs new file mode 100644 index 000000000..cf30db8a0 --- /dev/null +++ b/azul-desktop/src/shell/appkit/gl.rs @@ -0,0 +1,958 @@ +use gl_context_loader::GenericGlContext; +use std::rc::Rc; +use std::fmt; +use std::ffi::{CString, c_void, c_char}; + +// Ensure we can call dlopen/dlsym/dlclose +#[link(name = "dl")] +extern "C" { + fn dlopen(filename: *const c_char, flag: i32) -> *mut c_void; + fn dlsym(handle: *mut c_void, symbol: *const c_char) -> *mut c_void; + fn dlclose(handle: *mut c_void) -> i32; +} + +// Wrapper to get access to the GL function pointers +pub struct GlFunctions { + /// The handle returned by dlopen. + _opengl_lib_handle: *mut c_void, + + /// Actual GL function pointers (glClear, glClearColor, etc.) + pub functions: Rc, +} + +impl fmt::Debug for GlFunctions { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + // Just show the pointer’s numeric value + write!(f, "GlFunctions {{ handle = {:0x?} }}", self._opengl_lib_handle as usize) + } +} + +impl GlFunctions { + /// Allocates and loads the OpenGL function pointers via dlopen + pub fn initialize() -> Result { + + fn get_func(symbol_name: &str, handle: *mut c_void) -> *mut gl_context_loader::c_void { + let c_string = CString::new(symbol_name).unwrap(); + (unsafe { dlsym(handle, c_string.as_ptr()) }) as *mut _ + } + + // Typical flags for dlopen: + const RTLD_NOW: i32 = 2; + const RTLD_LOCAL: i32 = 0; + const RTLD_GLOBAL: i32 = 8; // Or 0x100 if needed + + // Full path to Apple’s OpenGL framework library + // Alternatively: "/System/Library/Frameworks/OpenGL.framework/OpenGL" + let framework_path = CString::new("/System/Library/Frameworks/OpenGL.framework/OpenGL") + .unwrap(); + + // RTLD_NOW means "resolve all symbols immediately". + // RTLD_GLOBAL or RTLD_LOCAL depends on your use-case. + let handle = unsafe { dlopen(framework_path.as_ptr(), RTLD_NOW | RTLD_GLOBAL) }; + if handle.is_null() { + return Err("Could not dlopen OpenGL.framework/OpenGL".to_string()); + } + + // Zero-init the entire function table + let context = GenericGlContext { + glAccum: get_func("glAccum", handle), + glActiveTexture: get_func("glActiveTexture", handle), + glAlphaFunc: get_func("glAlphaFunc", handle), + glAreTexturesResident: get_func("glAreTexturesResident", handle), + glArrayElement: get_func("glArrayElement", handle), + glAttachShader: get_func("glAttachShader", handle), + glBegin: get_func("glBegin", handle), + glBeginConditionalRender: get_func( + "glBeginConditionalRender", + handle, + ), + glBeginQuery: get_func("glBeginQuery", handle), + glBeginTransformFeedback: get_func( + "glBeginTransformFeedback", + handle, + ), + glBindAttribLocation: get_func("glBindAttribLocation", handle), + glBindBuffer: get_func("glBindBuffer", handle), + glBindBufferBase: get_func("glBindBufferBase", handle), + glBindBufferRange: get_func("glBindBufferRange", handle), + glBindFragDataLocation: get_func("glBindFragDataLocation", handle), + glBindFragDataLocationIndexed: get_func( + "glBindFragDataLocationIndexed", + handle, + ), + glBindFramebuffer: get_func("glBindFramebuffer", handle), + glBindRenderbuffer: get_func("glBindRenderbuffer", handle), + glBindSampler: get_func("glBindSampler", handle), + glBindTexture: get_func("glBindTexture", handle), + glBindVertexArray: get_func("glBindVertexArray", handle), + glBindVertexArrayAPPLE: get_func("glBindVertexArrayAPPLE", handle), + glBitmap: get_func("glBitmap", handle), + glBlendBarrierKHR: get_func("glBlendBarrierKHR", handle), + glBlendColor: get_func("glBlendColor", handle), + glBlendEquation: get_func("glBlendEquation", handle), + glBlendEquationSeparate: get_func("glBlendEquationSeparate", handle), + glBlendFunc: get_func("glBlendFunc", handle), + glBlendFuncSeparate: get_func("glBlendFuncSeparate", handle), + glBlitFramebuffer: get_func("glBlitFramebuffer", handle), + glBufferData: get_func("glBufferData", handle), + glBufferStorage: get_func("glBufferStorage", handle), + glBufferSubData: get_func("glBufferSubData", handle), + glCallList: get_func("glCallList", handle), + glCallLists: get_func("glCallLists", handle), + glCheckFramebufferStatus: get_func( + "glCheckFramebufferStatus", + handle, + ), + glClampColor: get_func("glClampColor", handle), + glClear: get_func("glClear", handle), + glClearAccum: get_func("glClearAccum", handle), + glClearBufferfi: get_func("glClearBufferfi", handle), + glClearBufferfv: get_func("glClearBufferfv", handle), + glClearBufferiv: get_func("glClearBufferiv", handle), + glClearBufferuiv: get_func("glClearBufferuiv", handle), + glClearColor: get_func("glClearColor", handle), + glClearDepth: get_func("glClearDepth", handle), + glClearIndex: get_func("glClearIndex", handle), + glClearStencil: get_func("glClearStencil", handle), + glClientActiveTexture: get_func("glClientActiveTexture", handle), + glClientWaitSync: get_func("glClientWaitSync", handle), + glClipPlane: get_func("glClipPlane", handle), + glColor3b: get_func("glColor3b", handle), + glColor3bv: get_func("glColor3bv", handle), + glColor3d: get_func("glColor3d", handle), + glColor3dv: get_func("glColor3dv", handle), + glColor3f: get_func("glColor3f", handle), + glColor3fv: get_func("glColor3fv", handle), + glColor3i: get_func("glColor3i", handle), + glColor3iv: get_func("glColor3iv", handle), + glColor3s: get_func("glColor3s", handle), + glColor3sv: get_func("glColor3sv", handle), + glColor3ub: get_func("glColor3ub", handle), + glColor3ubv: get_func("glColor3ubv", handle), + glColor3ui: get_func("glColor3ui", handle), + glColor3uiv: get_func("glColor3uiv", handle), + glColor3us: get_func("glColor3us", handle), + glColor3usv: get_func("glColor3usv", handle), + glColor4b: get_func("glColor4b", handle), + glColor4bv: get_func("glColor4bv", handle), + glColor4d: get_func("glColor4d", handle), + glColor4dv: get_func("glColor4dv", handle), + glColor4f: get_func("glColor4f", handle), + glColor4fv: get_func("glColor4fv", handle), + glColor4i: get_func("glColor4i", handle), + glColor4iv: get_func("glColor4iv", handle), + glColor4s: get_func("glColor4s", handle), + glColor4sv: get_func("glColor4sv", handle), + glColor4ub: get_func("glColor4ub", handle), + glColor4ubv: get_func("glColor4ubv", handle), + glColor4ui: get_func("glColor4ui", handle), + glColor4uiv: get_func("glColor4uiv", handle), + glColor4us: get_func("glColor4us", handle), + glColor4usv: get_func("glColor4usv", handle), + glColorMask: get_func("glColorMask", handle), + glColorMaski: get_func("glColorMaski", handle), + glColorMaterial: get_func("glColorMaterial", handle), + glColorP3ui: get_func("glColorP3ui", handle), + glColorP3uiv: get_func("glColorP3uiv", handle), + glColorP4ui: get_func("glColorP4ui", handle), + glColorP4uiv: get_func("glColorP4uiv", handle), + glColorPointer: get_func("glColorPointer", handle), + glCompileShader: get_func("glCompileShader", handle), + glCompressedTexImage1D: get_func("glCompressedTexImage1D", handle), + glCompressedTexImage2D: get_func("glCompressedTexImage2D", handle), + glCompressedTexImage3D: get_func("glCompressedTexImage3D", handle), + glCompressedTexSubImage1D: get_func( + "glCompressedTexSubImage1D", + handle, + ), + glCompressedTexSubImage2D: get_func( + "glCompressedTexSubImage2D", + handle, + ), + glCompressedTexSubImage3D: get_func( + "glCompressedTexSubImage3D", + handle, + ), + glCopyBufferSubData: get_func("glCopyBufferSubData", handle), + glCopyImageSubData: get_func("glCopyImageSubData", handle), + glCopyPixels: get_func("glCopyPixels", handle), + glCopyTexImage1D: get_func("glCopyTexImage1D", handle), + glCopyTexImage2D: get_func("glCopyTexImage2D", handle), + glCopyTexSubImage1D: get_func("glCopyTexSubImage1D", handle), + glCopyTexSubImage2D: get_func("glCopyTexSubImage2D", handle), + glCopyTexSubImage3D: get_func("glCopyTexSubImage3D", handle), + glCreateProgram: get_func("glCreateProgram", handle), + glCreateShader: get_func("glCreateShader", handle), + glCullFace: get_func("glCullFace", handle), + glDebugMessageCallback: get_func("glDebugMessageCallback", handle), + glDebugMessageCallbackKHR: get_func( + "glDebugMessageCallbackKHR", + handle, + ), + glDebugMessageControl: get_func("glDebugMessageControl", handle), + glDebugMessageControlKHR: get_func( + "glDebugMessageControlKHR", + handle, + ), + glDebugMessageInsert: get_func("glDebugMessageInsert", handle), + glDebugMessageInsertKHR: get_func("glDebugMessageInsertKHR", handle), + glDeleteBuffers: get_func("glDeleteBuffers", handle), + glDeleteFencesAPPLE: get_func("glDeleteFencesAPPLE", handle), + glDeleteFramebuffers: get_func("glDeleteFramebuffers", handle), + glDeleteLists: get_func("glDeleteLists", handle), + glDeleteProgram: get_func("glDeleteProgram", handle), + glDeleteQueries: get_func("glDeleteQueries", handle), + glDeleteRenderbuffers: get_func("glDeleteRenderbuffers", handle), + glDeleteSamplers: get_func("glDeleteSamplers", handle), + glDeleteShader: get_func("glDeleteShader", handle), + glDeleteSync: get_func("glDeleteSync", handle), + glDeleteTextures: get_func("glDeleteTextures", handle), + glDeleteVertexArrays: get_func("glDeleteVertexArrays", handle), + glDeleteVertexArraysAPPLE: get_func( + "glDeleteVertexArraysAPPLE", + handle, + ), + glDepthFunc: get_func("glDepthFunc", handle), + glDepthMask: get_func("glDepthMask", handle), + glDepthRange: get_func("glDepthRange", handle), + glDetachShader: get_func("glDetachShader", handle), + glDisable: get_func("glDisable", handle), + glDisableClientState: get_func("glDisableClientState", handle), + glDisableVertexAttribArray: get_func( + "glDisableVertexAttribArray", + handle, + ), + glDisablei: get_func("glDisablei", handle), + glDrawArrays: get_func("glDrawArrays", handle), + glDrawArraysInstanced: get_func("glDrawArraysInstanced", handle), + glDrawBuffer: get_func("glDrawBuffer", handle), + glDrawBuffers: get_func("glDrawBuffers", handle), + glDrawElements: get_func("glDrawElements", handle), + glDrawElementsBaseVertex: get_func( + "glDrawElementsBaseVertex", + handle, + ), + glDrawElementsInstanced: get_func("glDrawElementsInstanced", handle), + glDrawElementsInstancedBaseVertex: get_func( + "glDrawElementsInstancedBaseVertex", + handle, + ), + glDrawPixels: get_func("glDrawPixels", handle), + glDrawRangeElements: get_func("glDrawRangeElements", handle), + glDrawRangeElementsBaseVertex: get_func( + "glDrawRangeElementsBaseVertex", + handle, + ), + glEdgeFlag: get_func("glEdgeFlag", handle), + glEdgeFlagPointer: get_func("glEdgeFlagPointer", handle), + glEdgeFlagv: get_func("glEdgeFlagv", handle), + glEnable: get_func("glEnable", handle), + glEnableClientState: get_func("glEnableClientState", handle), + glEnableVertexAttribArray: get_func( + "glEnableVertexAttribArray", + handle, + ), + glEnablei: get_func("glEnablei", handle), + glEnd: get_func("glEnd", handle), + glEndConditionalRender: get_func("glEndConditionalRender", handle), + glEndList: get_func("glEndList", handle), + glEndQuery: get_func("glEndQuery", handle), + glEndTransformFeedback: get_func("glEndTransformFeedback", handle), + glEvalCoord1d: get_func("glEvalCoord1d", handle), + glEvalCoord1dv: get_func("glEvalCoord1dv", handle), + glEvalCoord1f: get_func("glEvalCoord1f", handle), + glEvalCoord1fv: get_func("glEvalCoord1fv", handle), + glEvalCoord2d: get_func("glEvalCoord2d", handle), + glEvalCoord2dv: get_func("glEvalCoord2dv", handle), + glEvalCoord2f: get_func("glEvalCoord2f", handle), + glEvalCoord2fv: get_func("glEvalCoord2fv", handle), + glEvalMesh1: get_func("glEvalMesh1", handle), + glEvalMesh2: get_func("glEvalMesh2", handle), + glEvalPoint1: get_func("glEvalPoint1", handle), + glEvalPoint2: get_func("glEvalPoint2", handle), + glFeedbackBuffer: get_func("glFeedbackBuffer", handle), + glFenceSync: get_func("glFenceSync", handle), + glFinish: get_func("glFinish", handle), + glFinishFenceAPPLE: get_func("glFinishFenceAPPLE", handle), + glFinishObjectAPPLE: get_func("glFinishObjectAPPLE", handle), + glFlush: get_func("glFlush", handle), + glFlushMappedBufferRange: get_func( + "glFlushMappedBufferRange", + handle, + ), + glFogCoordPointer: get_func("glFogCoordPointer", handle), + glFogCoordd: get_func("glFogCoordd", handle), + glFogCoorddv: get_func("glFogCoorddv", handle), + glFogCoordf: get_func("glFogCoordf", handle), + glFogCoordfv: get_func("glFogCoordfv", handle), + glFogf: get_func("glFogf", handle), + glFogfv: get_func("glFogfv", handle), + glFogi: get_func("glFogi", handle), + glFogiv: get_func("glFogiv", handle), + glFramebufferRenderbuffer: get_func( + "glFramebufferRenderbuffer", + handle, + ), + glFramebufferTexture: get_func("glFramebufferTexture", handle), + glFramebufferTexture1D: get_func("glFramebufferTexture1D", handle), + glFramebufferTexture2D: get_func("glFramebufferTexture2D", handle), + glFramebufferTexture3D: get_func("glFramebufferTexture3D", handle), + glFramebufferTextureLayer: get_func( + "glFramebufferTextureLayer", + handle, + ), + glFrontFace: get_func("glFrontFace", handle), + glFrustum: get_func("glFrustum", handle), + glGenBuffers: get_func("glGenBuffers", handle), + glGenFencesAPPLE: get_func("glGenFencesAPPLE", handle), + glGenFramebuffers: get_func("glGenFramebuffers", handle), + glGenLists: get_func("glGenLists", handle), + glGenQueries: get_func("glGenQueries", handle), + glGenRenderbuffers: get_func("glGenRenderbuffers", handle), + glGenSamplers: get_func("glGenSamplers", handle), + glGenTextures: get_func("glGenTextures", handle), + glGenVertexArrays: get_func("glGenVertexArrays", handle), + glGenVertexArraysAPPLE: get_func("glGenVertexArraysAPPLE", handle), + glGenerateMipmap: get_func("glGenerateMipmap", handle), + glGetActiveAttrib: get_func("glGetActiveAttrib", handle), + glGetActiveUniform: get_func("glGetActiveUniform", handle), + glGetActiveUniformBlockName: get_func( + "glGetActiveUniformBlockName", + handle, + ), + glGetActiveUniformBlockiv: get_func( + "glGetActiveUniformBlockiv", + handle, + ), + glGetActiveUniformName: get_func("glGetActiveUniformName", handle), + glGetActiveUniformsiv: get_func("glGetActiveUniformsiv", handle), + glGetAttachedShaders: get_func("glGetAttachedShaders", handle), + glGetAttribLocation: get_func("glGetAttribLocation", handle), + glGetBooleani_v: get_func("glGetBooleani_v", handle), + glGetBooleanv: get_func("glGetBooleanv", handle), + glGetBufferParameteri64v: get_func( + "glGetBufferParameteri64v", + handle, + ), + glGetBufferParameteriv: get_func("glGetBufferParameteriv", handle), + glGetBufferPointerv: get_func("glGetBufferPointerv", handle), + glGetBufferSubData: get_func("glGetBufferSubData", handle), + glGetClipPlane: get_func("glGetClipPlane", handle), + glGetCompressedTexImage: get_func("glGetCompressedTexImage", handle), + glGetDebugMessageLog: get_func("glGetDebugMessageLog", handle), + glGetDebugMessageLogKHR: get_func("glGetDebugMessageLogKHR", handle), + glGetDoublev: get_func("glGetDoublev", handle), + glGetError: get_func("glGetError", handle), + glGetFloatv: get_func("glGetFloatv", handle), + glGetFragDataIndex: get_func("glGetFragDataIndex", handle), + glGetFragDataLocation: get_func("glGetFragDataLocation", handle), + glGetFramebufferAttachmentParameteriv: get_func( + "glGetFramebufferAttachmentParameteriv", + handle, + ), + glGetInteger64i_v: get_func("glGetInteger64i_v", handle), + glGetInteger64v: get_func("glGetInteger64v", handle), + glGetIntegeri_v: get_func("glGetIntegeri_v", handle), + glGetIntegerv: get_func("glGetIntegerv", handle), + glGetLightfv: get_func("glGetLightfv", handle), + glGetLightiv: get_func("glGetLightiv", handle), + glGetMapdv: get_func("glGetMapdv", handle), + glGetMapfv: get_func("glGetMapfv", handle), + glGetMapiv: get_func("glGetMapiv", handle), + glGetMaterialfv: get_func("glGetMaterialfv", handle), + glGetMaterialiv: get_func("glGetMaterialiv", handle), + glGetMultisamplefv: get_func("glGetMultisamplefv", handle), + glGetObjectLabel: get_func("glGetObjectLabel", handle), + glGetObjectLabelKHR: get_func("glGetObjectLabelKHR", handle), + glGetObjectPtrLabel: get_func("glGetObjectPtrLabel", handle), + glGetObjectPtrLabelKHR: get_func("glGetObjectPtrLabelKHR", handle), + glGetPixelMapfv: get_func("glGetPixelMapfv", handle), + glGetPixelMapuiv: get_func("glGetPixelMapuiv", handle), + glGetPixelMapusv: get_func("glGetPixelMapusv", handle), + glGetPointerv: get_func("glGetPointerv", handle), + glGetPointervKHR: get_func("glGetPointervKHR", handle), + glGetPolygonStipple: get_func("glGetPolygonStipple", handle), + glGetProgramBinary: get_func("glGetProgramBinary", handle), + glGetProgramInfoLog: get_func("glGetProgramInfoLog", handle), + glGetProgramiv: get_func("glGetProgramiv", handle), + glGetQueryObjecti64v: get_func("glGetQueryObjecti64v", handle), + glGetQueryObjectiv: get_func("glGetQueryObjectiv", handle), + glGetQueryObjectui64v: get_func("glGetQueryObjectui64v", handle), + glGetQueryObjectuiv: get_func("glGetQueryObjectuiv", handle), + glGetQueryiv: get_func("glGetQueryiv", handle), + glGetRenderbufferParameteriv: get_func( + "glGetRenderbufferParameteriv", + handle, + ), + glGetSamplerParameterIiv: get_func( + "glGetSamplerParameterIiv", + handle, + ), + glGetSamplerParameterIuiv: get_func( + "glGetSamplerParameterIuiv", + handle, + ), + glGetSamplerParameterfv: get_func("glGetSamplerParameterfv", handle), + glGetSamplerParameteriv: get_func("glGetSamplerParameteriv", handle), + glGetShaderInfoLog: get_func("glGetShaderInfoLog", handle), + glGetShaderSource: get_func("glGetShaderSource", handle), + glGetShaderiv: get_func("glGetShaderiv", handle), + glGetString: get_func("glGetString", handle), + glGetStringi: get_func("glGetStringi", handle), + glGetSynciv: get_func("glGetSynciv", handle), + glGetTexEnvfv: get_func("glGetTexEnvfv", handle), + glGetTexEnviv: get_func("glGetTexEnviv", handle), + glGetTexGendv: get_func("glGetTexGendv", handle), + glGetTexGenfv: get_func("glGetTexGenfv", handle), + glGetTexGeniv: get_func("glGetTexGeniv", handle), + glGetTexImage: get_func("glGetTexImage", handle), + glGetTexLevelParameterfv: get_func( + "glGetTexLevelParameterfv", + handle, + ), + glGetTexLevelParameteriv: get_func( + "glGetTexLevelParameteriv", + handle, + ), + glGetTexParameterIiv: get_func("glGetTexParameterIiv", handle), + glGetTexParameterIuiv: get_func("glGetTexParameterIuiv", handle), + glGetTexParameterPointervAPPLE: get_func( + "glGetTexParameterPointervAPPLE", + handle, + ), + glGetTexParameterfv: get_func("glGetTexParameterfv", handle), + glGetTexParameteriv: get_func("glGetTexParameteriv", handle), + glGetTransformFeedbackVarying: get_func( + "glGetTransformFeedbackVarying", + handle, + ), + glGetUniformBlockIndex: get_func("glGetUniformBlockIndex", handle), + glGetUniformIndices: get_func("glGetUniformIndices", handle), + glGetUniformLocation: get_func("glGetUniformLocation", handle), + glGetUniformfv: get_func("glGetUniformfv", handle), + glGetUniformiv: get_func("glGetUniformiv", handle), + glGetUniformuiv: get_func("glGetUniformuiv", handle), + glGetVertexAttribIiv: get_func("glGetVertexAttribIiv", handle), + glGetVertexAttribIuiv: get_func("glGetVertexAttribIuiv", handle), + glGetVertexAttribPointerv: get_func( + "glGetVertexAttribPointerv", + handle, + ), + glGetVertexAttribdv: get_func("glGetVertexAttribdv", handle), + glGetVertexAttribfv: get_func("glGetVertexAttribfv", handle), + glGetVertexAttribiv: get_func("glGetVertexAttribiv", handle), + glHint: get_func("glHint", handle), + glIndexMask: get_func("glIndexMask", handle), + glIndexPointer: get_func("glIndexPointer", handle), + glIndexd: get_func("glIndexd", handle), + glIndexdv: get_func("glIndexdv", handle), + glIndexf: get_func("glIndexf", handle), + glIndexfv: get_func("glIndexfv", handle), + glIndexi: get_func("glIndexi", handle), + glIndexiv: get_func("glIndexiv", handle), + glIndexs: get_func("glIndexs", handle), + glIndexsv: get_func("glIndexsv", handle), + glIndexub: get_func("glIndexub", handle), + glIndexubv: get_func("glIndexubv", handle), + glInitNames: get_func("glInitNames", handle), + glInsertEventMarkerEXT: get_func("glInsertEventMarkerEXT", handle), + glInterleavedArrays: get_func("glInterleavedArrays", handle), + glInvalidateBufferData: get_func("glInvalidateBufferData", handle), + glInvalidateBufferSubData: get_func( + "glInvalidateBufferSubData", + handle, + ), + glInvalidateFramebuffer: get_func("glInvalidateFramebuffer", handle), + glInvalidateSubFramebuffer: get_func( + "glInvalidateSubFramebuffer", + handle, + ), + glInvalidateTexImage: get_func("glInvalidateTexImage", handle), + glInvalidateTexSubImage: get_func("glInvalidateTexSubImage", handle), + glIsBuffer: get_func("glIsBuffer", handle), + glIsEnabled: get_func("glIsEnabled", handle), + glIsEnabledi: get_func("glIsEnabledi", handle), + glIsFenceAPPLE: get_func("glIsFenceAPPLE", handle), + glIsFramebuffer: get_func("glIsFramebuffer", handle), + glIsList: get_func("glIsList", handle), + glIsProgram: get_func("glIsProgram", handle), + glIsQuery: get_func("glIsQuery", handle), + glIsRenderbuffer: get_func("glIsRenderbuffer", handle), + glIsSampler: get_func("glIsSampler", handle), + glIsShader: get_func("glIsShader", handle), + glIsSync: get_func("glIsSync", handle), + glIsTexture: get_func("glIsTexture", handle), + glIsVertexArray: get_func("glIsVertexArray", handle), + glIsVertexArrayAPPLE: get_func("glIsVertexArrayAPPLE", handle), + glLightModelf: get_func("glLightModelf", handle), + glLightModelfv: get_func("glLightModelfv", handle), + glLightModeli: get_func("glLightModeli", handle), + glLightModeliv: get_func("glLightModeliv", handle), + glLightf: get_func("glLightf", handle), + glLightfv: get_func("glLightfv", handle), + glLighti: get_func("glLighti", handle), + glLightiv: get_func("glLightiv", handle), + glLineStipple: get_func("glLineStipple", handle), + glLineWidth: get_func("glLineWidth", handle), + glLinkProgram: get_func("glLinkProgram", handle), + glListBase: get_func("glListBase", handle), + glLoadIdentity: get_func("glLoadIdentity", handle), + glLoadMatrixd: get_func("glLoadMatrixd", handle), + glLoadMatrixf: get_func("glLoadMatrixf", handle), + glLoadName: get_func("glLoadName", handle), + glLoadTransposeMatrixd: get_func("glLoadTransposeMatrixd", handle), + glLoadTransposeMatrixf: get_func("glLoadTransposeMatrixf", handle), + glLogicOp: get_func("glLogicOp", handle), + glMap1d: get_func("glMap1d", handle), + glMap1f: get_func("glMap1f", handle), + glMap2d: get_func("glMap2d", handle), + glMap2f: get_func("glMap2f", handle), + glMapBuffer: get_func("glMapBuffer", handle), + glMapBufferRange: get_func("glMapBufferRange", handle), + glMapGrid1d: get_func("glMapGrid1d", handle), + glMapGrid1f: get_func("glMapGrid1f", handle), + glMapGrid2d: get_func("glMapGrid2d", handle), + glMapGrid2f: get_func("glMapGrid2f", handle), + glMaterialf: get_func("glMaterialf", handle), + glMaterialfv: get_func("glMaterialfv", handle), + glMateriali: get_func("glMateriali", handle), + glMaterialiv: get_func("glMaterialiv", handle), + glMatrixMode: get_func("glMatrixMode", handle), + glMultMatrixd: get_func("glMultMatrixd", handle), + glMultMatrixf: get_func("glMultMatrixf", handle), + glMultTransposeMatrixd: get_func("glMultTransposeMatrixd", handle), + glMultTransposeMatrixf: get_func("glMultTransposeMatrixf", handle), + glMultiDrawArrays: get_func("glMultiDrawArrays", handle), + glMultiDrawElements: get_func("glMultiDrawElements", handle), + glMultiDrawElementsBaseVertex: get_func("glMultiDrawElementsBaseVertex", handle), + glMultiTexCoord1d: get_func("glMultiTexCoord1d", handle), + glMultiTexCoord1dv: get_func("glMultiTexCoord1dv", handle), + glMultiTexCoord1f: get_func("glMultiTexCoord1f", handle), + glMultiTexCoord1fv: get_func("glMultiTexCoord1fv", handle), + glMultiTexCoord1i: get_func("glMultiTexCoord1i", handle), + glMultiTexCoord1iv: get_func("glMultiTexCoord1iv", handle), + glMultiTexCoord1s: get_func("glMultiTexCoord1s", handle), + glMultiTexCoord1sv: get_func("glMultiTexCoord1sv", handle), + glMultiTexCoord2d: get_func("glMultiTexCoord2d", handle), + glMultiTexCoord2dv: get_func("glMultiTexCoord2dv", handle), + glMultiTexCoord2f: get_func("glMultiTexCoord2f", handle), + glMultiTexCoord2fv: get_func("glMultiTexCoord2fv", handle), + glMultiTexCoord2i: get_func("glMultiTexCoord2i", handle), + glMultiTexCoord2iv: get_func("glMultiTexCoord2iv", handle), + glMultiTexCoord2s: get_func("glMultiTexCoord2s", handle), + glMultiTexCoord2sv: get_func("glMultiTexCoord2sv", handle), + glMultiTexCoord3d: get_func("glMultiTexCoord3d", handle), + glMultiTexCoord3dv: get_func("glMultiTexCoord3dv", handle), + glMultiTexCoord3f: get_func("glMultiTexCoord3f", handle), + glMultiTexCoord3fv: get_func("glMultiTexCoord3fv", handle), + glMultiTexCoord3i: get_func("glMultiTexCoord3i", handle), + glMultiTexCoord3iv: get_func("glMultiTexCoord3iv", handle), + glMultiTexCoord3s: get_func("glMultiTexCoord3s", handle), + glMultiTexCoord3sv: get_func("glMultiTexCoord3sv", handle), + glMultiTexCoord4d: get_func("glMultiTexCoord4d", handle), + glMultiTexCoord4dv: get_func("glMultiTexCoord4dv", handle), + glMultiTexCoord4f: get_func("glMultiTexCoord4f", handle), + glMultiTexCoord4fv: get_func("glMultiTexCoord4fv", handle), + glMultiTexCoord4i: get_func("glMultiTexCoord4i", handle), + glMultiTexCoord4iv: get_func("glMultiTexCoord4iv", handle), + glMultiTexCoord4s: get_func("glMultiTexCoord4s", handle), + glMultiTexCoord4sv: get_func("glMultiTexCoord4sv", handle), + glMultiTexCoordP1ui: get_func("glMultiTexCoordP1ui", handle), + glMultiTexCoordP1uiv: get_func("glMultiTexCoordP1uiv", handle), + glMultiTexCoordP2ui: get_func("glMultiTexCoordP2ui", handle), + glMultiTexCoordP2uiv: get_func("glMultiTexCoordP2uiv", handle), + glMultiTexCoordP3ui: get_func("glMultiTexCoordP3ui", handle), + glMultiTexCoordP3uiv: get_func("glMultiTexCoordP3uiv", handle), + glMultiTexCoordP4ui: get_func("glMultiTexCoordP4ui", handle), + glMultiTexCoordP4uiv: get_func("glMultiTexCoordP4uiv", handle), + glNewList: get_func("glNewList", handle), + glNormal3b: get_func("glNormal3b", handle), + glNormal3bv: get_func("glNormal3bv", handle), + glNormal3d: get_func("glNormal3d", handle), + glNormal3dv: get_func("glNormal3dv", handle), + glNormal3f: get_func("glNormal3f", handle), + glNormal3fv: get_func("glNormal3fv", handle), + glNormal3i: get_func("glNormal3i", handle), + glNormal3iv: get_func("glNormal3iv", handle), + glNormal3s: get_func("glNormal3s", handle), + glNormal3sv: get_func("glNormal3sv", handle), + glNormalP3ui: get_func("glNormalP3ui", handle), + glNormalP3uiv: get_func("glNormalP3uiv", handle), + glNormalPointer: get_func("glNormalPointer", handle), + glObjectLabel: get_func("glObjectLabel", handle), + glObjectLabelKHR: get_func("glObjectLabelKHR", handle), + glObjectPtrLabel: get_func("glObjectPtrLabel", handle), + glObjectPtrLabelKHR: get_func("glObjectPtrLabelKHR", handle), + glOrtho: get_func("glOrtho", handle), + glPassThrough: get_func("glPassThrough", handle), + glPixelMapfv: get_func("glPixelMapfv", handle), + glPixelMapuiv: get_func("glPixelMapuiv", handle), + glPixelMapusv: get_func("glPixelMapusv", handle), + glPixelStoref: get_func("glPixelStoref", handle), + glPixelStorei: get_func("glPixelStorei", handle), + glPixelTransferf: get_func("glPixelTransferf", handle), + glPixelTransferi: get_func("glPixelTransferi", handle), + glPixelZoom: get_func("glPixelZoom", handle), + glPointParameterf: get_func("glPointParameterf", handle), + glPointParameterfv: get_func("glPointParameterfv", handle), + glPointParameteri: get_func("glPointParameteri", handle), + glPointParameteriv: get_func("glPointParameteriv", handle), + glPointSize: get_func("glPointSize", handle), + glPolygonMode: get_func("glPolygonMode", handle), + glPolygonOffset: get_func("glPolygonOffset", handle), + glPolygonStipple: get_func("glPolygonStipple", handle), + glPopAttrib: get_func("glPopAttrib", handle), + glPopClientAttrib: get_func("glPopClientAttrib", handle), + glPopDebugGroup: get_func("glPopDebugGroup", handle), + glPopDebugGroupKHR: get_func("glPopDebugGroupKHR", handle), + glPopGroupMarkerEXT: get_func("glPopGroupMarkerEXT", handle), + glPopMatrix: get_func("glPopMatrix", handle), + glPopName: get_func("glPopName", handle), + glPrimitiveRestartIndex: get_func("glPrimitiveRestartIndex", handle), + glPrioritizeTextures: get_func("glPrioritizeTextures", handle), + glProgramBinary: get_func("glProgramBinary", handle), + glProgramParameteri: get_func("glProgramParameteri", handle), + glProvokingVertex: get_func("glProvokingVertex", handle), + glPushAttrib: get_func("glPushAttrib", handle), + glPushClientAttrib: get_func("glPushClientAttrib", handle), + glPushDebugGroup: get_func("glPushDebugGroup", handle), + glPushDebugGroupKHR: get_func("glPushDebugGroupKHR", handle), + glPushGroupMarkerEXT: get_func("glPushGroupMarkerEXT", handle), + glPushMatrix: get_func("glPushMatrix", handle), + glPushName: get_func("glPushName", handle), + glQueryCounter: get_func("glQueryCounter", handle), + glRasterPos2d: get_func("glRasterPos2d", handle), + glRasterPos2dv: get_func("glRasterPos2dv", handle), + glRasterPos2f: get_func("glRasterPos2f", handle), + glRasterPos2fv: get_func("glRasterPos2fv", handle), + glRasterPos2i: get_func("glRasterPos2i", handle), + glRasterPos2iv: get_func("glRasterPos2iv", handle), + glRasterPos2s: get_func("glRasterPos2s", handle), + glRasterPos2sv: get_func("glRasterPos2sv", handle), + glRasterPos3d: get_func("glRasterPos3d", handle), + glRasterPos3dv: get_func("glRasterPos3dv", handle), + glRasterPos3f: get_func("glRasterPos3f", handle), + glRasterPos3fv: get_func("glRasterPos3fv", handle), + glRasterPos3i: get_func("glRasterPos3i", handle), + glRasterPos3iv: get_func("glRasterPos3iv", handle), + glRasterPos3s: get_func("glRasterPos3s", handle), + glRasterPos3sv: get_func("glRasterPos3sv", handle), + glRasterPos4d: get_func("glRasterPos4d", handle), + glRasterPos4dv: get_func("glRasterPos4dv", handle), + glRasterPos4f: get_func("glRasterPos4f", handle), + glRasterPos4fv: get_func("glRasterPos4fv", handle), + glRasterPos4i: get_func("glRasterPos4i", handle), + glRasterPos4iv: get_func("glRasterPos4iv", handle), + glRasterPos4s: get_func("glRasterPos4s", handle), + glRasterPos4sv: get_func("glRasterPos4sv", handle), + glReadBuffer: get_func("glReadBuffer", handle), + glReadPixels: get_func("glReadPixels", handle), + glRectd: get_func("glRectd", handle), + glRectdv: get_func("glRectdv", handle), + glRectf: get_func("glRectf", handle), + glRectfv: get_func("glRectfv", handle), + glRecti: get_func("glRecti", handle), + glRectiv: get_func("glRectiv", handle), + glRects: get_func("glRects", handle), + glRectsv: get_func("glRectsv", handle), + glRenderMode: get_func("glRenderMode", handle), + glRenderbufferStorage: get_func("glRenderbufferStorage", handle), + glRenderbufferStorageMultisample: get_func("glRenderbufferStorageMultisample", handle), + glRotated: get_func("glRotated", handle), + glRotatef: get_func("glRotatef", handle), + glSampleCoverage: get_func("glSampleCoverage", handle), + glSampleMaski: get_func("glSampleMaski", handle), + glSamplerParameterIiv: get_func("glSamplerParameterIiv", handle), + glSamplerParameterIuiv: get_func("glSamplerParameterIuiv", handle), + glSamplerParameterf: get_func("glSamplerParameterf", handle), + glSamplerParameterfv: get_func("glSamplerParameterfv", handle), + glSamplerParameteri: get_func("glSamplerParameteri", handle), + glSamplerParameteriv: get_func("glSamplerParameteriv", handle), + glScaled: get_func("glScaled", handle), + glScalef: get_func("glScalef", handle), + glScissor: get_func("glScissor", handle), + glSecondaryColor3b: get_func("glSecondaryColor3b", handle), + glSecondaryColor3bv: get_func("glSecondaryColor3bv", handle), + glSecondaryColor3d: get_func("glSecondaryColor3d", handle), + glSecondaryColor3dv: get_func("glSecondaryColor3dv", handle), + glSecondaryColor3f: get_func("glSecondaryColor3f", handle), + glSecondaryColor3fv: get_func("glSecondaryColor3fv", handle), + glSecondaryColor3i: get_func("glSecondaryColor3i", handle), + glSecondaryColor3iv: get_func("glSecondaryColor3iv", handle), + glSecondaryColor3s: get_func("glSecondaryColor3s", handle), + glSecondaryColor3sv: get_func("glSecondaryColor3sv", handle), + glSecondaryColor3ub: get_func("glSecondaryColor3ub", handle), + glSecondaryColor3ubv: get_func("glSecondaryColor3ubv", handle), + glSecondaryColor3ui: get_func("glSecondaryColor3ui", handle), + glSecondaryColor3uiv: get_func("glSecondaryColor3uiv", handle), + glSecondaryColor3us: get_func("glSecondaryColor3us", handle), + glSecondaryColor3usv: get_func("glSecondaryColor3usv", handle), + glSecondaryColorP3ui: get_func("glSecondaryColorP3ui", handle), + glSecondaryColorP3uiv: get_func("glSecondaryColorP3uiv", handle), + glSecondaryColorPointer: get_func("glSecondaryColorPointer", handle), + glSelectBuffer: get_func("glSelectBuffer", handle), + glSetFenceAPPLE: get_func("glSetFenceAPPLE", handle), + glShadeModel: get_func("glShadeModel", handle), + glShaderSource: get_func("glShaderSource", handle), + glShaderStorageBlockBinding: get_func("glShaderStorageBlockBinding", handle), + glStencilFunc: get_func("glStencilFunc", handle), + glStencilFuncSeparate: get_func("glStencilFuncSeparate", handle), + glStencilMask: get_func("glStencilMask", handle), + glStencilMaskSeparate: get_func("glStencilMaskSeparate", handle), + glStencilOp: get_func("glStencilOp", handle), + glStencilOpSeparate: get_func("glStencilOpSeparate", handle), + glTestFenceAPPLE: get_func("glTestFenceAPPLE", handle), + glTestObjectAPPLE: get_func("glTestObjectAPPLE", handle), + glTexBuffer: get_func("glTexBuffer", handle), + glTexCoord1d: get_func("glTexCoord1d", handle), + glTexCoord1dv: get_func("glTexCoord1dv", handle), + glTexCoord1f: get_func("glTexCoord1f", handle), + glTexCoord1fv: get_func("glTexCoord1fv", handle), + glTexCoord1i: get_func("glTexCoord1i", handle), + glTexCoord1iv: get_func("glTexCoord1iv", handle), + glTexCoord1s: get_func("glTexCoord1s", handle), + glTexCoord1sv: get_func("glTexCoord1sv", handle), + glTexCoord2d: get_func("glTexCoord2d", handle), + glTexCoord2dv: get_func("glTexCoord2dv", handle), + glTexCoord2f: get_func("glTexCoord2f", handle), + glTexCoord2fv: get_func("glTexCoord2fv", handle), + glTexCoord2i: get_func("glTexCoord2i", handle), + glTexCoord2iv: get_func("glTexCoord2iv", handle), + glTexCoord2s: get_func("glTexCoord2s", handle), + glTexCoord2sv: get_func("glTexCoord2sv", handle), + glTexCoord3d: get_func("glTexCoord3d", handle), + glTexCoord3dv: get_func("glTexCoord3dv", handle), + glTexCoord3f: get_func("glTexCoord3f", handle), + glTexCoord3fv: get_func("glTexCoord3fv", handle), + glTexCoord3i: get_func("glTexCoord3i", handle), + glTexCoord3iv: get_func("glTexCoord3iv", handle), + glTexCoord3s: get_func("glTexCoord3s", handle), + glTexCoord3sv: get_func("glTexCoord3sv", handle), + glTexCoord4d: get_func("glTexCoord4d", handle), + glTexCoord4dv: get_func("glTexCoord4dv", handle), + glTexCoord4f: get_func("glTexCoord4f", handle), + glTexCoord4fv: get_func("glTexCoord4fv", handle), + glTexCoord4i: get_func("glTexCoord4i", handle), + glTexCoord4iv: get_func("glTexCoord4iv", handle), + glTexCoord4s: get_func("glTexCoord4s", handle), + glTexCoord4sv: get_func("glTexCoord4sv", handle), + glTexCoordP1ui: get_func("glTexCoordP1ui", handle), + glTexCoordP1uiv: get_func("glTexCoordP1uiv", handle), + glTexCoordP2ui: get_func("glTexCoordP2ui", handle), + glTexCoordP2uiv: get_func("glTexCoordP2uiv", handle), + glTexCoordP3ui: get_func("glTexCoordP3ui", handle), + glTexCoordP3uiv: get_func("glTexCoordP3uiv", handle), + glTexCoordP4ui: get_func("glTexCoordP4ui", handle), + glTexCoordP4uiv: get_func("glTexCoordP4uiv", handle), + glTexCoordPointer: get_func("glTexCoordPointer", handle), + glTexEnvf: get_func("glTexEnvf", handle), + glTexEnvfv: get_func("glTexEnvfv", handle), + glTexEnvi: get_func("glTexEnvi", handle), + glTexEnviv: get_func("glTexEnviv", handle), + glTexGend: get_func("glTexGend", handle), + glTexGendv: get_func("glTexGendv", handle), + glTexGenf: get_func("glTexGenf", handle), + glTexGenfv: get_func("glTexGenfv", handle), + glTexGeni: get_func("glTexGeni", handle), + glTexGeniv: get_func("glTexGeniv", handle), + glTexImage1D: get_func("glTexImage1D", handle), + glTexImage2D: get_func("glTexImage2D", handle), + glTexImage2DMultisample: get_func("glTexImage2DMultisample", handle), + glTexImage3D: get_func("glTexImage3D", handle), + glTexImage3DMultisample: get_func("glTexImage3DMultisample", handle), + glTexParameterIiv: get_func("glTexParameterIiv", handle), + glTexParameterIuiv: get_func("glTexParameterIuiv", handle), + glTexParameterf: get_func("glTexParameterf", handle), + glTexParameterfv: get_func("glTexParameterfv", handle), + glTexParameteri: get_func("glTexParameteri", handle), + glTexParameteriv: get_func("glTexParameteriv", handle), + glTexStorage1D: get_func("glTexStorage1D", handle), + glTexStorage2D: get_func("glTexStorage2D", handle), + glTexStorage3D: get_func("glTexStorage3D", handle), + glTexSubImage1D: get_func("glTexSubImage1D", handle), + glTexSubImage2D: get_func("glTexSubImage2D", handle), + glTexSubImage3D: get_func("glTexSubImage3D", handle), + glTextureRangeAPPLE: get_func("glTextureRangeAPPLE", handle), + glTransformFeedbackVaryings: get_func( + "glTransformFeedbackVaryings", + handle, + ), + glTranslated: get_func("glTranslated", handle), + glTranslatef: get_func("glTranslatef", handle), + glUniform1f: get_func("glUniform1f", handle), + glUniform1fv: get_func("glUniform1fv", handle), + glUniform1i: get_func("glUniform1i", handle), + glUniform1iv: get_func("glUniform1iv", handle), + glUniform1ui: get_func("glUniform1ui", handle), + glUniform1uiv: get_func("glUniform1uiv", handle), + glUniform2f: get_func("glUniform2f", handle), + glUniform2fv: get_func("glUniform2fv", handle), + glUniform2i: get_func("glUniform2i", handle), + glUniform2iv: get_func("glUniform2iv", handle), + glUniform2ui: get_func("glUniform2ui", handle), + glUniform2uiv: get_func("glUniform2uiv", handle), + glUniform3f: get_func("glUniform3f", handle), + glUniform3fv: get_func("glUniform3fv", handle), + glUniform3i: get_func("glUniform3i", handle), + glUniform3iv: get_func("glUniform3iv", handle), + glUniform3ui: get_func("glUniform3ui", handle), + glUniform3uiv: get_func("glUniform3uiv", handle), + glUniform4f: get_func("glUniform4f", handle), + glUniform4fv: get_func("glUniform4fv", handle), + glUniform4i: get_func("glUniform4i", handle), + glUniform4iv: get_func("glUniform4iv", handle), + glUniform4ui: get_func("glUniform4ui", handle), + glUniform4uiv: get_func("glUniform4uiv", handle), + glUniformBlockBinding: get_func("glUniformBlockBinding", handle), + glUniformMatrix2fv: get_func("glUniformMatrix2fv", handle), + glUniformMatrix2x3fv: get_func("glUniformMatrix2x3fv", handle), + glUniformMatrix2x4fv: get_func("glUniformMatrix2x4fv", handle), + glUniformMatrix3fv: get_func("glUniformMatrix3fv", handle), + glUniformMatrix3x2fv: get_func("glUniformMatrix3x2fv", handle), + glUniformMatrix3x4fv: get_func("glUniformMatrix3x4fv", handle), + glUniformMatrix4fv: get_func("glUniformMatrix4fv", handle), + glUniformMatrix4x2fv: get_func("glUniformMatrix4x2fv", handle), + glUniformMatrix4x3fv: get_func("glUniformMatrix4x3fv", handle), + glUnmapBuffer: get_func("glUnmapBuffer", handle), + glUseProgram: get_func("glUseProgram", handle), + glValidateProgram: get_func("glValidateProgram", handle), + glVertex2d: get_func("glVertex2d", handle), + glVertex2dv: get_func("glVertex2dv", handle), + glVertex2f: get_func("glVertex2f", handle), + glVertex2fv: get_func("glVertex2fv", handle), + glVertex2i: get_func("glVertex2i", handle), + glVertex2iv: get_func("glVertex2iv", handle), + glVertex2s: get_func("glVertex2s", handle), + glVertex2sv: get_func("glVertex2sv", handle), + glVertex3d: get_func("glVertex3d", handle), + glVertex3dv: get_func("glVertex3dv", handle), + glVertex3f: get_func("glVertex3f", handle), + glVertex3fv: get_func("glVertex3fv", handle), + glVertex3i: get_func("glVertex3i", handle), + glVertex3iv: get_func("glVertex3iv", handle), + glVertex3s: get_func("glVertex3s", handle), + glVertex3sv: get_func("glVertex3sv", handle), + glVertex4d: get_func("glVertex4d", handle), + glVertex4dv: get_func("glVertex4dv", handle), + glVertex4f: get_func("glVertex4f", handle), + glVertex4fv: get_func("glVertex4fv", handle), + glVertex4i: get_func("glVertex4i", handle), + glVertex4iv: get_func("glVertex4iv", handle), + glVertex4s: get_func("glVertex4s", handle), + glVertex4sv: get_func("glVertex4sv", handle), + glVertexAttrib1d: get_func("glVertexAttrib1d", handle), + glVertexAttrib1dv: get_func("glVertexAttrib1dv", handle), + glVertexAttrib1f: get_func("glVertexAttrib1f", handle), + glVertexAttrib1fv: get_func("glVertexAttrib1fv", handle), + glVertexAttrib1s: get_func("glVertexAttrib1s", handle), + glVertexAttrib1sv: get_func("glVertexAttrib1sv", handle), + glVertexAttrib2d: get_func("glVertexAttrib2d", handle), + glVertexAttrib2dv: get_func("glVertexAttrib2dv", handle), + glVertexAttrib2f: get_func("glVertexAttrib2f", handle), + glVertexAttrib2fv: get_func("glVertexAttrib2fv", handle), + glVertexAttrib2s: get_func("glVertexAttrib2s", handle), + glVertexAttrib2sv: get_func("glVertexAttrib2sv", handle), + glVertexAttrib3d: get_func("glVertexAttrib3d", handle), + glVertexAttrib3dv: get_func("glVertexAttrib3dv", handle), + glVertexAttrib3f: get_func("glVertexAttrib3f", handle), + glVertexAttrib3fv: get_func("glVertexAttrib3fv", handle), + glVertexAttrib3s: get_func("glVertexAttrib3s", handle), + glVertexAttrib3sv: get_func("glVertexAttrib3sv", handle), + glVertexAttrib4Nbv: get_func("glVertexAttrib4Nbv", handle), + glVertexAttrib4Niv: get_func("glVertexAttrib4Niv", handle), + glVertexAttrib4Nsv: get_func("glVertexAttrib4Nsv", handle), + glVertexAttrib4Nub: get_func("glVertexAttrib4Nub", handle), + glVertexAttrib4Nubv: get_func("glVertexAttrib4Nubv", handle), + glVertexAttrib4Nuiv: get_func("glVertexAttrib4Nuiv", handle), + glVertexAttrib4Nusv: get_func("glVertexAttrib4Nusv", handle), + glVertexAttrib4bv: get_func("glVertexAttrib4bv", handle), + glVertexAttrib4d: get_func("glVertexAttrib4d", handle), + glVertexAttrib4dv: get_func("glVertexAttrib4dv", handle), + glVertexAttrib4f: get_func("glVertexAttrib4f", handle), + glVertexAttrib4fv: get_func("glVertexAttrib4fv", handle), + glVertexAttrib4iv: get_func("glVertexAttrib4iv", handle), + glVertexAttrib4s: get_func("glVertexAttrib4s", handle), + glVertexAttrib4sv: get_func("glVertexAttrib4sv", handle), + glVertexAttrib4ubv: get_func("glVertexAttrib4ubv", handle), + glVertexAttrib4uiv: get_func("glVertexAttrib4uiv", handle), + glVertexAttrib4usv: get_func("glVertexAttrib4usv", handle), + glVertexAttribDivisor: get_func("glVertexAttribDivisor", handle), + glVertexAttribI1i: get_func("glVertexAttribI1i", handle), + glVertexAttribI1iv: get_func("glVertexAttribI1iv", handle), + glVertexAttribI1ui: get_func("glVertexAttribI1ui", handle), + glVertexAttribI1uiv: get_func("glVertexAttribI1uiv", handle), + glVertexAttribI2i: get_func("glVertexAttribI2i", handle), + glVertexAttribI2iv: get_func("glVertexAttribI2iv", handle), + glVertexAttribI2ui: get_func("glVertexAttribI2ui", handle), + glVertexAttribI2uiv: get_func("glVertexAttribI2uiv", handle), + glVertexAttribI3i: get_func("glVertexAttribI3i", handle), + glVertexAttribI3iv: get_func("glVertexAttribI3iv", handle), + glVertexAttribI3ui: get_func("glVertexAttribI3ui", handle), + glVertexAttribI3uiv: get_func("glVertexAttribI3uiv", handle), + glVertexAttribI4bv: get_func("glVertexAttribI4bv", handle), + glVertexAttribI4i: get_func("glVertexAttribI4i", handle), + glVertexAttribI4iv: get_func("glVertexAttribI4iv", handle), + glVertexAttribI4sv: get_func("glVertexAttribI4sv", handle), + glVertexAttribI4ubv: get_func("glVertexAttribI4ubv", handle), + glVertexAttribI4ui: get_func("glVertexAttribI4ui", handle), + glVertexAttribI4uiv: get_func("glVertexAttribI4uiv", handle), + glVertexAttribI4usv: get_func("glVertexAttribI4usv", handle), + glVertexAttribIPointer: get_func("glVertexAttribIPointer", handle), + glVertexAttribP1ui: get_func("glVertexAttribP1ui", handle), + glVertexAttribP1uiv: get_func("glVertexAttribP1uiv", handle), + glVertexAttribP2ui: get_func("glVertexAttribP2ui", handle), + glVertexAttribP2uiv: get_func("glVertexAttribP2uiv", handle), + glVertexAttribP3ui: get_func("glVertexAttribP3ui", handle), + glVertexAttribP3uiv: get_func("glVertexAttribP3uiv", handle), + glVertexAttribP4ui: get_func("glVertexAttribP4ui", handle), + glVertexAttribP4uiv: get_func("glVertexAttribP4uiv", handle), + glVertexAttribPointer: get_func("glVertexAttribPointer", handle), + glVertexP2ui: get_func("glVertexP2ui", handle), + glVertexP2uiv: get_func("glVertexP2uiv", handle), + glVertexP3ui: get_func("glVertexP3ui", handle), + glVertexP3uiv: get_func("glVertexP3uiv", handle), + glVertexP4ui: get_func("glVertexP4ui", handle), + glVertexP4uiv: get_func("glVertexP4uiv", handle), + glVertexPointer: get_func("glVertexPointer", handle), + glViewport: get_func("glViewport", handle), + glWaitSync: get_func("glWaitSync", handle), + glWindowPos2d: get_func("glWindowPos2d", handle), + glWindowPos2dv: get_func("glWindowPos2dv", handle), + glWindowPos2f: get_func("glWindowPos2f", handle), + glWindowPos2fv: get_func("glWindowPos2fv", handle), + glWindowPos2i: get_func("glWindowPos2i", handle), + glWindowPos2iv: get_func("glWindowPos2iv", handle), + glWindowPos2s: get_func("glWindowPos2s", handle), + glWindowPos2sv: get_func("glWindowPos2sv", handle), + glWindowPos3d: get_func("glWindowPos3d", handle), + glWindowPos3dv: get_func("glWindowPos3dv", handle), + glWindowPos3f: get_func("glWindowPos3f", handle), + glWindowPos3fv: get_func("glWindowPos3fv", handle), + glWindowPos3i: get_func("glWindowPos3i", handle), + glWindowPos3iv: get_func("glWindowPos3iv", handle), + glWindowPos3s: get_func("glWindowPos3s", handle), + glWindowPos3sv: get_func("glWindowPos3sv", handle), + }; + + Ok(Self { + _opengl_lib_handle: handle, + functions: Rc::new(context), + }) + } + + /// Returns the loaded function pointers (for use in your GL code). + pub fn get_context(&self) -> Rc { + self.functions.clone() + } +} + +impl Drop for GlFunctions { + fn drop(&mut self) { + // On drop, close the handle. + if !self._opengl_lib_handle.is_null() { + unsafe { + dlclose(self._opengl_lib_handle); + } + } + } +} \ No newline at end of file diff --git a/azul-desktop/src/shell/appkit/menu.rs b/azul-desktop/src/shell/appkit/menu.rs new file mode 100644 index 000000000..f48b44688 --- /dev/null +++ b/azul-desktop/src/shell/appkit/menu.rs @@ -0,0 +1,323 @@ + +use std::collections::BTreeMap; +use std::ffi::{CStr, CString, c_void}; +use std::sync::atomic::{AtomicI32, AtomicIsize, Ordering}; +use std::sync::{Arc, Mutex}; + +use azul_core::callbacks::CallbackInfo; +use azul_core::window::{Menu, MenuCallback, MenuItem, ProcessEventResult}; +use azul_core::styled_dom::NodeHierarchyItemId; +use azul_core::window_state::NodesToCheck; + +use objc2::rc::Id; +use objc2::rc::Retained; +use objc2::MainThreadMarker; +use objc2_foundation::{NSString}; +use objc2_app_kit::{NSEventModifierFlags, NSMenu, NSMenuItem, NSUserInterfaceItemIdentification, NSWindow}; +use objc2::runtime::{AnyClass, AnyObject, Object, Sel, NO}; +use once_cell::sync::Lazy; +use objc2::{declare::ClassDecl, sel, msg_send}; + +use super::{AppData, MacApp, WindowId}; + +// We'll store: (tag: i32) => MenuCallback +// (On macOS, `tag` is an `NSInteger` or `i64`. We'll just use `i32` for simplicity.) +pub type CommandMap = BTreeMap; + +#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct MacOsMenuCommands { + pub menu_hash: u64, + pub commands: CommandMap, +} + +#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub enum MenuTarget { + App, + Window(isize), +} + +#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[repr(transparent)] +pub struct CommandId(pub isize); + +impl CommandId { + pub fn new() -> Self { + static NEXT_MENU_TAG: AtomicIsize = AtomicIsize::new(0); + Self(NEXT_MENU_TAG.fetch_add(1, Ordering::SeqCst)) + } +} + +// If the app_data.active_menus[target] differs from the `menu`, creates a new +// NSMenu and returns it. Should only be called on the main thread. +pub fn reinit_nsmenu( + mtm: &MainThreadMarker, + target: MenuTarget, + menu: &Menu, + menu_handler_class: *mut Object, +) -> Option<(Retained, MacOsMenuCommands)> { + let menu_hash = menu.get_hash(); + let mut m = NSMenu::new(*mtm); + let mut map = CommandMap::new(); + recursive_construct_menu(mtm, &menu.items.as_slice(), &mut m, &mut map, menu_handler_class); + Some((m, MacOsMenuCommands { + menu_hash, + commands: map, + })) +} + +/// Recursively build an `NSMenu` from our `MenuItem` list +fn recursive_construct_menu( + mtm: &MainThreadMarker, + items: &[MenuItem], + menu: &NSMenu, + command_map: &mut CommandMap, + menu_handler_class: *mut Object +) { + unsafe { + for item in items { + match item { + MenuItem::String(mi) => { + if mi.children.is_empty() { + + // Leaf menu item + let mut menu_item = NSMenuItem::new(*mtm); + menu_item.setTitle(&NSString::from_str(&mi.label)); + menu_item.setAction(Some(sel!(menuItemClicked:))); + menu_item.setTarget(Some(&*menu_handler_class)); + + // If there's a callback, assign a fresh "tag" integer + if let Some(cb) = &mi.callback.as_ref() { + let new_tag = CommandId::new(); + command_map.insert(new_tag, (*cb).clone()); + menu_item.setTag(new_tag.0); + } + + if let Some(vk) = mi.accelerator.as_ref() { + use azul_core::window::VirtualKeyCode; + + let keys = vk.keys.as_slice(); + if !keys.is_empty() { + let mut flags = NSEventModifierFlags::empty(); + + if keys.contains(&VirtualKeyCode::LShift) || keys.contains(&VirtualKeyCode::RShift) { + flags.insert(NSEventModifierFlags::Shift); + } + if keys.contains(&VirtualKeyCode::LControl) || keys.contains(&VirtualKeyCode::RControl) { + flags.insert(NSEventModifierFlags::Control); + } + if keys.contains(&VirtualKeyCode::LAlt) || keys.contains(&VirtualKeyCode::RAlt) { + flags.insert(NSEventModifierFlags::Option); + } + if keys.contains(&VirtualKeyCode::LWin) || keys.contains(&VirtualKeyCode::RWin) { + flags.insert(NSEventModifierFlags::Command); + } + + // TODO: function keys! + let keys = keys.iter() + .filter_map(|s| s.get_lowercase()) + .collect::(); + + menu_item.setKeyEquivalentModifierMask(flags); + menu_item.setKeyEquivalent(&NSString::from_str(&keys)); + } + } + + menu.addItem(&menu_item); + } else { + + let mut submenu_item = NSMenuItem::new(*mtm); + submenu_item.setTitle(&NSString::from_str(&mi.label)); + submenu_item.setAction(Some(sel!(menuItemClicked:))); + + // Create the submenu itself + let mut submenu = NSMenu::new(*mtm); + submenu.setTitle(&NSString::from_str(&mi.label)); + recursive_construct_menu(mtm, mi.children.as_slice(), &submenu, command_map, menu_handler_class); + menu.setSubmenu_forItem(Some(&*submenu), &submenu_item); + menu.addItem(&submenu_item); + } + }, + MenuItem::Separator | MenuItem::BreakLine => { + let separator = NSMenuItem::separatorItem(*mtm); + menu.addItem(&separator); + } + } + } + } +} + +// Returns the class definition for the Menu click handler +pub fn menu_handler_class() -> ClassDecl { + + let superclass = objc2::class!(NSObject); + + let c = CString::new("RustMenuHandler").unwrap(); + let mut decl = ClassDecl::new(&c, superclass) + .expect("MenuHandler class name is already registered?"); + + unsafe { + let c = CString::new("app").unwrap(); + decl.add_ivar::<*const c_void>(&c); + decl.add_method( + sel!(menuItemClicked:), + menu_item_clicked as extern "C" fn(*mut Object, Sel, *mut Object) + ); + } + + decl +} + +/// Creates an instance of the class, with a pointer to the `MacApp` stored in the `app` ivar. +fn create_menu_handler_instance(cls: &AnyClass, megaclass: &MacApp) -> *mut Object { + unsafe { + let instance: *mut Object = msg_send![cls, new]; + *((*instance).get_mut_ivar("app")) = megaclass as *const _ as *const c_void; + instance + } +} + +/// The actual callback method for your NSMenuItem action +extern "C" fn menu_item_clicked(this: *mut Object, _sel: Sel, sender: *mut Object) { + unsafe { + + // `sender` is an NSMenuItem + let tag: isize = msg_send![sender, tag]; + + let ptr = (*this).get_ivar::<*const c_void>("app"); + let ptr = *ptr as *const MacApp; + let ptr = &*ptr; + let windowid = *(*this).get_ivar::("windowid"); + + let cb = ptr.active_menus.values() + .find_map(|s| s.get(&CommandId(tag))); + + let callback = match cb { + Some(s) => s, + None => return, + }; + + let mut app_borrow = ptr.data.lock().unwrap(); + + let mut ret = ProcessEventResult::DoNothing; + // let mut new_windows = Vec::new(); + // let mut destroyed_windows = Vec::new(); + let mut ab = &mut app_borrow.userdata; + + let windows = &mut ab.windows; + let data = &mut ab.data; + let image_cache = &mut ab.image_cache; + let fc_cache = &mut ab.fc_cache; + let config = &ab.config; + + let mut current_window = match app_borrow.windows.get_mut(&WindowId { id: windowid as i64 }) { + Some(s) => s, + None => return, + }; + + let ntc = NodesToCheck::empty( + current_window.internal.current_window_state.mouse_state.mouse_down(), + current_window.internal.current_window_state.focused_node, + ); + + /* + + let call_callback_result = { + + let mb = &mut current_window.menu_bar; + let internal = &mut current_window.internal; + let context_menu = current_window.context_menu.as_mut(); + let gl_context_ptr = ¤t_window.gl_context_ptr; + + if let Some(menu_callback) = mb.as_mut().and_then(|m| m.callbacks.get_mut(&loword)) { + Some(fc_cache.apply_closure(|fc_cache| { + internal.invoke_menu_callback( + menu_callback, + DomNodeId { + dom: DomId::ROOT_ID, + node: NodeHierarchyItemId::from_crate_internal(None), + }, + &window_handle, + &gl_context_ptr, + image_cache, + fc_cache, + &config.system_callbacks, + ) + })) + } else if let Some(context_menu) = context_menu { + let hit_dom_node = context_menu.hit_dom_node; + if let Some(menu_callback) = context_menu.callbacks.get_mut(&loword) { + Some(fc_cache.apply_closure(|fc_cache| { + internal.invoke_menu_callback( + menu_callback, + hit_dom_node, + &window_handle, + &gl_context_ptr, + image_cache, + fc_cache, + &config.system_callbacks, + ) + })) + } else { + None + } + } else { + None + } + }; + + if let Some(ccr) = call_callback_result { + ret = process_callback_results( + ccr, + current_window, + &ntc, + image_cache, + fc_cache, + &mut new_windows, + &mut destroyed_windows, + ); + }; + + // same as invoke_timers(), invoke_threads(), ... + + mem::drop(ab); + mem::drop(app_borrow); + create_windows(hinstance, shared_application_data, new_windows); + + let mut app_borrow = shared_application_data.inner.try_borrow_mut().unwrap(); + let mut ab = &mut *app_borrow; + destroy_windows(ab, destroyed_windows); + + match ret { + ProcessEventResult::DoNothing => { }, + ProcessEventResult::ShouldRegenerateDomCurrentWindow => { + PostMessageW(hwnd, AZ_REGENERATE_DOM, 0, 0); + }, + ProcessEventResult::ShouldRegenerateDomAllWindows => { + for window in app_borrow.windows.values() { + PostMessageW(window.hwnd, AZ_REGENERATE_DOM, 0, 0); + } + }, + ProcessEventResult::ShouldUpdateDisplayListCurrentWindow => { + PostMessageW(hwnd, AZ_REGENERATE_DISPLAY_LIST, 0, 0); + }, + ProcessEventResult::UpdateHitTesterAndProcessAgain => { + if let Some(w) = app_borrow.windows.get_mut(&hwnd_key) { + w.internal.previous_window_state = Some(w.internal.current_window_state.clone()); + // TODO: submit display list, wait for new hit-tester and update hit-test results + PostMessageW(hwnd, AZ_REGENERATE_DISPLAY_LIST, 0, 0); + PostMessageW(hwnd, AZ_REDO_HIT_TEST, 0, 0); + } + }, + ProcessEventResult::ShouldReRenderCurrentWindow => { + PostMessageW(hwnd, AZ_GPU_SCROLL_RENDER, 0, 0); + }, + } + + mem::drop(app_borrow); + return 0; + + */ + } +} + + diff --git a/azul-desktop/src/shell/appkit/mod.rs b/azul-desktop/src/shell/appkit/mod.rs index 6d5a36592..ffc098f50 100644 --- a/azul-desktop/src/shell/appkit/mod.rs +++ b/azul-desktop/src/shell/appkit/mod.rs @@ -1,17 +1,26 @@ #![cfg(target_os = "macos")] +use std::collections::BTreeMap; use std::ffi::{CStr, CString}; +use std::ptr::NonNull; +use std::sync::atomic::{AtomicUsize, Ordering}; use std::sync::{Arc, Mutex}; +use azul_core::gl::OptionGlContextPtr; +use azul_core::task::{Thread, ThreadId, Timer, TimerId}; +use azul_core::window_state::NodesToCheck; +use azul_core::{FastBTreeSet, FastHashMap}; +use gl_context_loader::GenericGlContext; use objc2::declare::ClassDecl; -use objc2::runtime::{AnyObject, Class, Object, Sel}; +use objc2::runtime::{AnyClass, AnyObject, Class, ClassBuilder, Object, ProtocolObject, Sel}; use objc2::*; -use azul_core::window::MonitorVec; +use azul_core::window::{MacOSHandle, MonitorVec, ScrollResult, WindowInternal, WindowInternalInit}; use azul_core::window::WindowCreateOptions; use crate::app::App; +use crate::wr_translate::{wr_synchronize_updated_images, AsyncHitTester}; use objc2::runtime::YES; use objc2::rc::{autoreleasepool, AutoreleasePool, Retained}; -use objc2_app_kit::{NSView, NSWindowStyleMask}; +use objc2_app_kit::{NSAppKitVersionNumber, NSAppKitVersionNumber10_12, NSView, NSWindowStyleMask, NSWindowWillCloseNotification}; use objc2_app_kit::NSApp; -use objc2_foundation::MainThreadMarker; +use objc2_foundation::{MainThreadMarker, NSNotification, NSNotificationCenter, NSNotificationName, NSObjectProtocol}; use objc2::ffi::id; use objc2_foundation::NSRect; use objc2_foundation::NSString; @@ -22,68 +31,230 @@ use objc2_foundation::NSPoint; use std::ffi::c_void; use objc2_app_kit::NSBackingStoreType; use objc2_app_kit::NSApplicationActivationPolicy; - -#[link(name = "OpenGL", kind = "framework")] -extern "C" { - fn glClearColor(r: f32, g: f32, b: f32, a: f32); - fn glClear(mask: u32); +use std::{fmt, mem, os::raw::c_char, ptr, rc::Rc}; +use self::gl::GlFunctions; +use objc2::rc::Id; +use azul_core::window::{RawWindowHandle, WindowId, WindowsHandle}; +use webrender::{ + api::{ + units::{ + DeviceIntPoint as WrDeviceIntPoint, + DeviceIntRect as WrDeviceIntRect, + DeviceIntSize as WrDeviceIntSize, + LayoutSize as WrLayoutSize, + }, + HitTesterRequest as WrHitTesterRequest, + ApiHitTester as WrApiHitTester, DocumentId as WrDocumentId, + RenderNotifier as WrRenderNotifier, + }, + render_api::RenderApi as WrRenderApi, + PipelineInfo as WrPipelineInfo, Renderer as WrRenderer, RendererError as WrRendererError, + RendererOptions as WrRendererOptions, ShaderPrecacheFlags as WrShaderPrecacheFlags, + Shaders as WrShaders, Transaction as WrTransaction, +}; + +mod menu; +mod gl; + +pub(crate) struct MacApp { + pub(crate) functions: Rc, + pub(crate) active_menus: BTreeMap, + pub(crate) data: Arc>, } -const GL_COLOR_BUFFER_BIT: u32 = 0x00004000; - - -#[derive(Debug, Clone)] struct AppData { - test: &'static str, + userdata: App, + windows: BTreeMap } -// In your actual code, you have this function to build and send -// the WebRender display list. This is just a minimal placeholder: -fn rebuild_display_list() { - // In a real application, you'd: - // 1) Gather your layout results - // 2) Build your WebRender display list - // 3) Send it to the WebRender API - // For demonstration, just a stub: - println!("(Stub) rebuild_display_list called"); +pub(crate) struct Window { + /// Internal Window ID + pub(crate) id: WindowId, + /// NSWindow + pub(crate) ns_window: Option>, + /// Observer that fires a notification when the window is closed + pub(crate) ns_close_observer: Retained>, + /// See azul-core, stores the entire UI (DOM, CSS styles, layout results, etc.) + pub(crate) internal: WindowInternal, + /// Main render API that can be used to register and un-register fonts and images + pub(crate) render_api: WrRenderApi, + /// WebRender renderer implementation (software or hardware) + pub(crate) renderer: Option, + /// Hit-tester, lazily initialized and updated every time the display list changes layout + pub(crate) hit_tester: AsyncHitTester, + pub(crate) gl_context_ptr: OptionGlContextPtr, + /* + /// ID -> Callback map for the window menu (default: empty map) + menu_bar: Option, + /// ID -> Context menu callbacks (cleared when the context menu closes) + context_menu: Option, + /// Timer ID -> Win32 timer map + timers: BTreeMap, + /// If threads is non-empty, the window will receive a WM_TIMER every 16ms + thread_timer_running: Option, + */ } -pub struct MacApp { - data: Arc>, +impl Window { + + pub(crate) fn start_stop_timers( + &mut self, + added: FastHashMap, + removed: FastBTreeSet + ) { + + /* + use winapi::um::winuser::{SetTimer, KillTimer}; + + for (id, timer) in added { + let res = unsafe { SetTimer(self.hwnd, id.id, timer.tick_millis().min(u32::MAX as u64) as u32, None) }; + self.internal.timers.insert(id, timer); + self.timers.insert(id, res); + } + + for id in removed { + if let Some(_) = self.internal.timers.remove(&id) { + if let Some(handle) = self.timers.remove(&id) { + unsafe { KillTimer(self.hwnd, handle) }; + } + } + } + */ + } + + pub(crate) fn start_stop_threads( + &mut self, + mut added: FastHashMap, + removed: FastBTreeSet + ) { + + /* + use winapi::um::winuser::{SetTimer, KillTimer}; + + self.internal.threads.append(&mut added); + self.internal.threads.retain(|r, _| !removed.contains(r)); + + if self.internal.threads.is_empty() { + if let Some(thread_tick) = self.thread_timer_running { + unsafe { KillTimer(self.hwnd, thread_tick) }; + } + self.thread_timer_running = None; + } else if !self.internal.threads.is_empty() && self.thread_timer_running.is_none() { + let res = unsafe { SetTimer(self.hwnd, AZ_THREAD_TICK, 16, None) }; // 16ms timer + self.thread_timer_running = Some(res); + } + */ + } + + // Stop all timers that have a NodeId attached to them because in the next + // frame the NodeId would be invalid, leading to crashes / panics + pub(crate) fn stop_timers_with_node_ids(&mut self) { + let timers_to_remove = self.internal.timers + .iter() + .filter_map(|(id, timer)| timer.node_id.as_ref().map(|_| *id)) + .collect(); + + self.start_stop_timers(FastHashMap::default(), timers_to_remove); + } + + // ScrollResult contains information about what nodes need to be scrolled, + // whether they were scrolled by the system or by the user and how far they + // need to be scrolled + pub(crate) fn do_system_scroll(&mut self, scroll: ScrollResult) { + // for scrolled_node in scroll { + // self.render_api.scroll_node_with_id(); + // let scrolled_rect = LogicalRect { origin: scroll_offset, size: visible.size }; + // if !scrolled_node.scroll_bounds.contains(&scroll_rect) { + // + // } + // } + } } pub fn get_monitors(app: &App) -> MonitorVec { azul_core::window::MonitorVec::from_const_slice(&[]) // TODO } -pub fn run(options: WindowCreateOptions) -> Result<(), String> { - - println!("cocoa run"); +pub fn run(app: App, root_window: WindowCreateOptions) -> Result<(), String> { + + let context = GlFunctions::initialize()?; let s = MacApp { + functions: context.functions.clone(), + active_menus: BTreeMap::new(), data: Arc::new(Mutex::new(AppData { - test: "hello" + userdata: app, + windows: BTreeMap::new(), })), }; - let mtm = MainThreadMarker::new().unwrap(); - autoreleasepool(|app| { + + let mtm = MainThreadMarker::new() + .ok_or_else(|| format!("appkit::run(app, root_window) not on main thread"))?; + + let ns_opengl_class = ns_opengl_class(); + let any_opengl_class = ns_opengl_class.register(); + + let ns_menu_class = menu::menu_handler_class(); + let any_menu_class = ns_menu_class.register(); + let app = NSApp(mtm); + + let (window_id, window) = create_nswindow( + &mtm, + root_window, + &any_opengl_class, + &any_menu_class, + &s + )?; + + // Show the window + window.ns_window.as_ref().map(|s| s.makeKeyAndOrderFront(None)); + + s.data.lock().unwrap().windows.insert(window_id, window); + app.setActivationPolicy(NSApplicationActivationPolicy::Regular); - let _window_id = unsafe { create_nswindow(s.data.clone(), options) }; app.activateIgnoringOtherApps(true); app.run(); + Ok(()) }) } -// ----------------------------------------------------------------------------- -// Creating the NSWindow and hooking up an NSOpenGLView -// ----------------------------------------------------------------------------- +// Creates an NSWindow and hooks up an NSOpenGLView +fn create_nswindow( + mtm: &MainThreadMarker, + mut options: WindowCreateOptions, + ns_opengl_view: &AnyClass, + ns_menu_view: &AnyClass, + megaclass: &MacApp, +) -> Result<(WindowId, Window), String> { + + use crate::{ + compositor::Compositor, + wr_translate::{ + translate_document_id_wr, + translate_id_namespace_wr, + wr_translate_debug_flags, + wr_translate_document_id, + }, + }; + use azul_core::{ + callbacks::PipelineId, + gl::GlContextPtr, + window::{ + CursorPosition, HwAcceleration, + LogicalPosition, ScrollResult, + PhysicalSize, RendererType, + WindowInternalInit, FullHitTest, + WindowFrame, + }, + }; + use webrender::api::ColorF as WrColorF; + use webrender::ProgramCache as WrProgramCache; -unsafe fn create_nswindow(data: Arc>, options: WindowCreateOptions) -> Retained { - + // let parent_window = options.platform_specific_options.parent_window; let width = options.state.size.dimensions.width as f64; let height = options.state.size.dimensions.height as f64; let rect = NSRect::new(NSPoint::new(0.0, 0.0), NSSize::new(width, height)); @@ -94,94 +265,442 @@ unsafe fn create_nswindow(data: Arc>, options: WindowCreateOption | NSWindowStyleMask::Miniaturizable; let mtm = MainThreadMarker::new().unwrap(); - println!("NSWindow::alloc"); let window = NSWindow::alloc(mtm); - let window = NSWindow::initWithContentRect_styleMask_backing_defer( + let window = unsafe { + NSWindow::initWithContentRect_styleMask_backing_defer( window, rect, style_mask, NSBackingStoreType::Buffered, false, - ); - println!("NSWindow::window"); + ) }; window.center(); - window.setTitle(&NSString::from_str(&options.state.title)); - // Create the custom view that will handle drawing: - let gl_view = create_opengl_view(rect, data); + let dpi_factor = window.screen().map(|s| s.backingScaleFactor()).unwrap_or(1.0); + options.state.size.dpi = (dpi_factor * 96.0) as u32; + + let physical_size = if options.size_to_content { + PhysicalSize { + width: 0, + height: 0, + } + } else { + PhysicalSize { + width: width as u32, + height: height as u32, + } + }; + + options.state.size.dimensions = physical_size.to_logical(dpi_factor as f32); + + let (window_id, gl_view) = create_opengl_view( + rect, ns_opengl_view, megaclass + ); + + // Attach an observer for "will close" notifications + let data_clone2 = megaclass.data.clone(); + let observer = unsafe { + create_observer( + &objc2_foundation::NSNotificationCenter::defaultCenter(), + &NSWindowWillCloseNotification, + move |notification| { window_will_close(Arc::clone(&data_clone2), window_id, mtm); }, + ) }; + + // Make gl_view the content view of the window + unsafe { window.setContentView(Some(&*(gl_view as *const _ as *const NSView))) }; + + let rt = RendererType::Hardware; + let gl_context_ptr: OptionGlContextPtr = Some(unsafe { + let gl_context: *mut Object = msg_send![gl_view, openGLContext]; + let _: () = msg_send![gl_context, makeCurrentContext]; + let s = GlContextPtr::new(rt, megaclass.functions.clone()); + let _: () = msg_send![gl_context, flushBuffer]; + s + }).into(); + + + // WindowInternal::new() may dispatch OpenGL calls, + // need to make context current before invoking + let gl_context: *mut Object = unsafe { msg_send![gl_view, openGLContext] }; + let _: () = unsafe { msg_send![gl_context, makeCurrentContext] }; + + // Invoke callback to initialize UI for the first time + let wr = WrRenderer::new( + megaclass.functions.clone(), + Box::new(super::Notifier {}), + super::default_renderer_options(&options), + super::WR_SHADER_CACHE, + ).map_err(|e| format!("{e:?}"))?; + + let (mut renderer, sender) = wr; + + renderer.set_external_image_handler(Box::new(Compositor::default())); + + let mut render_api = sender.create_api(); + let framebuffer_size = WrDeviceIntSize::new(physical_size.width as i32, physical_size.height as i32); + let document_id = translate_document_id_wr(render_api.add_document(framebuffer_size)); + let pipeline_id = PipelineId::new(); + let id_namespace = translate_id_namespace_wr(render_api.get_namespace_id()); + let hit_tester = render_api + .request_hit_tester(wr_translate_document_id(document_id)) + .resolve(); + let hit_tester_ref = &*hit_tester; + + let mut appdata_lock = match megaclass.data.lock() { + Ok(o) => o, + Err(e) => unsafe { + return Err(format!("failed to lock app data on startup {e:?}")) + }, + }; + - println!("setting content to GL view"); + let mut initial_resource_updates = Vec::new(); + let mut internal = { + + let appdata_lock = &mut *appdata_lock; + let fc_cache = &mut appdata_lock.userdata.fc_cache; + let image_cache = &appdata_lock.userdata.image_cache; + let data = &mut appdata_lock.userdata.data; + + fc_cache.apply_closure(|fc_cache| { + WindowInternal::new( + WindowInternalInit { + window_create_options: options.clone(), + document_id, + id_namespace, + }, + data, + image_cache, + &gl_context_ptr, + &mut initial_resource_updates, + &crate::app::CALLBACKS, + fc_cache, + azul_layout::do_the_relayout, + |window_state, scroll_states, layout_results| { + crate::wr_translate::fullhittest_new_webrender( + hit_tester_ref, + document_id, + window_state.focused_node, + layout_results, + &window_state.mouse_state.cursor_position, + window_state.size.get_hidpi_factor(), + ) + }, + ) + }) + }; - // Make gl_view the content view of the window: - window.setContentView(Some(&*(gl_view as *const _ as *const NSView))); - // If the user wants the window sized to content, you would measure the - // "rebuild_display_list" result and resize to that. Skipping for brevity. + /* + // Since the menu bar affects the window size, set it first, + // before querying the window size again + let mut menu_bar = None; + if let Some(m) = internal.get_menu_bar() { + let mb = WindowsMenuBar::new(m); + unsafe { SetMenu(hwnd, mb._native_ptr); } + menu_bar = Some(mb); + } + */ + + // If size_to_content is set, query the content size and adjust! + if options.size_to_content { + let content_size = internal.get_content_size(); + // window.setWidth(content_size.width); + // window.setHeight(content_size.height); + internal.current_window_state.size.dimensions = content_size; + } + + let mut txn = WrTransaction::new(); + + // re-layout the window content for the first frame + // (since the width / height might have changed) + let resize_result = { + let mut uc = &mut appdata_lock.userdata; + let fcc = &mut uc.fc_cache; + let ic = &uc.image_cache; + fcc.apply_closure(|mut fc_cache| { + let size = internal.current_window_state.size.clone(); + let theme = internal.current_window_state.theme; + + internal.do_quick_resize( + ic, + &crate::app::CALLBACKS, + azul_layout::do_the_relayout, + &mut fc_cache, + &gl_context_ptr, + &size, + theme, + ) + }) + }; - println!("makeKeyAndOrderFront"); + wr_synchronize_updated_images(resize_result.updated_images, &document_id, &mut txn); - window.makeKeyAndOrderFront(None); + // glContext can be deactivated now + let _: () = unsafe { msg_send![gl_context, flushBuffer] }; - window + txn.set_document_view( + WrDeviceIntRect::from_size( + WrDeviceIntSize::new(physical_size.width as i32, physical_size.height as i32), + ) + ); + render_api.send_transaction(wr_translate_document_id(internal.document_id), txn); + render_api.flush_scene_builder(); + + // Build the display list and send it to webrender for the first time + crate::wr_translate::rebuild_display_list( + &mut internal, + &mut render_api, + &appdata_lock.userdata.image_cache, + initial_resource_updates, + ); + + render_api.flush_scene_builder(); + + crate::wr_translate::generate_frame( + &mut internal, + &mut render_api, + true, + ); + + render_api.flush_scene_builder(); + + /* + // Get / store mouse cursor position, now that the window position is final + let mut cursor_pos: POINT = POINT { x: 0, y: 0 }; + unsafe { GetCursorPos(&mut cursor_pos); } + unsafe { ScreenToClient(hwnd, &mut cursor_pos) }; + let cursor_pos_logical = LogicalPosition { + x: cursor_pos.x as f32 / dpi_factor, + y: cursor_pos.y as f32 / dpi_factor, + }; + internal.current_window_state.mouse_state.cursor_position = if cursor_pos.x <= 0 || cursor_pos.y <= 0 { + CursorPosition::Uninitialized + } else { + CursorPosition::InWindow(cursor_pos_logical) + }; + */ + + // Update the hit-tester to account for the new hit-testing functionality + let hit_tester = render_api.request_hit_tester(wr_translate_document_id(document_id)); + + // Done! Window is now created properly, display list has been built by + // WebRender (window is ready to render), menu bar is visible and hit-tester + // now contains the newest UI tree. + + if options.hot_reload { + // SetTimer(regenerate_dom, 200ms); + } + + // regenerate_dom (???) - necessary? + let mut window = Window { + id: window_id.clone(), + ns_window: Some(window), + internal, + render_api, + renderer: Some(renderer), + hit_tester: AsyncHitTester::Requested(hit_tester), + ns_close_observer: observer, + gl_context_ptr: gl_context_ptr, + }; + + // invoke the window create callback, if there is any + let (windows_to_create, windows_to_destroy) = + if let Some(create_callback) = options.create_callback.as_mut() { + + let _: () = unsafe { msg_send![gl_context, makeCurrentContext] }; + + let uc = &mut appdata_lock.userdata; + let fcc = &mut uc.fc_cache; + let ud = &mut uc.data; + let ic1 = &mut uc.image_cache; + let sysc = &uc.config.system_callbacks; + + let ccr = fcc.apply_closure(|mut fc_cache| { + + let raw_window_ptr = window.ns_window.take().map(|s| { + Retained::::into_raw(s) + }).unwrap_or_else(|| std::ptr::null_mut()); + + let s = window.internal.invoke_single_callback( + create_callback, + ud, + &RawWindowHandle::MacOS(MacOSHandle { + ns_view: gl_view as *mut c_void, + ns_window: raw_window_ptr as *mut c_void, + }), + &window.gl_context_ptr, + ic1, + &mut fc_cache, + sysc, + ); + + window.ns_window = unsafe { Retained::::from_raw(raw_window_ptr) }; + + s + }); + + let ntc = NodesToCheck::empty( + window.internal.current_window_state.mouse_state.mouse_down(), + window.internal.current_window_state.focused_node.clone(), + ); + + let mut new_windows = Vec::new(); + let mut destroyed_windows = Vec::new(); + + let ret = { + let mut ud = &mut appdata_lock.userdata; + let ic = &mut ud.image_cache; + let fc = &mut ud.fc_cache; + super::process::process_callback_results( + ccr, + &mut window, + &ntc, + ic, + fc, + &mut new_windows, + &mut destroyed_windows, + ) + }; + + let _: () = unsafe { msg_send![gl_context, flushBuffer] }; + + (new_windows, destroyed_windows) + } else { + (Vec::new(), Vec::new()) + }; + + mem::drop(appdata_lock); + + create_windows( + &mtm, + megaclass, + windows_to_create, + ns_opengl_view, + ns_menu_view + ); + + destroy_windows(megaclass, windows_to_destroy); + + Ok((window_id, window)) } -/// Override of `[NSOpenGLView initWithFrame:pixelFormat:]`. -/// -/// - Chains up to `[super initWithFrame:frame pixelFormat:format]`. -/// - You can do additional initialization if needed. -extern "C" fn init_with_frame_pixel_format( - this: *mut Object, - _sel: Sel, - frame: NSRect, - format: *mut Object -) -> *mut Object { - unsafe { - // Call [super initWithFrame:frame pixelFormat:format] - let superclass = class!(NSOpenGLView); - let this: *mut Object = msg_send![super(this, superclass), - initWithFrame: frame - pixelFormat: format - ]; - // You could do more setup logic if `this` != null. - this +fn create_windows( + mtm: &MainThreadMarker, + app: &MacApp, + new: Vec, + any_opengl_class: &AnyClass, + any_menu_class: &AnyClass, +) { + for opts in new { + let w = create_nswindow( + &mtm, + opts, + &any_opengl_class, + &any_menu_class, + &app, + ); + + if let Ok((id, w)) = w { + if let Ok(mut lock) = app.data.lock() { + lock.windows.insert(id, w); + } + } + } +} + +fn destroy_windows( + app: &MacApp, + old: Vec +) { + for window in old { + let _ = app.data + .try_lock().ok() + .and_then(|s| { + s.windows.get(&window) + .and_then(|w| w.ns_window.as_ref()) + .map(|w| w.close()) + }); } } -/// Creates a custom subclass of `NSOpenGLView` and returns an instance of it, -/// storing `data` in an ivar so you can use it during drawing. -pub fn create_opengl_view(frame: NSRect, data: Arc>) -> id { // Retained +pub(crate) fn synchronize_window_state_with_os(window: &Window) { + // TODO: window.set_title +} + +fn create_observer( + center: &NSNotificationCenter, + name: &NSNotificationName, + handler: impl Fn(&NSNotification) + 'static, +) -> Retained> { + + let block = block2::RcBlock::new( + move |notification: NonNull| { + handler(unsafe { notification.as_ref() }); + } + ); + + // SAFETY: Per the docs, `addObserverForName:object:queue:usingBlock:` is safe as long as + // we keep the observer alive, which we do by storing it in our struct. unsafe { - // - // 1) Declare and register a new Objective-C class: "MyOpenGLView" - // - let superclass = class!(NSOpenGLView); + center.addObserverForName_object_queue_usingBlock( + Some(name), + None, // No sender filter + None, // No queue => use the posting thread + &block, + ) + } +} + + +// Creates a class as a subclass of NSOpenGLView, and registers a "megastruct" ivar, which +// holds a pointer to the NSObject +fn ns_opengl_class() -> ClassBuilder { - let c = CString::new("MyOpenGLView").unwrap(); - let mut decl = ClassDecl::new(&c.as_c_str(), superclass) - .expect("Failed to create ClassDecl for MyOpenGLView"); + let superclass = class!(NSOpenGLView); + let c = CString::new("AzulOpenGLView").unwrap(); + let mut decl = ClassDecl::new(&c.as_c_str(), superclass) + .expect("Failed to create ClassDecl for AzulOpenGLView"); - // We add an ivar to store an Arc> pointer. We can store any user data here. - let i = CString::new("myAppDataPointer").unwrap(); + unsafe { + + let i: CString = CString::new("app").unwrap(); decl.add_ivar::<*mut core::ffi::c_void>(&i.as_c_str()); + let i: CString = CString::new("windowid").unwrap(); + decl.add_ivar::(i.as_c_str()); - // Add method overrides decl.add_method( sel!(initWithFrame:pixelFormat:), init_with_frame_pixel_format as extern "C" fn(*mut Object, Sel, NSRect, *mut Object) -> *mut Object ); - decl.add_method(sel!(drawRect:), - draw_rect as extern "C" fn(*mut Object, Sel, NSRect) - ); - // Register the new class - let cls = decl.register(); + decl.add_method(sel!(drawRect:), draw_rect as extern "C" fn(*mut Object, Sel, NSRect)); + decl.add_method(sel!(mouseDown:), mouse_down as extern "C" fn(*mut Object, Sel, *mut Object)); + decl.add_method(sel!(mouseUp:), mouse_up as extern "C" fn(*mut Object, Sel, *mut Object)); + decl.add_method(sel!(mouseMoved:), mouse_moved as extern "C" fn(*mut Object, Sel, *mut Object)); + decl.add_method(sel!(scrollWheel:), scroll_wheel as extern "C" fn(*mut Object, Sel, *mut Object)); + decl.add_method(sel!(keyDown:), key_down as extern "C" fn(*mut Object, Sel, *mut Object)); + decl.add_method(sel!(keyUp:), key_up as extern "C" fn(*mut Object, Sel, *mut Object)); + } - // - // 2) Create an NSOpenGLPixelFormat for your desired settings - // + decl +} + +/// Creates a custom instance of the given `ns_opengl_view` class template, +/// storing a pointer to the `megaclass` inside the templates `app` field. +fn create_opengl_view( + frame: NSRect, + ns_opengl_view: &AnyClass, + megaclass: &MacApp, +) -> (WindowId, id) { // Retained + unsafe { + + let new_window_id = WindowId::new(); + + // 2) Create an NSOpenGLPixelFormat let attrs = [ objc2_app_kit::NSOpenGLPFAAccelerated, objc2_app_kit::NSOpenGLPFADoubleBuffer, @@ -192,7 +711,7 @@ pub fn create_opengl_view(frame: NSRect, data: Arc>) -> id { // R objc2_app_kit::NSOpenGLPFAStencilSize, 8, objc2_app_kit::NSOpenGLPFAOpenGLProfile, - objc2_app_kit::NSOpenGLProfileVersion3_2Core, + objc2_app_kit::NSOpenGLProfileVersion3_2Core, // <- use OpenGL 3.2 core 0, // terminator ]; @@ -203,52 +722,183 @@ pub fn create_opengl_view(frame: NSRect, data: Arc>) -> id { // R ]; assert!(!pixel_format.is_null(), "Failed to create NSOpenGLPixelFormat"); - // - // 3) Allocate and init our "MyOpenGLView" instance - // - let view: *mut Object = msg_send![cls, alloc]; + // 3) Allocate and init our "AzulOpenGLView" instance + let view: *mut Object = msg_send![ns_opengl_view, alloc]; let view: *mut Object = msg_send![view, initWithFrame: frame pixelFormat: pixel_format]; - assert!(!view.is_null(), "Failed to init MyOpenGLView"); + assert!(!view.is_null(), "Failed to init AzulOpenGLView"); - // Store Arc> pointer in the ivar - let ptr_to_appdata = Arc::into_raw(data) as *mut c_void; - *((*view).get_mut_ivar("myAppDataPointer")) = ptr_to_appdata; + *((*view).get_mut_ivar("app")) = megaclass as *const _ as *const c_void; + *((*view).get_mut_ivar("windowid")) = new_window_id.id; - // Tell the view to use best resolution (Retina) let _: () = msg_send![view, setWantsBestResolutionOpenGLSurface: YES]; - view + // On Mojave, views automatically become layer-backed shortly after being added to + // a window. Changing the layer-backedness of a view breaks the association between + // the view and its associated OpenGL context. To work around this, on Mojave we + // explicitly make the view layer-backed up front so that AppKit doesn't do it + // itself and break the association with its context. + if unsafe { NSAppKitVersionNumber }.floor() > NSAppKitVersionNumber10_12 { + let _: () = msg_send![view, setWantsLayer: YES]; + } + + (new_window_id, view) } } -/// Override of `[NSOpenGLView drawRect:]`. +/// Override of `[NSOpenGLView initWithFrame:pixelFormat:]`. /// -/// 1. Grab the pointer to `myAppDataPointer` and cast it back to `Arc>`. -/// 2. Make the current OpenGL context current. -/// 3. Perform any OpenGL calls. -/// 4. Flush buffers. -extern "C" fn draw_rect(this: *mut AnyObject, _sel: Sel, _dirty_rect: NSRect) { +/// - Chains up to `[super initWithFrame:frame pixelFormat:format]`. +extern "C" fn init_with_frame_pixel_format( + this: *mut Object, + _sel: Sel, + frame: NSRect, + format: *mut Object +) -> *mut Object { + unsafe { + // Call [super initWithFrame:frame pixelFormat:format] + let superclass = class!(NSOpenGLView); + let this: *mut Object = msg_send![super(this, superclass), + initWithFrame: frame + pixelFormat: format + ]; + + // You could do more setup logic if `this` != null. + this + } +} + +extern "C" +fn window_will_close(ptr: Arc>, window_id: WindowId, mtm: MainThreadMarker) { + + let mut app_data = match ptr.try_lock().ok() { + Some(s) => s, + None => { + // close notification can fire twice for the same window, + // could lead to deadlock, hence try_lock + return; + }, + }; + + app_data.windows.remove(&window_id); + if app_data.windows.is_empty() { + unsafe { objc2_app_kit::NSApplication::sharedApplication(mtm).terminate(None); } + } +} + +extern "C" +fn mouse_down(this: *mut Object, _sel: Sel, event: *mut Object) { + unsafe { + let ptr = (*this).get_ivar::<*const c_void>("app"); + let ptr = *ptr as *const MacApp; + let ptr = &*ptr; + let windowid = *(*this).get_ivar::("windowid"); + + if let Some(data) = ptr.data.lock().ok() { + // shared_data.process_mouse_down(); + println!("mouse down!"); + } + } +} + +extern "C" +fn mouse_up(this: *mut Object, _sel: Sel, event: *mut Object) { + unsafe { + let ptr = (*this).get_ivar::<*const c_void>("app"); + let ptr = *ptr as *const MacApp; + let ptr = &*ptr; + let windowid = *(*this).get_ivar::("windowid"); + + if let Some(data) = ptr.data.lock().ok() { + // shared_data.process_mouse_up(); + println!("mouse up!"); + } + } +} + +extern "C" +fn mouse_moved(this: *mut Object, _sel: Sel, event: *mut Object) { + unsafe { + let ptr = (*this).get_ivar::<*const c_void>("app"); + let ptr = *ptr as *const MacApp; + let ptr = &*ptr; + let windowid = *(*this).get_ivar::("windowid"); + + if let Some(data) = ptr.data.lock().ok() { + // shared_data.process_mouse_move(); + println!("mouse moved!"); + } + } +} + +extern "C" +fn scroll_wheel(this: *mut Object, _sel: Sel, event: *mut Object) { + unsafe { + let ptr = (*this).get_ivar::<*const c_void>("app"); + let ptr = *ptr as *const MacApp; + let ptr = &*ptr; + let windowid = *(*this).get_ivar::("windowid"); + + if let Some(data) = ptr.data.lock().ok() { + let delta_y: f64 = msg_send![event, scrollingDeltaY]; // deltaY, et.c + // data.process_scroll(delta_y as f32); + // [this setNeedsDisplay, YES] + println!("scrolled {delta_y}"); + } + } +} + +extern "C" +fn key_down(this: *mut Object, _sel: Sel, event: *mut Object) { + unsafe { + let ptr = (*this).get_ivar::<*const c_void>("app"); + let ptr = *ptr as *const MacApp; + let ptr = &*ptr; + let windowid = *(*this).get_ivar::("windowid"); + + if let Some(data) = ptr.data.lock().ok() { + // query [event keyCode], [event modifierFlags], etc. + // data.process_key_down(); + println!("key down"); + } + } +} + +extern "C" +fn key_up(this: *mut Object, _sel: Sel, event: *mut Object) { + unsafe { + let ptr = (*this).get_ivar::<*const c_void>("app"); + let ptr = *ptr as *const MacApp; + let ptr = &*ptr; + let windowid = *(*this).get_ivar::("windowid"); + + if let Some(data) = ptr.data.lock().ok() { + // data.process_key_up(); + println!("key up"); + } + } +} + +extern "C" +fn draw_rect(this: *mut AnyObject, _sel: Sel, _dirty_rect: NSRect) { unsafe { // Retrieve the pointer to our Arc> from the ivar - let ptr: &(*mut c_void) = (&*this).get_ivar("myAppDataPointer"); - let app_data: Arc> = Arc::from_raw(*ptr as *const _); - // Immediately turn it back into a raw pointer so we don't drop it - let _ = Arc::into_raw(app_data.clone()); + let ptr = (*this).get_ivar::<*const c_void>("app"); + let ptr = *ptr as *const MacApp; + let ptr = &*ptr; + let windowid = *(*this).get_ivar::("windowid"); - println!("draw rect: {}", app_data.lock().unwrap().test); + // REDRAWING: if the width / height of the window differ from the display list w / h, + // relayout the code here (yes, in the redrawing function) - // Obtain the OpenGL context let gl_context: *mut Object = msg_send![this, openGLContext]; - // Make it current let _: () = msg_send![gl_context, makeCurrentContext]; - // ---- Perform your GL calls here ---- - // e.g. clearing the screen, drawing geometry, etc. - // Clear the screen to green - glClearColor(0.0, 1.0, 0.0, 1.0); - glClear(GL_COLOR_BUFFER_BIT); + const GL_COLOR_BUFFER_BIT: u32 = 0x00004000; + ptr.functions.clear_color(0.0, 1.0, 0.0, 1.0); + ptr.functions.clear(GL_COLOR_BUFFER_BIT); + + println!("redrawing window {windowid}"); - // Swap buffers let _: () = msg_send![gl_context, flushBuffer]; } } diff --git a/azul-desktop/src/shell/mod.rs b/azul-desktop/src/shell/mod.rs index e33f2f9ed..4a4b4302c 100644 --- a/azul-desktop/src/shell/mod.rs +++ b/azul-desktop/src/shell/mod.rs @@ -1,6 +1,61 @@ +use azul_core::window::WindowCreateOptions; +use webrender::RendererOptions as WrRendererOptions; +use webrender::ProgramCache as WrProgramCache; +use webrender::ShaderPrecacheFlags as WrShaderPrecacheFlags; +use webrender::api::RenderNotifier as WrRenderNotifier; +use webrender::api::DocumentId as WrDocumentId; +use webrender::Shaders as WrShaders; +use std::rc::Rc; +use std::cell::RefCell; + +pub(crate) mod process; #[cfg(target_os = "windows")] pub mod win32; #[cfg(target_os = "linux")] pub mod x11; #[cfg(target_os = "macos")] -pub mod appkit; \ No newline at end of file +pub mod appkit; + +// TODO: Cache compiled shaders between renderers +const WR_SHADER_CACHE: Option<&Rc>> = None; + +fn default_renderer_options(options: &WindowCreateOptions) -> WrRendererOptions { + use crate::wr_translate::wr_translate_debug_flags; + WrRendererOptions { + resource_override_path: None, + use_optimized_shaders: true, + enable_aa: true, + enable_subpixel_aa: true, + force_subpixel_aa: true, + clear_color: webrender::api::ColorF { + r: 0.0, + g: 0.0, + b: 0.0, + a: 0.0, + }, // transparent + panic_on_gl_error: false, + precache_flags: WrShaderPrecacheFlags::EMPTY, + cached_programs: Some(WrProgramCache::new(None)), + enable_multithreading: true, + debug_flags: wr_translate_debug_flags(&options.state.debug_state), + ..WrRendererOptions::default() + } +} + +struct Notifier {} + +impl WrRenderNotifier for Notifier { + fn clone(&self) -> Box { + Box::new(Notifier {}) + } + fn wake_up(&self, composite_needed: bool) {} + fn new_frame_ready( + &self, + _: WrDocumentId, + _scrolled: bool, + composite_needed: bool, + _render_time: Option, + ) { + } +} + diff --git a/azul-desktop/src/shell/process.rs b/azul-desktop/src/shell/process.rs new file mode 100644 index 000000000..cfa8d2dc1 --- /dev/null +++ b/azul-desktop/src/shell/process.rs @@ -0,0 +1,340 @@ + +#[cfg(target_os = "macos")] +use crate::shell::appkit::Window; +#[cfg(target_os = "windows")] +use crate::shell::win32::Window; +use crate::{ + app::LazyFcCache, + wr_translate::wr_synchronize_updated_images +}; +use webrender::Transaction as WrTransaction; +use azul_core::{ + app_resources::{AppConfig, ImageCache}, + callbacks::{RefAny, Update}, + styled_dom::DomId, + ui_solver::LayoutResult, + window::{ + CallCallbacksResult, FullWindowState, ProcessEventResult, RawWindowHandle, WindowCreateOptions, WindowId + }, + window_state::{ + CallbacksOfHitTest, Events, NodesToCheck, StyleAndLayoutChanges + } +}; + +// Assuming that current_window_state and the previous_window_state of the window +// are set correctly and the hit-test has been performed, will call the callbacks +// and return what the application should do next +#[must_use] +pub(crate) fn process_event( + window_handle: &RawWindowHandle, + window: &mut Window, + fc_cache: &mut LazyFcCache, + image_cache: &mut ImageCache, + config: &AppConfig, + new_windows: &mut Vec, + destroyed_windows: &mut Vec, +) -> ProcessEventResult { + + // TODO: + // window.internal.current_window_state.monitor = + // win32_translate_monitor(MonitorFromWindow(window.hwnd, MONITOR_DEFAULTTONEAREST)); + + // Get events + let events = Events::new( + &window.internal.current_window_state, + &window.internal.previous_window_state, + ); + + // Get nodes for events + let nodes_to_check = NodesToCheck::new( + &window.internal.current_window_state.last_hit_test, + &events + ); + + // Invoke callbacks on nodes + let callback_result = fc_cache.apply_closure(|fc_cache| { + + // Get callbacks for nodes + let mut callbacks = CallbacksOfHitTest::new( + &nodes_to_check, + &events, + &window.internal.layout_results + ); + + let current_scroll_states = window.internal.get_current_scroll_states(); + + // Invoke user-defined callbacks in the UI + callbacks.call( + &window.internal.previous_window_state, + &window.internal.current_window_state, + &window_handle, + ¤t_scroll_states, + &window.gl_context_ptr, + &mut window.internal.layout_results, + &mut window.internal.scroll_states, + image_cache, + fc_cache, + &config.system_callbacks, + &window.internal.renderer_resources, + ) + }); + + return process_callback_results( + callback_result, + window, + &nodes_to_check, + image_cache, + fc_cache, + new_windows, + destroyed_windows + ); +} + +#[must_use] +pub(crate) fn process_timer( + timer_id: usize, + window_handle: &RawWindowHandle, + window: &mut Window, + fc_cache: &mut LazyFcCache, + image_cache: &mut ImageCache, + config: &AppConfig, + new_windows: &mut Vec, + destroyed_windows: &mut Vec +) -> ProcessEventResult { + + use azul_core::window::{RawWindowHandle, WindowsHandle}; + + let callback_result = fc_cache.apply_closure(|fc_cache| { + let frame_start = (config.system_callbacks.get_system_time_fn.cb)(); + window.internal.run_single_timer( + timer_id, + frame_start, + &window_handle, + &window.gl_context_ptr, + image_cache, + fc_cache, + &config.system_callbacks, + ) + }); + + return process_callback_results( + callback_result, + window, + &NodesToCheck::empty( + window.internal.current_window_state.mouse_state.mouse_down(), + window.internal.current_window_state.focused_node, + ), + image_cache, + fc_cache, + new_windows, + destroyed_windows + ); +} + +#[must_use] +pub(crate) fn process_threads( + window_handle: &RawWindowHandle, + data: &mut RefAny, + window: &mut Window, + fc_cache: &mut LazyFcCache, + image_cache: &mut ImageCache, + config: &AppConfig, + new_windows: &mut Vec, + destroyed_windows: &mut Vec +) -> ProcessEventResult { + + use azul_core::window::{RawWindowHandle, WindowsHandle}; + + let callback_result = fc_cache.apply_closure(|fc_cache| { + let frame_start = (config.system_callbacks.get_system_time_fn.cb)(); + window.internal.run_all_threads( + data, + &window_handle, + &window.gl_context_ptr, + image_cache, + fc_cache, + &config.system_callbacks, + ) + }); + + return process_callback_results( + callback_result, + window, + &NodesToCheck::empty( + window.internal.current_window_state.mouse_state.mouse_down(), + window.internal.current_window_state.focused_node, + ), + image_cache, + fc_cache, + new_windows, + destroyed_windows + ); +} + +#[must_use] +pub(crate) fn process_callback_results( + mut callback_results: CallCallbacksResult, + window: &mut Window, + nodes_to_check: &NodesToCheck, + image_cache: &mut ImageCache, + fc_cache: &mut LazyFcCache, + new_windows: &mut Vec, + destroyed_windows: &mut Vec, +) -> ProcessEventResult { + + use azul_core::callbacks::Update; + use azul_core::window_state::{StyleAndLayoutChanges, NodesToCheck}; + use crate::wr_translate::wr_translate_document_id; + + let mut result = ProcessEventResult::DoNothing; + + if callback_results.images_changed.is_some() || + callback_results.image_masks_changed.is_some() { + + let updated_images = window.internal.renderer_resources.update_image_resources( + &window.internal.layout_results, + callback_results.images_changed.unwrap_or_default(), + callback_results.image_masks_changed.unwrap_or_default(), + &crate::app::CALLBACKS, + &*image_cache, + &mut window.internal.gl_texture_cache, + window.internal.document_id, + window.internal.epoch, + ); + + if !updated_images.is_empty() { + let mut txn = WrTransaction::new(); + wr_synchronize_updated_images(updated_images, &window.internal.document_id, &mut txn); + window.render_api.send_transaction(wr_translate_document_id(window.internal.document_id), txn); + result = result.max_self(ProcessEventResult::ShouldReRenderCurrentWindow); + } + } + + window.start_stop_timers( + callback_results.timers.unwrap_or_default(), + callback_results.timers_removed.unwrap_or_default() + ); + window.start_stop_threads( + callback_results.threads.unwrap_or_default(), + callback_results.threads_removed.unwrap_or_default() + ); + + for w in callback_results.windows_created { + new_windows.push(w); + } + + let scroll = window.internal.current_window_state.process_system_scroll(&window.internal.scroll_states); + let need_scroll_render = scroll.is_some(); + + if let Some(modified) = callback_results.modified_window_state.as_ref() { + if modified.flags.is_about_to_close { + destroyed_windows.push(window.id.clone()); + } + window.internal.current_window_state = FullWindowState::from_window_state( + modified, + window.internal.current_window_state.dropped_file.clone(), + window.internal.current_window_state.hovered_file.clone(), + window.internal.current_window_state.focused_node.clone(), + window.internal.current_window_state.last_hit_test.clone(), + ); + if modified.size.get_layout_size() != window.internal.current_window_state.size.get_layout_size() { + result = result.max_self(ProcessEventResult::UpdateHitTesterAndProcessAgain); + } else if !need_scroll_render { + result = result.max_self(ProcessEventResult::ShouldReRenderCurrentWindow); + } + } + + #[cfg(target_os = "macos")] + crate::shell::appkit::synchronize_window_state_with_os(&window); + #[cfg(target_os = "windows")] + crate::shell::win32::synchronize_window_state_with_os(&window); + + let layout_callback_changed = window.internal.current_window_state.layout_callback_changed( + &window.internal.previous_window_state + ); + + if layout_callback_changed { + return ProcessEventResult::ShouldRegenerateDomCurrentWindow; + } else { + match callback_results.callbacks_update_screen { + Update::RefreshDom => { + return ProcessEventResult::ShouldRegenerateDomCurrentWindow; + }, + Update::RefreshDomAllWindows => { + return ProcessEventResult::ShouldRegenerateDomAllWindows; + }, + Update::DoNothing => { }, + } + } + + // Re-layout and re-style the window.internal.layout_results + let mut style_layout_changes = StyleAndLayoutChanges::new( + &nodes_to_check, + &mut window.internal.layout_results, + &image_cache, + &mut window.internal.renderer_resources, + window.internal.current_window_state.size.get_layout_size(), + &window.internal.document_id, + callback_results.css_properties_changed.as_ref(), + callback_results.words_changed.as_ref(), + &callback_results.update_focused_node, + azul_layout::do_the_relayout, + ); + + + if let Some(rsn) = style_layout_changes.nodes_that_changed_size.as_ref() { + + let updated_images = fc_cache.apply_closure(|fc_cache| { + LayoutResult::resize_images( + window.internal.id_namespace, + window.internal.document_id, + window.internal.epoch, + DomId::ROOT_ID, + &image_cache, + &window.gl_context_ptr, + &mut window.internal.layout_results, + &mut window.internal.gl_texture_cache, + &mut window.internal.renderer_resources, + &crate::app::CALLBACKS, + azul_layout::do_the_relayout, + fc_cache, + &window.internal.current_window_state.size, + window.internal.current_window_state.theme, + &rsn, + ) + }); + + if !updated_images.is_empty() { + let mut txn = WrTransaction::new(); + wr_synchronize_updated_images(updated_images, &window.internal.document_id, &mut txn); + window.render_api.send_transaction(wr_translate_document_id(window.internal.document_id), txn); + } + } + + // FOCUS CHANGE HAPPENS HERE! + if let Some(focus_change) = style_layout_changes.focus_change.clone() { + window.internal.current_window_state.focused_node = focus_change.new; + } + + // Perform a system or user scroll event: only + // scroll nodes that were not scrolled in the current frame + // + // Update the scroll states of the nodes, returning what nodes were actually scrolled this frame + if let Some(scroll) = scroll { + // Does a system scroll and re-invokes the IFrame + // callbacks if scrolled out of view + window.do_system_scroll(scroll); + window.internal.current_window_state.mouse_state.reset_scroll_to_zero(); + } + + if style_layout_changes.did_resize_nodes() { + // at least update the hit-tester + result.max_self(ProcessEventResult::UpdateHitTesterAndProcessAgain) + } else if style_layout_changes.need_regenerate_display_list() { + result.max_self(ProcessEventResult::ShouldUpdateDisplayListCurrentWindow) + } else if need_scroll_render || style_layout_changes.need_redraw() { + result.max_self(ProcessEventResult::ShouldReRenderCurrentWindow) + } else { + result + } +} \ No newline at end of file diff --git a/azul-desktop/src/shell/win32/gl.rs b/azul-desktop/src/shell/win32/gl.rs new file mode 100644 index 000000000..eb8bb036e --- /dev/null +++ b/azul-desktop/src/shell/win32/gl.rs @@ -0,0 +1,1085 @@ +use gl_context_loader::GenericGlContext; + +// OpenGL functions from wglGetProcAddress OR loaded from opengl32.dll +pub struct GlFunctions { + pub _opengl32_dll_handle: Option, + pub functions: Rc, // implements Rc! +} + +impl fmt::Debug for GlFunctions { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + self._opengl32_dll_handle.map(|f| f as usize).fmt(f)?; + Ok(()) + } +} + +impl GlFunctions { + // Initializes the DLL, but does not load the functions yet + fn initialize() -> Self { + // zero-initialize all function pointers + let context: GenericGlContext = unsafe { mem::zeroed() }; + + let opengl32_dll = load_dll("opengl32.dll"); + + Self { + _opengl32_dll_handle: opengl32_dll, + functions: Rc::new(context), + } + } + + // Assuming the OpenGL context is current, loads the OpenGL function pointers + fn load(&mut self) { + fn get_func(s: &str, opengl32_dll: Option) -> *mut gl_context_loader::c_void { + use winapi::um::{libloaderapi::GetProcAddress, wingdi::wglGetProcAddress}; + + let mut func_name = encode_ascii(s); + let addr1 = unsafe { wglGetProcAddress(func_name.as_mut_ptr()) }; + (if addr1 != ptr::null_mut() { + addr1 + } else { + if let Some(opengl32_dll) = opengl32_dll { + unsafe { GetProcAddress(opengl32_dll, func_name.as_mut_ptr()) } + } else { + addr1 + } + }) as *mut gl_context_loader::c_void + } + + self.functions = Rc::new(GenericGlContext { + glAccum: get_func("glAccum", self._opengl32_dll_handle), + glActiveTexture: get_func("glActiveTexture", self._opengl32_dll_handle), + glAlphaFunc: get_func("glAlphaFunc", self._opengl32_dll_handle), + glAreTexturesResident: get_func("glAreTexturesResident", self._opengl32_dll_handle), + glArrayElement: get_func("glArrayElement", self._opengl32_dll_handle), + glAttachShader: get_func("glAttachShader", self._opengl32_dll_handle), + glBegin: get_func("glBegin", self._opengl32_dll_handle), + glBeginConditionalRender: get_func( + "glBeginConditionalRender", + self._opengl32_dll_handle, + ), + glBeginQuery: get_func("glBeginQuery", self._opengl32_dll_handle), + glBeginTransformFeedback: get_func( + "glBeginTransformFeedback", + self._opengl32_dll_handle, + ), + glBindAttribLocation: get_func("glBindAttribLocation", self._opengl32_dll_handle), + glBindBuffer: get_func("glBindBuffer", self._opengl32_dll_handle), + glBindBufferBase: get_func("glBindBufferBase", self._opengl32_dll_handle), + glBindBufferRange: get_func("glBindBufferRange", self._opengl32_dll_handle), + glBindFragDataLocation: get_func("glBindFragDataLocation", self._opengl32_dll_handle), + glBindFragDataLocationIndexed: get_func( + "glBindFragDataLocationIndexed", + self._opengl32_dll_handle, + ), + glBindFramebuffer: get_func("glBindFramebuffer", self._opengl32_dll_handle), + glBindRenderbuffer: get_func("glBindRenderbuffer", self._opengl32_dll_handle), + glBindSampler: get_func("glBindSampler", self._opengl32_dll_handle), + glBindTexture: get_func("glBindTexture", self._opengl32_dll_handle), + glBindVertexArray: get_func("glBindVertexArray", self._opengl32_dll_handle), + glBindVertexArrayAPPLE: get_func("glBindVertexArrayAPPLE", self._opengl32_dll_handle), + glBitmap: get_func("glBitmap", self._opengl32_dll_handle), + glBlendBarrierKHR: get_func("glBlendBarrierKHR", self._opengl32_dll_handle), + glBlendColor: get_func("glBlendColor", self._opengl32_dll_handle), + glBlendEquation: get_func("glBlendEquation", self._opengl32_dll_handle), + glBlendEquationSeparate: get_func("glBlendEquationSeparate", self._opengl32_dll_handle), + glBlendFunc: get_func("glBlendFunc", self._opengl32_dll_handle), + glBlendFuncSeparate: get_func("glBlendFuncSeparate", self._opengl32_dll_handle), + glBlitFramebuffer: get_func("glBlitFramebuffer", self._opengl32_dll_handle), + glBufferData: get_func("glBufferData", self._opengl32_dll_handle), + glBufferStorage: get_func("glBufferStorage", self._opengl32_dll_handle), + glBufferSubData: get_func("glBufferSubData", self._opengl32_dll_handle), + glCallList: get_func("glCallList", self._opengl32_dll_handle), + glCallLists: get_func("glCallLists", self._opengl32_dll_handle), + glCheckFramebufferStatus: get_func( + "glCheckFramebufferStatus", + self._opengl32_dll_handle, + ), + glClampColor: get_func("glClampColor", self._opengl32_dll_handle), + glClear: get_func("glClear", self._opengl32_dll_handle), + glClearAccum: get_func("glClearAccum", self._opengl32_dll_handle), + glClearBufferfi: get_func("glClearBufferfi", self._opengl32_dll_handle), + glClearBufferfv: get_func("glClearBufferfv", self._opengl32_dll_handle), + glClearBufferiv: get_func("glClearBufferiv", self._opengl32_dll_handle), + glClearBufferuiv: get_func("glClearBufferuiv", self._opengl32_dll_handle), + glClearColor: get_func("glClearColor", self._opengl32_dll_handle), + glClearDepth: get_func("glClearDepth", self._opengl32_dll_handle), + glClearIndex: get_func("glClearIndex", self._opengl32_dll_handle), + glClearStencil: get_func("glClearStencil", self._opengl32_dll_handle), + glClientActiveTexture: get_func("glClientActiveTexture", self._opengl32_dll_handle), + glClientWaitSync: get_func("glClientWaitSync", self._opengl32_dll_handle), + glClipPlane: get_func("glClipPlane", self._opengl32_dll_handle), + glColor3b: get_func("glColor3b", self._opengl32_dll_handle), + glColor3bv: get_func("glColor3bv", self._opengl32_dll_handle), + glColor3d: get_func("glColor3d", self._opengl32_dll_handle), + glColor3dv: get_func("glColor3dv", self._opengl32_dll_handle), + glColor3f: get_func("glColor3f", self._opengl32_dll_handle), + glColor3fv: get_func("glColor3fv", self._opengl32_dll_handle), + glColor3i: get_func("glColor3i", self._opengl32_dll_handle), + glColor3iv: get_func("glColor3iv", self._opengl32_dll_handle), + glColor3s: get_func("glColor3s", self._opengl32_dll_handle), + glColor3sv: get_func("glColor3sv", self._opengl32_dll_handle), + glColor3ub: get_func("glColor3ub", self._opengl32_dll_handle), + glColor3ubv: get_func("glColor3ubv", self._opengl32_dll_handle), + glColor3ui: get_func("glColor3ui", self._opengl32_dll_handle), + glColor3uiv: get_func("glColor3uiv", self._opengl32_dll_handle), + glColor3us: get_func("glColor3us", self._opengl32_dll_handle), + glColor3usv: get_func("glColor3usv", self._opengl32_dll_handle), + glColor4b: get_func("glColor4b", self._opengl32_dll_handle), + glColor4bv: get_func("glColor4bv", self._opengl32_dll_handle), + glColor4d: get_func("glColor4d", self._opengl32_dll_handle), + glColor4dv: get_func("glColor4dv", self._opengl32_dll_handle), + glColor4f: get_func("glColor4f", self._opengl32_dll_handle), + glColor4fv: get_func("glColor4fv", self._opengl32_dll_handle), + glColor4i: get_func("glColor4i", self._opengl32_dll_handle), + glColor4iv: get_func("glColor4iv", self._opengl32_dll_handle), + glColor4s: get_func("glColor4s", self._opengl32_dll_handle), + glColor4sv: get_func("glColor4sv", self._opengl32_dll_handle), + glColor4ub: get_func("glColor4ub", self._opengl32_dll_handle), + glColor4ubv: get_func("glColor4ubv", self._opengl32_dll_handle), + glColor4ui: get_func("glColor4ui", self._opengl32_dll_handle), + glColor4uiv: get_func("glColor4uiv", self._opengl32_dll_handle), + glColor4us: get_func("glColor4us", self._opengl32_dll_handle), + glColor4usv: get_func("glColor4usv", self._opengl32_dll_handle), + glColorMask: get_func("glColorMask", self._opengl32_dll_handle), + glColorMaski: get_func("glColorMaski", self._opengl32_dll_handle), + glColorMaterial: get_func("glColorMaterial", self._opengl32_dll_handle), + glColorP3ui: get_func("glColorP3ui", self._opengl32_dll_handle), + glColorP3uiv: get_func("glColorP3uiv", self._opengl32_dll_handle), + glColorP4ui: get_func("glColorP4ui", self._opengl32_dll_handle), + glColorP4uiv: get_func("glColorP4uiv", self._opengl32_dll_handle), + glColorPointer: get_func("glColorPointer", self._opengl32_dll_handle), + glCompileShader: get_func("glCompileShader", self._opengl32_dll_handle), + glCompressedTexImage1D: get_func("glCompressedTexImage1D", self._opengl32_dll_handle), + glCompressedTexImage2D: get_func("glCompressedTexImage2D", self._opengl32_dll_handle), + glCompressedTexImage3D: get_func("glCompressedTexImage3D", self._opengl32_dll_handle), + glCompressedTexSubImage1D: get_func( + "glCompressedTexSubImage1D", + self._opengl32_dll_handle, + ), + glCompressedTexSubImage2D: get_func( + "glCompressedTexSubImage2D", + self._opengl32_dll_handle, + ), + glCompressedTexSubImage3D: get_func( + "glCompressedTexSubImage3D", + self._opengl32_dll_handle, + ), + glCopyBufferSubData: get_func("glCopyBufferSubData", self._opengl32_dll_handle), + glCopyImageSubData: get_func("glCopyImageSubData", self._opengl32_dll_handle), + glCopyPixels: get_func("glCopyPixels", self._opengl32_dll_handle), + glCopyTexImage1D: get_func("glCopyTexImage1D", self._opengl32_dll_handle), + glCopyTexImage2D: get_func("glCopyTexImage2D", self._opengl32_dll_handle), + glCopyTexSubImage1D: get_func("glCopyTexSubImage1D", self._opengl32_dll_handle), + glCopyTexSubImage2D: get_func("glCopyTexSubImage2D", self._opengl32_dll_handle), + glCopyTexSubImage3D: get_func("glCopyTexSubImage3D", self._opengl32_dll_handle), + glCreateProgram: get_func("glCreateProgram", self._opengl32_dll_handle), + glCreateShader: get_func("glCreateShader", self._opengl32_dll_handle), + glCullFace: get_func("glCullFace", self._opengl32_dll_handle), + glDebugMessageCallback: get_func("glDebugMessageCallback", self._opengl32_dll_handle), + glDebugMessageCallbackKHR: get_func( + "glDebugMessageCallbackKHR", + self._opengl32_dll_handle, + ), + glDebugMessageControl: get_func("glDebugMessageControl", self._opengl32_dll_handle), + glDebugMessageControlKHR: get_func( + "glDebugMessageControlKHR", + self._opengl32_dll_handle, + ), + glDebugMessageInsert: get_func("glDebugMessageInsert", self._opengl32_dll_handle), + glDebugMessageInsertKHR: get_func("glDebugMessageInsertKHR", self._opengl32_dll_handle), + glDeleteBuffers: get_func("glDeleteBuffers", self._opengl32_dll_handle), + glDeleteFencesAPPLE: get_func("glDeleteFencesAPPLE", self._opengl32_dll_handle), + glDeleteFramebuffers: get_func("glDeleteFramebuffers", self._opengl32_dll_handle), + glDeleteLists: get_func("glDeleteLists", self._opengl32_dll_handle), + glDeleteProgram: get_func("glDeleteProgram", self._opengl32_dll_handle), + glDeleteQueries: get_func("glDeleteQueries", self._opengl32_dll_handle), + glDeleteRenderbuffers: get_func("glDeleteRenderbuffers", self._opengl32_dll_handle), + glDeleteSamplers: get_func("glDeleteSamplers", self._opengl32_dll_handle), + glDeleteShader: get_func("glDeleteShader", self._opengl32_dll_handle), + glDeleteSync: get_func("glDeleteSync", self._opengl32_dll_handle), + glDeleteTextures: get_func("glDeleteTextures", self._opengl32_dll_handle), + glDeleteVertexArrays: get_func("glDeleteVertexArrays", self._opengl32_dll_handle), + glDeleteVertexArraysAPPLE: get_func( + "glDeleteVertexArraysAPPLE", + self._opengl32_dll_handle, + ), + glDepthFunc: get_func("glDepthFunc", self._opengl32_dll_handle), + glDepthMask: get_func("glDepthMask", self._opengl32_dll_handle), + glDepthRange: get_func("glDepthRange", self._opengl32_dll_handle), + glDetachShader: get_func("glDetachShader", self._opengl32_dll_handle), + glDisable: get_func("glDisable", self._opengl32_dll_handle), + glDisableClientState: get_func("glDisableClientState", self._opengl32_dll_handle), + glDisableVertexAttribArray: get_func( + "glDisableVertexAttribArray", + self._opengl32_dll_handle, + ), + glDisablei: get_func("glDisablei", self._opengl32_dll_handle), + glDrawArrays: get_func("glDrawArrays", self._opengl32_dll_handle), + glDrawArraysInstanced: get_func("glDrawArraysInstanced", self._opengl32_dll_handle), + glDrawBuffer: get_func("glDrawBuffer", self._opengl32_dll_handle), + glDrawBuffers: get_func("glDrawBuffers", self._opengl32_dll_handle), + glDrawElements: get_func("glDrawElements", self._opengl32_dll_handle), + glDrawElementsBaseVertex: get_func( + "glDrawElementsBaseVertex", + self._opengl32_dll_handle, + ), + glDrawElementsInstanced: get_func("glDrawElementsInstanced", self._opengl32_dll_handle), + glDrawElementsInstancedBaseVertex: get_func( + "glDrawElementsInstancedBaseVertex", + self._opengl32_dll_handle, + ), + glDrawPixels: get_func("glDrawPixels", self._opengl32_dll_handle), + glDrawRangeElements: get_func("glDrawRangeElements", self._opengl32_dll_handle), + glDrawRangeElementsBaseVertex: get_func( + "glDrawRangeElementsBaseVertex", + self._opengl32_dll_handle, + ), + glEdgeFlag: get_func("glEdgeFlag", self._opengl32_dll_handle), + glEdgeFlagPointer: get_func("glEdgeFlagPointer", self._opengl32_dll_handle), + glEdgeFlagv: get_func("glEdgeFlagv", self._opengl32_dll_handle), + glEnable: get_func("glEnable", self._opengl32_dll_handle), + glEnableClientState: get_func("glEnableClientState", self._opengl32_dll_handle), + glEnableVertexAttribArray: get_func( + "glEnableVertexAttribArray", + self._opengl32_dll_handle, + ), + glEnablei: get_func("glEnablei", self._opengl32_dll_handle), + glEnd: get_func("glEnd", self._opengl32_dll_handle), + glEndConditionalRender: get_func("glEndConditionalRender", self._opengl32_dll_handle), + glEndList: get_func("glEndList", self._opengl32_dll_handle), + glEndQuery: get_func("glEndQuery", self._opengl32_dll_handle), + glEndTransformFeedback: get_func("glEndTransformFeedback", self._opengl32_dll_handle), + glEvalCoord1d: get_func("glEvalCoord1d", self._opengl32_dll_handle), + glEvalCoord1dv: get_func("glEvalCoord1dv", self._opengl32_dll_handle), + glEvalCoord1f: get_func("glEvalCoord1f", self._opengl32_dll_handle), + glEvalCoord1fv: get_func("glEvalCoord1fv", self._opengl32_dll_handle), + glEvalCoord2d: get_func("glEvalCoord2d", self._opengl32_dll_handle), + glEvalCoord2dv: get_func("glEvalCoord2dv", self._opengl32_dll_handle), + glEvalCoord2f: get_func("glEvalCoord2f", self._opengl32_dll_handle), + glEvalCoord2fv: get_func("glEvalCoord2fv", self._opengl32_dll_handle), + glEvalMesh1: get_func("glEvalMesh1", self._opengl32_dll_handle), + glEvalMesh2: get_func("glEvalMesh2", self._opengl32_dll_handle), + glEvalPoint1: get_func("glEvalPoint1", self._opengl32_dll_handle), + glEvalPoint2: get_func("glEvalPoint2", self._opengl32_dll_handle), + glFeedbackBuffer: get_func("glFeedbackBuffer", self._opengl32_dll_handle), + glFenceSync: get_func("glFenceSync", self._opengl32_dll_handle), + glFinish: get_func("glFinish", self._opengl32_dll_handle), + glFinishFenceAPPLE: get_func("glFinishFenceAPPLE", self._opengl32_dll_handle), + glFinishObjectAPPLE: get_func("glFinishObjectAPPLE", self._opengl32_dll_handle), + glFlush: get_func("glFlush", self._opengl32_dll_handle), + glFlushMappedBufferRange: get_func( + "glFlushMappedBufferRange", + self._opengl32_dll_handle, + ), + glFogCoordPointer: get_func("glFogCoordPointer", self._opengl32_dll_handle), + glFogCoordd: get_func("glFogCoordd", self._opengl32_dll_handle), + glFogCoorddv: get_func("glFogCoorddv", self._opengl32_dll_handle), + glFogCoordf: get_func("glFogCoordf", self._opengl32_dll_handle), + glFogCoordfv: get_func("glFogCoordfv", self._opengl32_dll_handle), + glFogf: get_func("glFogf", self._opengl32_dll_handle), + glFogfv: get_func("glFogfv", self._opengl32_dll_handle), + glFogi: get_func("glFogi", self._opengl32_dll_handle), + glFogiv: get_func("glFogiv", self._opengl32_dll_handle), + glFramebufferRenderbuffer: get_func( + "glFramebufferRenderbuffer", + self._opengl32_dll_handle, + ), + glFramebufferTexture: get_func("glFramebufferTexture", self._opengl32_dll_handle), + glFramebufferTexture1D: get_func("glFramebufferTexture1D", self._opengl32_dll_handle), + glFramebufferTexture2D: get_func("glFramebufferTexture2D", self._opengl32_dll_handle), + glFramebufferTexture3D: get_func("glFramebufferTexture3D", self._opengl32_dll_handle), + glFramebufferTextureLayer: get_func( + "glFramebufferTextureLayer", + self._opengl32_dll_handle, + ), + glFrontFace: get_func("glFrontFace", self._opengl32_dll_handle), + glFrustum: get_func("glFrustum", self._opengl32_dll_handle), + glGenBuffers: get_func("glGenBuffers", self._opengl32_dll_handle), + glGenFencesAPPLE: get_func("glGenFencesAPPLE", self._opengl32_dll_handle), + glGenFramebuffers: get_func("glGenFramebuffers", self._opengl32_dll_handle), + glGenLists: get_func("glGenLists", self._opengl32_dll_handle), + glGenQueries: get_func("glGenQueries", self._opengl32_dll_handle), + glGenRenderbuffers: get_func("glGenRenderbuffers", self._opengl32_dll_handle), + glGenSamplers: get_func("glGenSamplers", self._opengl32_dll_handle), + glGenTextures: get_func("glGenTextures", self._opengl32_dll_handle), + glGenVertexArrays: get_func("glGenVertexArrays", self._opengl32_dll_handle), + glGenVertexArraysAPPLE: get_func("glGenVertexArraysAPPLE", self._opengl32_dll_handle), + glGenerateMipmap: get_func("glGenerateMipmap", self._opengl32_dll_handle), + glGetActiveAttrib: get_func("glGetActiveAttrib", self._opengl32_dll_handle), + glGetActiveUniform: get_func("glGetActiveUniform", self._opengl32_dll_handle), + glGetActiveUniformBlockName: get_func( + "glGetActiveUniformBlockName", + self._opengl32_dll_handle, + ), + glGetActiveUniformBlockiv: get_func( + "glGetActiveUniformBlockiv", + self._opengl32_dll_handle, + ), + glGetActiveUniformName: get_func("glGetActiveUniformName", self._opengl32_dll_handle), + glGetActiveUniformsiv: get_func("glGetActiveUniformsiv", self._opengl32_dll_handle), + glGetAttachedShaders: get_func("glGetAttachedShaders", self._opengl32_dll_handle), + glGetAttribLocation: get_func("glGetAttribLocation", self._opengl32_dll_handle), + glGetBooleani_v: get_func("glGetBooleani_v", self._opengl32_dll_handle), + glGetBooleanv: get_func("glGetBooleanv", self._opengl32_dll_handle), + glGetBufferParameteri64v: get_func( + "glGetBufferParameteri64v", + self._opengl32_dll_handle, + ), + glGetBufferParameteriv: get_func("glGetBufferParameteriv", self._opengl32_dll_handle), + glGetBufferPointerv: get_func("glGetBufferPointerv", self._opengl32_dll_handle), + glGetBufferSubData: get_func("glGetBufferSubData", self._opengl32_dll_handle), + glGetClipPlane: get_func("glGetClipPlane", self._opengl32_dll_handle), + glGetCompressedTexImage: get_func("glGetCompressedTexImage", self._opengl32_dll_handle), + glGetDebugMessageLog: get_func("glGetDebugMessageLog", self._opengl32_dll_handle), + glGetDebugMessageLogKHR: get_func("glGetDebugMessageLogKHR", self._opengl32_dll_handle), + glGetDoublev: get_func("glGetDoublev", self._opengl32_dll_handle), + glGetError: get_func("glGetError", self._opengl32_dll_handle), + glGetFloatv: get_func("glGetFloatv", self._opengl32_dll_handle), + glGetFragDataIndex: get_func("glGetFragDataIndex", self._opengl32_dll_handle), + glGetFragDataLocation: get_func("glGetFragDataLocation", self._opengl32_dll_handle), + glGetFramebufferAttachmentParameteriv: get_func( + "glGetFramebufferAttachmentParameteriv", + self._opengl32_dll_handle, + ), + glGetInteger64i_v: get_func("glGetInteger64i_v", self._opengl32_dll_handle), + glGetInteger64v: get_func("glGetInteger64v", self._opengl32_dll_handle), + glGetIntegeri_v: get_func("glGetIntegeri_v", self._opengl32_dll_handle), + glGetIntegerv: get_func("glGetIntegerv", self._opengl32_dll_handle), + glGetLightfv: get_func("glGetLightfv", self._opengl32_dll_handle), + glGetLightiv: get_func("glGetLightiv", self._opengl32_dll_handle), + glGetMapdv: get_func("glGetMapdv", self._opengl32_dll_handle), + glGetMapfv: get_func("glGetMapfv", self._opengl32_dll_handle), + glGetMapiv: get_func("glGetMapiv", self._opengl32_dll_handle), + glGetMaterialfv: get_func("glGetMaterialfv", self._opengl32_dll_handle), + glGetMaterialiv: get_func("glGetMaterialiv", self._opengl32_dll_handle), + glGetMultisamplefv: get_func("glGetMultisamplefv", self._opengl32_dll_handle), + glGetObjectLabel: get_func("glGetObjectLabel", self._opengl32_dll_handle), + glGetObjectLabelKHR: get_func("glGetObjectLabelKHR", self._opengl32_dll_handle), + glGetObjectPtrLabel: get_func("glGetObjectPtrLabel", self._opengl32_dll_handle), + glGetObjectPtrLabelKHR: get_func("glGetObjectPtrLabelKHR", self._opengl32_dll_handle), + glGetPixelMapfv: get_func("glGetPixelMapfv", self._opengl32_dll_handle), + glGetPixelMapuiv: get_func("glGetPixelMapuiv", self._opengl32_dll_handle), + glGetPixelMapusv: get_func("glGetPixelMapusv", self._opengl32_dll_handle), + glGetPointerv: get_func("glGetPointerv", self._opengl32_dll_handle), + glGetPointervKHR: get_func("glGetPointervKHR", self._opengl32_dll_handle), + glGetPolygonStipple: get_func("glGetPolygonStipple", self._opengl32_dll_handle), + glGetProgramBinary: get_func("glGetProgramBinary", self._opengl32_dll_handle), + glGetProgramInfoLog: get_func("glGetProgramInfoLog", self._opengl32_dll_handle), + glGetProgramiv: get_func("glGetProgramiv", self._opengl32_dll_handle), + glGetQueryObjecti64v: get_func("glGetQueryObjecti64v", self._opengl32_dll_handle), + glGetQueryObjectiv: get_func("glGetQueryObjectiv", self._opengl32_dll_handle), + glGetQueryObjectui64v: get_func("glGetQueryObjectui64v", self._opengl32_dll_handle), + glGetQueryObjectuiv: get_func("glGetQueryObjectuiv", self._opengl32_dll_handle), + glGetQueryiv: get_func("glGetQueryiv", self._opengl32_dll_handle), + glGetRenderbufferParameteriv: get_func( + "glGetRenderbufferParameteriv", + self._opengl32_dll_handle, + ), + glGetSamplerParameterIiv: get_func( + "glGetSamplerParameterIiv", + self._opengl32_dll_handle, + ), + glGetSamplerParameterIuiv: get_func( + "glGetSamplerParameterIuiv", + self._opengl32_dll_handle, + ), + glGetSamplerParameterfv: get_func("glGetSamplerParameterfv", self._opengl32_dll_handle), + glGetSamplerParameteriv: get_func("glGetSamplerParameteriv", self._opengl32_dll_handle), + glGetShaderInfoLog: get_func("glGetShaderInfoLog", self._opengl32_dll_handle), + glGetShaderSource: get_func("glGetShaderSource", self._opengl32_dll_handle), + glGetShaderiv: get_func("glGetShaderiv", self._opengl32_dll_handle), + glGetString: get_func("glGetString", self._opengl32_dll_handle), + glGetStringi: get_func("glGetStringi", self._opengl32_dll_handle), + glGetSynciv: get_func("glGetSynciv", self._opengl32_dll_handle), + glGetTexEnvfv: get_func("glGetTexEnvfv", self._opengl32_dll_handle), + glGetTexEnviv: get_func("glGetTexEnviv", self._opengl32_dll_handle), + glGetTexGendv: get_func("glGetTexGendv", self._opengl32_dll_handle), + glGetTexGenfv: get_func("glGetTexGenfv", self._opengl32_dll_handle), + glGetTexGeniv: get_func("glGetTexGeniv", self._opengl32_dll_handle), + glGetTexImage: get_func("glGetTexImage", self._opengl32_dll_handle), + glGetTexLevelParameterfv: get_func( + "glGetTexLevelParameterfv", + self._opengl32_dll_handle, + ), + glGetTexLevelParameteriv: get_func( + "glGetTexLevelParameteriv", + self._opengl32_dll_handle, + ), + glGetTexParameterIiv: get_func("glGetTexParameterIiv", self._opengl32_dll_handle), + glGetTexParameterIuiv: get_func("glGetTexParameterIuiv", self._opengl32_dll_handle), + glGetTexParameterPointervAPPLE: get_func( + "glGetTexParameterPointervAPPLE", + self._opengl32_dll_handle, + ), + glGetTexParameterfv: get_func("glGetTexParameterfv", self._opengl32_dll_handle), + glGetTexParameteriv: get_func("glGetTexParameteriv", self._opengl32_dll_handle), + glGetTransformFeedbackVarying: get_func( + "glGetTransformFeedbackVarying", + self._opengl32_dll_handle, + ), + glGetUniformBlockIndex: get_func("glGetUniformBlockIndex", self._opengl32_dll_handle), + glGetUniformIndices: get_func("glGetUniformIndices", self._opengl32_dll_handle), + glGetUniformLocation: get_func("glGetUniformLocation", self._opengl32_dll_handle), + glGetUniformfv: get_func("glGetUniformfv", self._opengl32_dll_handle), + glGetUniformiv: get_func("glGetUniformiv", self._opengl32_dll_handle), + glGetUniformuiv: get_func("glGetUniformuiv", self._opengl32_dll_handle), + glGetVertexAttribIiv: get_func("glGetVertexAttribIiv", self._opengl32_dll_handle), + glGetVertexAttribIuiv: get_func("glGetVertexAttribIuiv", self._opengl32_dll_handle), + glGetVertexAttribPointerv: get_func( + "glGetVertexAttribPointerv", + self._opengl32_dll_handle, + ), + glGetVertexAttribdv: get_func("glGetVertexAttribdv", self._opengl32_dll_handle), + glGetVertexAttribfv: get_func("glGetVertexAttribfv", self._opengl32_dll_handle), + glGetVertexAttribiv: get_func("glGetVertexAttribiv", self._opengl32_dll_handle), + glHint: get_func("glHint", self._opengl32_dll_handle), + glIndexMask: get_func("glIndexMask", self._opengl32_dll_handle), + glIndexPointer: get_func("glIndexPointer", self._opengl32_dll_handle), + glIndexd: get_func("glIndexd", self._opengl32_dll_handle), + glIndexdv: get_func("glIndexdv", self._opengl32_dll_handle), + glIndexf: get_func("glIndexf", self._opengl32_dll_handle), + glIndexfv: get_func("glIndexfv", self._opengl32_dll_handle), + glIndexi: get_func("glIndexi", self._opengl32_dll_handle), + glIndexiv: get_func("glIndexiv", self._opengl32_dll_handle), + glIndexs: get_func("glIndexs", self._opengl32_dll_handle), + glIndexsv: get_func("glIndexsv", self._opengl32_dll_handle), + glIndexub: get_func("glIndexub", self._opengl32_dll_handle), + glIndexubv: get_func("glIndexubv", self._opengl32_dll_handle), + glInitNames: get_func("glInitNames", self._opengl32_dll_handle), + glInsertEventMarkerEXT: get_func("glInsertEventMarkerEXT", self._opengl32_dll_handle), + glInterleavedArrays: get_func("glInterleavedArrays", self._opengl32_dll_handle), + glInvalidateBufferData: get_func("glInvalidateBufferData", self._opengl32_dll_handle), + glInvalidateBufferSubData: get_func( + "glInvalidateBufferSubData", + self._opengl32_dll_handle, + ), + glInvalidateFramebuffer: get_func("glInvalidateFramebuffer", self._opengl32_dll_handle), + glInvalidateSubFramebuffer: get_func( + "glInvalidateSubFramebuffer", + self._opengl32_dll_handle, + ), + glInvalidateTexImage: get_func("glInvalidateTexImage", self._opengl32_dll_handle), + glInvalidateTexSubImage: get_func("glInvalidateTexSubImage", self._opengl32_dll_handle), + glIsBuffer: get_func("glIsBuffer", self._opengl32_dll_handle), + glIsEnabled: get_func("glIsEnabled", self._opengl32_dll_handle), + glIsEnabledi: get_func("glIsEnabledi", self._opengl32_dll_handle), + glIsFenceAPPLE: get_func("glIsFenceAPPLE", self._opengl32_dll_handle), + glIsFramebuffer: get_func("glIsFramebuffer", self._opengl32_dll_handle), + glIsList: get_func("glIsList", self._opengl32_dll_handle), + glIsProgram: get_func("glIsProgram", self._opengl32_dll_handle), + glIsQuery: get_func("glIsQuery", self._opengl32_dll_handle), + glIsRenderbuffer: get_func("glIsRenderbuffer", self._opengl32_dll_handle), + glIsSampler: get_func("glIsSampler", self._opengl32_dll_handle), + glIsShader: get_func("glIsShader", self._opengl32_dll_handle), + glIsSync: get_func("glIsSync", self._opengl32_dll_handle), + glIsTexture: get_func("glIsTexture", self._opengl32_dll_handle), + glIsVertexArray: get_func("glIsVertexArray", self._opengl32_dll_handle), + glIsVertexArrayAPPLE: get_func("glIsVertexArrayAPPLE", self._opengl32_dll_handle), + glLightModelf: get_func("glLightModelf", self._opengl32_dll_handle), + glLightModelfv: get_func("glLightModelfv", self._opengl32_dll_handle), + glLightModeli: get_func("glLightModeli", self._opengl32_dll_handle), + glLightModeliv: get_func("glLightModeliv", self._opengl32_dll_handle), + glLightf: get_func("glLightf", self._opengl32_dll_handle), + glLightfv: get_func("glLightfv", self._opengl32_dll_handle), + glLighti: get_func("glLighti", self._opengl32_dll_handle), + glLightiv: get_func("glLightiv", self._opengl32_dll_handle), + glLineStipple: get_func("glLineStipple", self._opengl32_dll_handle), + glLineWidth: get_func("glLineWidth", self._opengl32_dll_handle), + glLinkProgram: get_func("glLinkProgram", self._opengl32_dll_handle), + glListBase: get_func("glListBase", self._opengl32_dll_handle), + glLoadIdentity: get_func("glLoadIdentity", self._opengl32_dll_handle), + glLoadMatrixd: get_func("glLoadMatrixd", self._opengl32_dll_handle), + glLoadMatrixf: get_func("glLoadMatrixf", self._opengl32_dll_handle), + glLoadName: get_func("glLoadName", self._opengl32_dll_handle), + glLoadTransposeMatrixd: get_func("glLoadTransposeMatrixd", self._opengl32_dll_handle), + glLoadTransposeMatrixf: get_func("glLoadTransposeMatrixf", self._opengl32_dll_handle), + glLogicOp: get_func("glLogicOp", self._opengl32_dll_handle), + glMap1d: get_func("glMap1d", self._opengl32_dll_handle), + glMap1f: get_func("glMap1f", self._opengl32_dll_handle), + glMap2d: get_func("glMap2d", self._opengl32_dll_handle), + glMap2f: get_func("glMap2f", self._opengl32_dll_handle), + glMapBuffer: get_func("glMapBuffer", self._opengl32_dll_handle), + glMapBufferRange: get_func("glMapBufferRange", self._opengl32_dll_handle), + glMapGrid1d: get_func("glMapGrid1d", self._opengl32_dll_handle), + glMapGrid1f: get_func("glMapGrid1f", self._opengl32_dll_handle), + glMapGrid2d: get_func("glMapGrid2d", self._opengl32_dll_handle), + glMapGrid2f: get_func("glMapGrid2f", self._opengl32_dll_handle), + glMaterialf: get_func("glMaterialf", self._opengl32_dll_handle), + glMaterialfv: get_func("glMaterialfv", self._opengl32_dll_handle), + glMateriali: get_func("glMateriali", self._opengl32_dll_handle), + glMaterialiv: get_func("glMaterialiv", self._opengl32_dll_handle), + glMatrixMode: get_func("glMatrixMode", self._opengl32_dll_handle), + glMultMatrixd: get_func("glMultMatrixd", self._opengl32_dll_handle), + glMultMatrixf: get_func("glMultMatrixf", self._opengl32_dll_handle), + glMultTransposeMatrixd: get_func("glMultTransposeMatrixd", self._opengl32_dll_handle), + glMultTransposeMatrixf: get_func("glMultTransposeMatrixf", self._opengl32_dll_handle), + glMultiDrawArrays: get_func("glMultiDrawArrays", self._opengl32_dll_handle), + glMultiDrawElements: get_func("glMultiDrawElements", self._opengl32_dll_handle), + glMultiDrawElementsBaseVertex: get_func( + "glMultiDrawElementsBaseVertex", + self._opengl32_dll_handle, + ), + glMultiTexCoord1d: get_func("glMultiTexCoord1d", self._opengl32_dll_handle), + glMultiTexCoord1dv: get_func("glMultiTexCoord1dv", self._opengl32_dll_handle), + glMultiTexCoord1f: get_func("glMultiTexCoord1f", self._opengl32_dll_handle), + glMultiTexCoord1fv: get_func("glMultiTexCoord1fv", self._opengl32_dll_handle), + glMultiTexCoord1i: get_func("glMultiTexCoord1i", self._opengl32_dll_handle), + glMultiTexCoord1iv: get_func("glMultiTexCoord1iv", self._opengl32_dll_handle), + glMultiTexCoord1s: get_func("glMultiTexCoord1s", self._opengl32_dll_handle), + glMultiTexCoord1sv: get_func("glMultiTexCoord1sv", self._opengl32_dll_handle), + glMultiTexCoord2d: get_func("glMultiTexCoord2d", self._opengl32_dll_handle), + glMultiTexCoord2dv: get_func("glMultiTexCoord2dv", self._opengl32_dll_handle), + glMultiTexCoord2f: get_func("glMultiTexCoord2f", self._opengl32_dll_handle), + glMultiTexCoord2fv: get_func("glMultiTexCoord2fv", self._opengl32_dll_handle), + glMultiTexCoord2i: get_func("glMultiTexCoord2i", self._opengl32_dll_handle), + glMultiTexCoord2iv: get_func("glMultiTexCoord2iv", self._opengl32_dll_handle), + glMultiTexCoord2s: get_func("glMultiTexCoord2s", self._opengl32_dll_handle), + glMultiTexCoord2sv: get_func("glMultiTexCoord2sv", self._opengl32_dll_handle), + glMultiTexCoord3d: get_func("glMultiTexCoord3d", self._opengl32_dll_handle), + glMultiTexCoord3dv: get_func("glMultiTexCoord3dv", self._opengl32_dll_handle), + glMultiTexCoord3f: get_func("glMultiTexCoord3f", self._opengl32_dll_handle), + glMultiTexCoord3fv: get_func("glMultiTexCoord3fv", self._opengl32_dll_handle), + glMultiTexCoord3i: get_func("glMultiTexCoord3i", self._opengl32_dll_handle), + glMultiTexCoord3iv: get_func("glMultiTexCoord3iv", self._opengl32_dll_handle), + glMultiTexCoord3s: get_func("glMultiTexCoord3s", self._opengl32_dll_handle), + glMultiTexCoord3sv: get_func("glMultiTexCoord3sv", self._opengl32_dll_handle), + glMultiTexCoord4d: get_func("glMultiTexCoord4d", self._opengl32_dll_handle), + glMultiTexCoord4dv: get_func("glMultiTexCoord4dv", self._opengl32_dll_handle), + glMultiTexCoord4f: get_func("glMultiTexCoord4f", self._opengl32_dll_handle), + glMultiTexCoord4fv: get_func("glMultiTexCoord4fv", self._opengl32_dll_handle), + glMultiTexCoord4i: get_func("glMultiTexCoord4i", self._opengl32_dll_handle), + glMultiTexCoord4iv: get_func("glMultiTexCoord4iv", self._opengl32_dll_handle), + glMultiTexCoord4s: get_func("glMultiTexCoord4s", self._opengl32_dll_handle), + glMultiTexCoord4sv: get_func("glMultiTexCoord4sv", self._opengl32_dll_handle), + glMultiTexCoordP1ui: get_func("glMultiTexCoordP1ui", self._opengl32_dll_handle), + glMultiTexCoordP1uiv: get_func("glMultiTexCoordP1uiv", self._opengl32_dll_handle), + glMultiTexCoordP2ui: get_func("glMultiTexCoordP2ui", self._opengl32_dll_handle), + glMultiTexCoordP2uiv: get_func("glMultiTexCoordP2uiv", self._opengl32_dll_handle), + glMultiTexCoordP3ui: get_func("glMultiTexCoordP3ui", self._opengl32_dll_handle), + glMultiTexCoordP3uiv: get_func("glMultiTexCoordP3uiv", self._opengl32_dll_handle), + glMultiTexCoordP4ui: get_func("glMultiTexCoordP4ui", self._opengl32_dll_handle), + glMultiTexCoordP4uiv: get_func("glMultiTexCoordP4uiv", self._opengl32_dll_handle), + glNewList: get_func("glNewList", self._opengl32_dll_handle), + glNormal3b: get_func("glNormal3b", self._opengl32_dll_handle), + glNormal3bv: get_func("glNormal3bv", self._opengl32_dll_handle), + glNormal3d: get_func("glNormal3d", self._opengl32_dll_handle), + glNormal3dv: get_func("glNormal3dv", self._opengl32_dll_handle), + glNormal3f: get_func("glNormal3f", self._opengl32_dll_handle), + glNormal3fv: get_func("glNormal3fv", self._opengl32_dll_handle), + glNormal3i: get_func("glNormal3i", self._opengl32_dll_handle), + glNormal3iv: get_func("glNormal3iv", self._opengl32_dll_handle), + glNormal3s: get_func("glNormal3s", self._opengl32_dll_handle), + glNormal3sv: get_func("glNormal3sv", self._opengl32_dll_handle), + glNormalP3ui: get_func("glNormalP3ui", self._opengl32_dll_handle), + glNormalP3uiv: get_func("glNormalP3uiv", self._opengl32_dll_handle), + glNormalPointer: get_func("glNormalPointer", self._opengl32_dll_handle), + glObjectLabel: get_func("glObjectLabel", self._opengl32_dll_handle), + glObjectLabelKHR: get_func("glObjectLabelKHR", self._opengl32_dll_handle), + glObjectPtrLabel: get_func("glObjectPtrLabel", self._opengl32_dll_handle), + glObjectPtrLabelKHR: get_func("glObjectPtrLabelKHR", self._opengl32_dll_handle), + glOrtho: get_func("glOrtho", self._opengl32_dll_handle), + glPassThrough: get_func("glPassThrough", self._opengl32_dll_handle), + glPixelMapfv: get_func("glPixelMapfv", self._opengl32_dll_handle), + glPixelMapuiv: get_func("glPixelMapuiv", self._opengl32_dll_handle), + glPixelMapusv: get_func("glPixelMapusv", self._opengl32_dll_handle), + glPixelStoref: get_func("glPixelStoref", self._opengl32_dll_handle), + glPixelStorei: get_func("glPixelStorei", self._opengl32_dll_handle), + glPixelTransferf: get_func("glPixelTransferf", self._opengl32_dll_handle), + glPixelTransferi: get_func("glPixelTransferi", self._opengl32_dll_handle), + glPixelZoom: get_func("glPixelZoom", self._opengl32_dll_handle), + glPointParameterf: get_func("glPointParameterf", self._opengl32_dll_handle), + glPointParameterfv: get_func("glPointParameterfv", self._opengl32_dll_handle), + glPointParameteri: get_func("glPointParameteri", self._opengl32_dll_handle), + glPointParameteriv: get_func("glPointParameteriv", self._opengl32_dll_handle), + glPointSize: get_func("glPointSize", self._opengl32_dll_handle), + glPolygonMode: get_func("glPolygonMode", self._opengl32_dll_handle), + glPolygonOffset: get_func("glPolygonOffset", self._opengl32_dll_handle), + glPolygonStipple: get_func("glPolygonStipple", self._opengl32_dll_handle), + glPopAttrib: get_func("glPopAttrib", self._opengl32_dll_handle), + glPopClientAttrib: get_func("glPopClientAttrib", self._opengl32_dll_handle), + glPopDebugGroup: get_func("glPopDebugGroup", self._opengl32_dll_handle), + glPopDebugGroupKHR: get_func("glPopDebugGroupKHR", self._opengl32_dll_handle), + glPopGroupMarkerEXT: get_func("glPopGroupMarkerEXT", self._opengl32_dll_handle), + glPopMatrix: get_func("glPopMatrix", self._opengl32_dll_handle), + glPopName: get_func("glPopName", self._opengl32_dll_handle), + glPrimitiveRestartIndex: get_func("glPrimitiveRestartIndex", self._opengl32_dll_handle), + glPrioritizeTextures: get_func("glPrioritizeTextures", self._opengl32_dll_handle), + glProgramBinary: get_func("glProgramBinary", self._opengl32_dll_handle), + glProgramParameteri: get_func("glProgramParameteri", self._opengl32_dll_handle), + glProvokingVertex: get_func("glProvokingVertex", self._opengl32_dll_handle), + glPushAttrib: get_func("glPushAttrib", self._opengl32_dll_handle), + glPushClientAttrib: get_func("glPushClientAttrib", self._opengl32_dll_handle), + glPushDebugGroup: get_func("glPushDebugGroup", self._opengl32_dll_handle), + glPushDebugGroupKHR: get_func("glPushDebugGroupKHR", self._opengl32_dll_handle), + glPushGroupMarkerEXT: get_func("glPushGroupMarkerEXT", self._opengl32_dll_handle), + glPushMatrix: get_func("glPushMatrix", self._opengl32_dll_handle), + glPushName: get_func("glPushName", self._opengl32_dll_handle), + glQueryCounter: get_func("glQueryCounter", self._opengl32_dll_handle), + glRasterPos2d: get_func("glRasterPos2d", self._opengl32_dll_handle), + glRasterPos2dv: get_func("glRasterPos2dv", self._opengl32_dll_handle), + glRasterPos2f: get_func("glRasterPos2f", self._opengl32_dll_handle), + glRasterPos2fv: get_func("glRasterPos2fv", self._opengl32_dll_handle), + glRasterPos2i: get_func("glRasterPos2i", self._opengl32_dll_handle), + glRasterPos2iv: get_func("glRasterPos2iv", self._opengl32_dll_handle), + glRasterPos2s: get_func("glRasterPos2s", self._opengl32_dll_handle), + glRasterPos2sv: get_func("glRasterPos2sv", self._opengl32_dll_handle), + glRasterPos3d: get_func("glRasterPos3d", self._opengl32_dll_handle), + glRasterPos3dv: get_func("glRasterPos3dv", self._opengl32_dll_handle), + glRasterPos3f: get_func("glRasterPos3f", self._opengl32_dll_handle), + glRasterPos3fv: get_func("glRasterPos3fv", self._opengl32_dll_handle), + glRasterPos3i: get_func("glRasterPos3i", self._opengl32_dll_handle), + glRasterPos3iv: get_func("glRasterPos3iv", self._opengl32_dll_handle), + glRasterPos3s: get_func("glRasterPos3s", self._opengl32_dll_handle), + glRasterPos3sv: get_func("glRasterPos3sv", self._opengl32_dll_handle), + glRasterPos4d: get_func("glRasterPos4d", self._opengl32_dll_handle), + glRasterPos4dv: get_func("glRasterPos4dv", self._opengl32_dll_handle), + glRasterPos4f: get_func("glRasterPos4f", self._opengl32_dll_handle), + glRasterPos4fv: get_func("glRasterPos4fv", self._opengl32_dll_handle), + glRasterPos4i: get_func("glRasterPos4i", self._opengl32_dll_handle), + glRasterPos4iv: get_func("glRasterPos4iv", self._opengl32_dll_handle), + glRasterPos4s: get_func("glRasterPos4s", self._opengl32_dll_handle), + glRasterPos4sv: get_func("glRasterPos4sv", self._opengl32_dll_handle), + glReadBuffer: get_func("glReadBuffer", self._opengl32_dll_handle), + glReadPixels: get_func("glReadPixels", self._opengl32_dll_handle), + glRectd: get_func("glRectd", self._opengl32_dll_handle), + glRectdv: get_func("glRectdv", self._opengl32_dll_handle), + glRectf: get_func("glRectf", self._opengl32_dll_handle), + glRectfv: get_func("glRectfv", self._opengl32_dll_handle), + glRecti: get_func("glRecti", self._opengl32_dll_handle), + glRectiv: get_func("glRectiv", self._opengl32_dll_handle), + glRects: get_func("glRects", self._opengl32_dll_handle), + glRectsv: get_func("glRectsv", self._opengl32_dll_handle), + glRenderMode: get_func("glRenderMode", self._opengl32_dll_handle), + glRenderbufferStorage: get_func("glRenderbufferStorage", self._opengl32_dll_handle), + glRenderbufferStorageMultisample: get_func( + "glRenderbufferStorageMultisample", + self._opengl32_dll_handle, + ), + glRotated: get_func("glRotated", self._opengl32_dll_handle), + glRotatef: get_func("glRotatef", self._opengl32_dll_handle), + glSampleCoverage: get_func("glSampleCoverage", self._opengl32_dll_handle), + glSampleMaski: get_func("glSampleMaski", self._opengl32_dll_handle), + glSamplerParameterIiv: get_func("glSamplerParameterIiv", self._opengl32_dll_handle), + glSamplerParameterIuiv: get_func("glSamplerParameterIuiv", self._opengl32_dll_handle), + glSamplerParameterf: get_func("glSamplerParameterf", self._opengl32_dll_handle), + glSamplerParameterfv: get_func("glSamplerParameterfv", self._opengl32_dll_handle), + glSamplerParameteri: get_func("glSamplerParameteri", self._opengl32_dll_handle), + glSamplerParameteriv: get_func("glSamplerParameteriv", self._opengl32_dll_handle), + glScaled: get_func("glScaled", self._opengl32_dll_handle), + glScalef: get_func("glScalef", self._opengl32_dll_handle), + glScissor: get_func("glScissor", self._opengl32_dll_handle), + glSecondaryColor3b: get_func("glSecondaryColor3b", self._opengl32_dll_handle), + glSecondaryColor3bv: get_func("glSecondaryColor3bv", self._opengl32_dll_handle), + glSecondaryColor3d: get_func("glSecondaryColor3d", self._opengl32_dll_handle), + glSecondaryColor3dv: get_func("glSecondaryColor3dv", self._opengl32_dll_handle), + glSecondaryColor3f: get_func("glSecondaryColor3f", self._opengl32_dll_handle), + glSecondaryColor3fv: get_func("glSecondaryColor3fv", self._opengl32_dll_handle), + glSecondaryColor3i: get_func("glSecondaryColor3i", self._opengl32_dll_handle), + glSecondaryColor3iv: get_func("glSecondaryColor3iv", self._opengl32_dll_handle), + glSecondaryColor3s: get_func("glSecondaryColor3s", self._opengl32_dll_handle), + glSecondaryColor3sv: get_func("glSecondaryColor3sv", self._opengl32_dll_handle), + glSecondaryColor3ub: get_func("glSecondaryColor3ub", self._opengl32_dll_handle), + glSecondaryColor3ubv: get_func("glSecondaryColor3ubv", self._opengl32_dll_handle), + glSecondaryColor3ui: get_func("glSecondaryColor3ui", self._opengl32_dll_handle), + glSecondaryColor3uiv: get_func("glSecondaryColor3uiv", self._opengl32_dll_handle), + glSecondaryColor3us: get_func("glSecondaryColor3us", self._opengl32_dll_handle), + glSecondaryColor3usv: get_func("glSecondaryColor3usv", self._opengl32_dll_handle), + glSecondaryColorP3ui: get_func("glSecondaryColorP3ui", self._opengl32_dll_handle), + glSecondaryColorP3uiv: get_func("glSecondaryColorP3uiv", self._opengl32_dll_handle), + glSecondaryColorPointer: get_func("glSecondaryColorPointer", self._opengl32_dll_handle), + glSelectBuffer: get_func("glSelectBuffer", self._opengl32_dll_handle), + glSetFenceAPPLE: get_func("glSetFenceAPPLE", self._opengl32_dll_handle), + glShadeModel: get_func("glShadeModel", self._opengl32_dll_handle), + glShaderSource: get_func("glShaderSource", self._opengl32_dll_handle), + glShaderStorageBlockBinding: get_func( + "glShaderStorageBlockBinding", + self._opengl32_dll_handle, + ), + glStencilFunc: get_func("glStencilFunc", self._opengl32_dll_handle), + glStencilFuncSeparate: get_func("glStencilFuncSeparate", self._opengl32_dll_handle), + glStencilMask: get_func("glStencilMask", self._opengl32_dll_handle), + glStencilMaskSeparate: get_func("glStencilMaskSeparate", self._opengl32_dll_handle), + glStencilOp: get_func("glStencilOp", self._opengl32_dll_handle), + glStencilOpSeparate: get_func("glStencilOpSeparate", self._opengl32_dll_handle), + glTestFenceAPPLE: get_func("glTestFenceAPPLE", self._opengl32_dll_handle), + glTestObjectAPPLE: get_func("glTestObjectAPPLE", self._opengl32_dll_handle), + glTexBuffer: get_func("glTexBuffer", self._opengl32_dll_handle), + glTexCoord1d: get_func("glTexCoord1d", self._opengl32_dll_handle), + glTexCoord1dv: get_func("glTexCoord1dv", self._opengl32_dll_handle), + glTexCoord1f: get_func("glTexCoord1f", self._opengl32_dll_handle), + glTexCoord1fv: get_func("glTexCoord1fv", self._opengl32_dll_handle), + glTexCoord1i: get_func("glTexCoord1i", self._opengl32_dll_handle), + glTexCoord1iv: get_func("glTexCoord1iv", self._opengl32_dll_handle), + glTexCoord1s: get_func("glTexCoord1s", self._opengl32_dll_handle), + glTexCoord1sv: get_func("glTexCoord1sv", self._opengl32_dll_handle), + glTexCoord2d: get_func("glTexCoord2d", self._opengl32_dll_handle), + glTexCoord2dv: get_func("glTexCoord2dv", self._opengl32_dll_handle), + glTexCoord2f: get_func("glTexCoord2f", self._opengl32_dll_handle), + glTexCoord2fv: get_func("glTexCoord2fv", self._opengl32_dll_handle), + glTexCoord2i: get_func("glTexCoord2i", self._opengl32_dll_handle), + glTexCoord2iv: get_func("glTexCoord2iv", self._opengl32_dll_handle), + glTexCoord2s: get_func("glTexCoord2s", self._opengl32_dll_handle), + glTexCoord2sv: get_func("glTexCoord2sv", self._opengl32_dll_handle), + glTexCoord3d: get_func("glTexCoord3d", self._opengl32_dll_handle), + glTexCoord3dv: get_func("glTexCoord3dv", self._opengl32_dll_handle), + glTexCoord3f: get_func("glTexCoord3f", self._opengl32_dll_handle), + glTexCoord3fv: get_func("glTexCoord3fv", self._opengl32_dll_handle), + glTexCoord3i: get_func("glTexCoord3i", self._opengl32_dll_handle), + glTexCoord3iv: get_func("glTexCoord3iv", self._opengl32_dll_handle), + glTexCoord3s: get_func("glTexCoord3s", self._opengl32_dll_handle), + glTexCoord3sv: get_func("glTexCoord3sv", self._opengl32_dll_handle), + glTexCoord4d: get_func("glTexCoord4d", self._opengl32_dll_handle), + glTexCoord4dv: get_func("glTexCoord4dv", self._opengl32_dll_handle), + glTexCoord4f: get_func("glTexCoord4f", self._opengl32_dll_handle), + glTexCoord4fv: get_func("glTexCoord4fv", self._opengl32_dll_handle), + glTexCoord4i: get_func("glTexCoord4i", self._opengl32_dll_handle), + glTexCoord4iv: get_func("glTexCoord4iv", self._opengl32_dll_handle), + glTexCoord4s: get_func("glTexCoord4s", self._opengl32_dll_handle), + glTexCoord4sv: get_func("glTexCoord4sv", self._opengl32_dll_handle), + glTexCoordP1ui: get_func("glTexCoordP1ui", self._opengl32_dll_handle), + glTexCoordP1uiv: get_func("glTexCoordP1uiv", self._opengl32_dll_handle), + glTexCoordP2ui: get_func("glTexCoordP2ui", self._opengl32_dll_handle), + glTexCoordP2uiv: get_func("glTexCoordP2uiv", self._opengl32_dll_handle), + glTexCoordP3ui: get_func("glTexCoordP3ui", self._opengl32_dll_handle), + glTexCoordP3uiv: get_func("glTexCoordP3uiv", self._opengl32_dll_handle), + glTexCoordP4ui: get_func("glTexCoordP4ui", self._opengl32_dll_handle), + glTexCoordP4uiv: get_func("glTexCoordP4uiv", self._opengl32_dll_handle), + glTexCoordPointer: get_func("glTexCoordPointer", self._opengl32_dll_handle), + glTexEnvf: get_func("glTexEnvf", self._opengl32_dll_handle), + glTexEnvfv: get_func("glTexEnvfv", self._opengl32_dll_handle), + glTexEnvi: get_func("glTexEnvi", self._opengl32_dll_handle), + glTexEnviv: get_func("glTexEnviv", self._opengl32_dll_handle), + glTexGend: get_func("glTexGend", self._opengl32_dll_handle), + glTexGendv: get_func("glTexGendv", self._opengl32_dll_handle), + glTexGenf: get_func("glTexGenf", self._opengl32_dll_handle), + glTexGenfv: get_func("glTexGenfv", self._opengl32_dll_handle), + glTexGeni: get_func("glTexGeni", self._opengl32_dll_handle), + glTexGeniv: get_func("glTexGeniv", self._opengl32_dll_handle), + glTexImage1D: get_func("glTexImage1D", self._opengl32_dll_handle), + glTexImage2D: get_func("glTexImage2D", self._opengl32_dll_handle), + glTexImage2DMultisample: get_func("glTexImage2DMultisample", self._opengl32_dll_handle), + glTexImage3D: get_func("glTexImage3D", self._opengl32_dll_handle), + glTexImage3DMultisample: get_func("glTexImage3DMultisample", self._opengl32_dll_handle), + glTexParameterIiv: get_func("glTexParameterIiv", self._opengl32_dll_handle), + glTexParameterIuiv: get_func("glTexParameterIuiv", self._opengl32_dll_handle), + glTexParameterf: get_func("glTexParameterf", self._opengl32_dll_handle), + glTexParameterfv: get_func("glTexParameterfv", self._opengl32_dll_handle), + glTexParameteri: get_func("glTexParameteri", self._opengl32_dll_handle), + glTexParameteriv: get_func("glTexParameteriv", self._opengl32_dll_handle), + glTexStorage1D: get_func("glTexStorage1D", self._opengl32_dll_handle), + glTexStorage2D: get_func("glTexStorage2D", self._opengl32_dll_handle), + glTexStorage3D: get_func("glTexStorage3D", self._opengl32_dll_handle), + glTexSubImage1D: get_func("glTexSubImage1D", self._opengl32_dll_handle), + glTexSubImage2D: get_func("glTexSubImage2D", self._opengl32_dll_handle), + glTexSubImage3D: get_func("glTexSubImage3D", self._opengl32_dll_handle), + glTextureRangeAPPLE: get_func("glTextureRangeAPPLE", self._opengl32_dll_handle), + glTransformFeedbackVaryings: get_func( + "glTransformFeedbackVaryings", + self._opengl32_dll_handle, + ), + glTranslated: get_func("glTranslated", self._opengl32_dll_handle), + glTranslatef: get_func("glTranslatef", self._opengl32_dll_handle), + glUniform1f: get_func("glUniform1f", self._opengl32_dll_handle), + glUniform1fv: get_func("glUniform1fv", self._opengl32_dll_handle), + glUniform1i: get_func("glUniform1i", self._opengl32_dll_handle), + glUniform1iv: get_func("glUniform1iv", self._opengl32_dll_handle), + glUniform1ui: get_func("glUniform1ui", self._opengl32_dll_handle), + glUniform1uiv: get_func("glUniform1uiv", self._opengl32_dll_handle), + glUniform2f: get_func("glUniform2f", self._opengl32_dll_handle), + glUniform2fv: get_func("glUniform2fv", self._opengl32_dll_handle), + glUniform2i: get_func("glUniform2i", self._opengl32_dll_handle), + glUniform2iv: get_func("glUniform2iv", self._opengl32_dll_handle), + glUniform2ui: get_func("glUniform2ui", self._opengl32_dll_handle), + glUniform2uiv: get_func("glUniform2uiv", self._opengl32_dll_handle), + glUniform3f: get_func("glUniform3f", self._opengl32_dll_handle), + glUniform3fv: get_func("glUniform3fv", self._opengl32_dll_handle), + glUniform3i: get_func("glUniform3i", self._opengl32_dll_handle), + glUniform3iv: get_func("glUniform3iv", self._opengl32_dll_handle), + glUniform3ui: get_func("glUniform3ui", self._opengl32_dll_handle), + glUniform3uiv: get_func("glUniform3uiv", self._opengl32_dll_handle), + glUniform4f: get_func("glUniform4f", self._opengl32_dll_handle), + glUniform4fv: get_func("glUniform4fv", self._opengl32_dll_handle), + glUniform4i: get_func("glUniform4i", self._opengl32_dll_handle), + glUniform4iv: get_func("glUniform4iv", self._opengl32_dll_handle), + glUniform4ui: get_func("glUniform4ui", self._opengl32_dll_handle), + glUniform4uiv: get_func("glUniform4uiv", self._opengl32_dll_handle), + glUniformBlockBinding: get_func("glUniformBlockBinding", self._opengl32_dll_handle), + glUniformMatrix2fv: get_func("glUniformMatrix2fv", self._opengl32_dll_handle), + glUniformMatrix2x3fv: get_func("glUniformMatrix2x3fv", self._opengl32_dll_handle), + glUniformMatrix2x4fv: get_func("glUniformMatrix2x4fv", self._opengl32_dll_handle), + glUniformMatrix3fv: get_func("glUniformMatrix3fv", self._opengl32_dll_handle), + glUniformMatrix3x2fv: get_func("glUniformMatrix3x2fv", self._opengl32_dll_handle), + glUniformMatrix3x4fv: get_func("glUniformMatrix3x4fv", self._opengl32_dll_handle), + glUniformMatrix4fv: get_func("glUniformMatrix4fv", self._opengl32_dll_handle), + glUniformMatrix4x2fv: get_func("glUniformMatrix4x2fv", self._opengl32_dll_handle), + glUniformMatrix4x3fv: get_func("glUniformMatrix4x3fv", self._opengl32_dll_handle), + glUnmapBuffer: get_func("glUnmapBuffer", self._opengl32_dll_handle), + glUseProgram: get_func("glUseProgram", self._opengl32_dll_handle), + glValidateProgram: get_func("glValidateProgram", self._opengl32_dll_handle), + glVertex2d: get_func("glVertex2d", self._opengl32_dll_handle), + glVertex2dv: get_func("glVertex2dv", self._opengl32_dll_handle), + glVertex2f: get_func("glVertex2f", self._opengl32_dll_handle), + glVertex2fv: get_func("glVertex2fv", self._opengl32_dll_handle), + glVertex2i: get_func("glVertex2i", self._opengl32_dll_handle), + glVertex2iv: get_func("glVertex2iv", self._opengl32_dll_handle), + glVertex2s: get_func("glVertex2s", self._opengl32_dll_handle), + glVertex2sv: get_func("glVertex2sv", self._opengl32_dll_handle), + glVertex3d: get_func("glVertex3d", self._opengl32_dll_handle), + glVertex3dv: get_func("glVertex3dv", self._opengl32_dll_handle), + glVertex3f: get_func("glVertex3f", self._opengl32_dll_handle), + glVertex3fv: get_func("glVertex3fv", self._opengl32_dll_handle), + glVertex3i: get_func("glVertex3i", self._opengl32_dll_handle), + glVertex3iv: get_func("glVertex3iv", self._opengl32_dll_handle), + glVertex3s: get_func("glVertex3s", self._opengl32_dll_handle), + glVertex3sv: get_func("glVertex3sv", self._opengl32_dll_handle), + glVertex4d: get_func("glVertex4d", self._opengl32_dll_handle), + glVertex4dv: get_func("glVertex4dv", self._opengl32_dll_handle), + glVertex4f: get_func("glVertex4f", self._opengl32_dll_handle), + glVertex4fv: get_func("glVertex4fv", self._opengl32_dll_handle), + glVertex4i: get_func("glVertex4i", self._opengl32_dll_handle), + glVertex4iv: get_func("glVertex4iv", self._opengl32_dll_handle), + glVertex4s: get_func("glVertex4s", self._opengl32_dll_handle), + glVertex4sv: get_func("glVertex4sv", self._opengl32_dll_handle), + glVertexAttrib1d: get_func("glVertexAttrib1d", self._opengl32_dll_handle), + glVertexAttrib1dv: get_func("glVertexAttrib1dv", self._opengl32_dll_handle), + glVertexAttrib1f: get_func("glVertexAttrib1f", self._opengl32_dll_handle), + glVertexAttrib1fv: get_func("glVertexAttrib1fv", self._opengl32_dll_handle), + glVertexAttrib1s: get_func("glVertexAttrib1s", self._opengl32_dll_handle), + glVertexAttrib1sv: get_func("glVertexAttrib1sv", self._opengl32_dll_handle), + glVertexAttrib2d: get_func("glVertexAttrib2d", self._opengl32_dll_handle), + glVertexAttrib2dv: get_func("glVertexAttrib2dv", self._opengl32_dll_handle), + glVertexAttrib2f: get_func("glVertexAttrib2f", self._opengl32_dll_handle), + glVertexAttrib2fv: get_func("glVertexAttrib2fv", self._opengl32_dll_handle), + glVertexAttrib2s: get_func("glVertexAttrib2s", self._opengl32_dll_handle), + glVertexAttrib2sv: get_func("glVertexAttrib2sv", self._opengl32_dll_handle), + glVertexAttrib3d: get_func("glVertexAttrib3d", self._opengl32_dll_handle), + glVertexAttrib3dv: get_func("glVertexAttrib3dv", self._opengl32_dll_handle), + glVertexAttrib3f: get_func("glVertexAttrib3f", self._opengl32_dll_handle), + glVertexAttrib3fv: get_func("glVertexAttrib3fv", self._opengl32_dll_handle), + glVertexAttrib3s: get_func("glVertexAttrib3s", self._opengl32_dll_handle), + glVertexAttrib3sv: get_func("glVertexAttrib3sv", self._opengl32_dll_handle), + glVertexAttrib4Nbv: get_func("glVertexAttrib4Nbv", self._opengl32_dll_handle), + glVertexAttrib4Niv: get_func("glVertexAttrib4Niv", self._opengl32_dll_handle), + glVertexAttrib4Nsv: get_func("glVertexAttrib4Nsv", self._opengl32_dll_handle), + glVertexAttrib4Nub: get_func("glVertexAttrib4Nub", self._opengl32_dll_handle), + glVertexAttrib4Nubv: get_func("glVertexAttrib4Nubv", self._opengl32_dll_handle), + glVertexAttrib4Nuiv: get_func("glVertexAttrib4Nuiv", self._opengl32_dll_handle), + glVertexAttrib4Nusv: get_func("glVertexAttrib4Nusv", self._opengl32_dll_handle), + glVertexAttrib4bv: get_func("glVertexAttrib4bv", self._opengl32_dll_handle), + glVertexAttrib4d: get_func("glVertexAttrib4d", self._opengl32_dll_handle), + glVertexAttrib4dv: get_func("glVertexAttrib4dv", self._opengl32_dll_handle), + glVertexAttrib4f: get_func("glVertexAttrib4f", self._opengl32_dll_handle), + glVertexAttrib4fv: get_func("glVertexAttrib4fv", self._opengl32_dll_handle), + glVertexAttrib4iv: get_func("glVertexAttrib4iv", self._opengl32_dll_handle), + glVertexAttrib4s: get_func("glVertexAttrib4s", self._opengl32_dll_handle), + glVertexAttrib4sv: get_func("glVertexAttrib4sv", self._opengl32_dll_handle), + glVertexAttrib4ubv: get_func("glVertexAttrib4ubv", self._opengl32_dll_handle), + glVertexAttrib4uiv: get_func("glVertexAttrib4uiv", self._opengl32_dll_handle), + glVertexAttrib4usv: get_func("glVertexAttrib4usv", self._opengl32_dll_handle), + glVertexAttribDivisor: get_func("glVertexAttribDivisor", self._opengl32_dll_handle), + glVertexAttribI1i: get_func("glVertexAttribI1i", self._opengl32_dll_handle), + glVertexAttribI1iv: get_func("glVertexAttribI1iv", self._opengl32_dll_handle), + glVertexAttribI1ui: get_func("glVertexAttribI1ui", self._opengl32_dll_handle), + glVertexAttribI1uiv: get_func("glVertexAttribI1uiv", self._opengl32_dll_handle), + glVertexAttribI2i: get_func("glVertexAttribI2i", self._opengl32_dll_handle), + glVertexAttribI2iv: get_func("glVertexAttribI2iv", self._opengl32_dll_handle), + glVertexAttribI2ui: get_func("glVertexAttribI2ui", self._opengl32_dll_handle), + glVertexAttribI2uiv: get_func("glVertexAttribI2uiv", self._opengl32_dll_handle), + glVertexAttribI3i: get_func("glVertexAttribI3i", self._opengl32_dll_handle), + glVertexAttribI3iv: get_func("glVertexAttribI3iv", self._opengl32_dll_handle), + glVertexAttribI3ui: get_func("glVertexAttribI3ui", self._opengl32_dll_handle), + glVertexAttribI3uiv: get_func("glVertexAttribI3uiv", self._opengl32_dll_handle), + glVertexAttribI4bv: get_func("glVertexAttribI4bv", self._opengl32_dll_handle), + glVertexAttribI4i: get_func("glVertexAttribI4i", self._opengl32_dll_handle), + glVertexAttribI4iv: get_func("glVertexAttribI4iv", self._opengl32_dll_handle), + glVertexAttribI4sv: get_func("glVertexAttribI4sv", self._opengl32_dll_handle), + glVertexAttribI4ubv: get_func("glVertexAttribI4ubv", self._opengl32_dll_handle), + glVertexAttribI4ui: get_func("glVertexAttribI4ui", self._opengl32_dll_handle), + glVertexAttribI4uiv: get_func("glVertexAttribI4uiv", self._opengl32_dll_handle), + glVertexAttribI4usv: get_func("glVertexAttribI4usv", self._opengl32_dll_handle), + glVertexAttribIPointer: get_func("glVertexAttribIPointer", self._opengl32_dll_handle), + glVertexAttribP1ui: get_func("glVertexAttribP1ui", self._opengl32_dll_handle), + glVertexAttribP1uiv: get_func("glVertexAttribP1uiv", self._opengl32_dll_handle), + glVertexAttribP2ui: get_func("glVertexAttribP2ui", self._opengl32_dll_handle), + glVertexAttribP2uiv: get_func("glVertexAttribP2uiv", self._opengl32_dll_handle), + glVertexAttribP3ui: get_func("glVertexAttribP3ui", self._opengl32_dll_handle), + glVertexAttribP3uiv: get_func("glVertexAttribP3uiv", self._opengl32_dll_handle), + glVertexAttribP4ui: get_func("glVertexAttribP4ui", self._opengl32_dll_handle), + glVertexAttribP4uiv: get_func("glVertexAttribP4uiv", self._opengl32_dll_handle), + glVertexAttribPointer: get_func("glVertexAttribPointer", self._opengl32_dll_handle), + glVertexP2ui: get_func("glVertexP2ui", self._opengl32_dll_handle), + glVertexP2uiv: get_func("glVertexP2uiv", self._opengl32_dll_handle), + glVertexP3ui: get_func("glVertexP3ui", self._opengl32_dll_handle), + glVertexP3uiv: get_func("glVertexP3uiv", self._opengl32_dll_handle), + glVertexP4ui: get_func("glVertexP4ui", self._opengl32_dll_handle), + glVertexP4uiv: get_func("glVertexP4uiv", self._opengl32_dll_handle), + glVertexPointer: get_func("glVertexPointer", self._opengl32_dll_handle), + glViewport: get_func("glViewport", self._opengl32_dll_handle), + glWaitSync: get_func("glWaitSync", self._opengl32_dll_handle), + glWindowPos2d: get_func("glWindowPos2d", self._opengl32_dll_handle), + glWindowPos2dv: get_func("glWindowPos2dv", self._opengl32_dll_handle), + glWindowPos2f: get_func("glWindowPos2f", self._opengl32_dll_handle), + glWindowPos2fv: get_func("glWindowPos2fv", self._opengl32_dll_handle), + glWindowPos2i: get_func("glWindowPos2i", self._opengl32_dll_handle), + glWindowPos2iv: get_func("glWindowPos2iv", self._opengl32_dll_handle), + glWindowPos2s: get_func("glWindowPos2s", self._opengl32_dll_handle), + glWindowPos2sv: get_func("glWindowPos2sv", self._opengl32_dll_handle), + glWindowPos3d: get_func("glWindowPos3d", self._opengl32_dll_handle), + glWindowPos3dv: get_func("glWindowPos3dv", self._opengl32_dll_handle), + glWindowPos3f: get_func("glWindowPos3f", self._opengl32_dll_handle), + glWindowPos3fv: get_func("glWindowPos3fv", self._opengl32_dll_handle), + glWindowPos3i: get_func("glWindowPos3i", self._opengl32_dll_handle), + glWindowPos3iv: get_func("glWindowPos3iv", self._opengl32_dll_handle), + glWindowPos3s: get_func("glWindowPos3s", self._opengl32_dll_handle), + glWindowPos3sv: get_func("glWindowPos3sv", self._opengl32_dll_handle), + }); + } +} + +impl Drop for GlFunctions { + fn drop(&mut self) { + use winapi::um::libloaderapi::FreeLibrary; + if let Some(opengl32) = self._opengl32_dll_handle { + unsafe { + FreeLibrary(opengl32); + } + } + } +} + +#[derive(Default)] +pub struct ExtraWglFunctions { + pub wglCreateContextAttribsARB: Option HGLRC>, + pub wglSwapIntervalEXT: Option i32>, + pub wglChoosePixelFormatARB: Option BOOL>, +} + +impl fmt::Debug for ExtraWglFunctions { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + self.wglCreateContextAttribsARB.map(|f| f as usize).fmt(f)?; + self.wglSwapIntervalEXT.map(|f| f as usize).fmt(f)?; + self.wglChoosePixelFormatARB.map(|f| f as usize).fmt(f)?; + Ok(()) + } +} + +#[derive(Debug, Copy, Clone)] +pub enum ExtraWglFunctionsLoadError { + FailedToCreateDummyWindow, + FailedToFindPixelFormat, + FailedToSetPixelFormat, + FailedToCreateDummyGlContext, + FailedToActivateDummyGlContext, +} + +impl ExtraWglFunctions { + pub fn load() -> Result { + + use winapi::um::{ + libloaderapi::GetModuleHandleW, + winuser::{ + CreateWindowExW, GetDC, + ReleaseDC, DestroyWindow, + CW_USEDEFAULT + }, + wingdi::{ + wglGetProcAddress, ChoosePixelFormat, + SetPixelFormat, wglCreateContext, + wglMakeCurrent, wglDeleteContext, + }, + }; + use self::ExtraWglFunctionsLoadError::*; + + unsafe { + + let mut hidden_class_name = encode_wide(CLASS_NAME); + let mut hidden_window_title = encode_wide("Dummy Window"); + + let dummy_window = CreateWindowExW( + 0, + hidden_class_name.as_mut_ptr(), + hidden_window_title.as_mut_ptr(), + 0, + CW_USEDEFAULT, + CW_USEDEFAULT, + CW_USEDEFAULT, + CW_USEDEFAULT, + ptr::null_mut(), + ptr::null_mut(), + GetModuleHandleW(ptr::null_mut()), + ptr::null_mut(), + ); + + if dummy_window.is_null() { + return Err(FailedToCreateDummyWindow); + } + + let dummy_dc = GetDC(dummy_window); + + let mut pfd = get_default_pfd(); + + let pixel_format = ChoosePixelFormat(dummy_dc, &pfd); + if pixel_format == 0 { + return Err(FailedToFindPixelFormat); + } + + if SetPixelFormat(dummy_dc, pixel_format, &pfd) != TRUE { + return Err(FailedToSetPixelFormat); + } + + let dummy_context = wglCreateContext(dummy_dc); + if dummy_context.is_null() { + return Err(FailedToCreateDummyGlContext); + } + + if wglMakeCurrent(dummy_dc, dummy_context) != TRUE { + return Err(FailedToActivateDummyGlContext); + } + + let mut extra_functions = ExtraWglFunctions::default(); + + extra_functions.wglChoosePixelFormatARB = { + let mut func_name_1 = encode_ascii("wglChoosePixelFormatARB"); + let mut func_name_2 = encode_ascii("wglChoosePixelFormatEXT"); + + let wgl1_result = unsafe { wglGetProcAddress(func_name_1.as_mut_ptr()) }; + let wgl2_result = unsafe { wglGetProcAddress(func_name_2.as_mut_ptr()) }; + + if wgl1_result != ptr::null_mut() { + Some(unsafe { mem::transmute(wgl1_result) }) + } else if wgl2_result != ptr::null_mut() { + Some(unsafe { mem::transmute(wgl2_result) }) + } else { + None + } + }; + + extra_functions.wglCreateContextAttribsARB = { + let mut func_name = encode_ascii("wglCreateContextAttribsARB"); + let proc_address = unsafe { wglGetProcAddress(func_name.as_mut_ptr()) }; + if proc_address == ptr::null_mut() { + None + } else { + Some(unsafe { mem::transmute(proc_address) }) + } + }; + + extra_functions.wglSwapIntervalEXT = { + let mut func_name = encode_ascii("wglSwapIntervalEXT"); + let proc_address = unsafe { wglGetProcAddress(func_name.as_mut_ptr()) }; + if proc_address == ptr::null_mut() { + None + } else { + Some(unsafe { mem::transmute(proc_address) }) + } + }; + + wglMakeCurrent(dummy_dc, ptr::null_mut()); + wglDeleteContext(dummy_context); + ReleaseDC(dummy_window, dummy_dc); + DestroyWindow(dummy_window); + + return Ok(extra_functions); + } + } +} diff --git a/azul-desktop/src/shell/win32/mod.rs b/azul-desktop/src/shell/win32/mod.rs index 401fa6049..c3c03baf8 100644 --- a/azul-desktop/src/shell/win32/mod.rs +++ b/azul-desktop/src/shell/win32/mod.rs @@ -6,6 +6,7 @@ mod event; mod dpi; +mod gl; use crate::{ app::{App, LazyFcCache}, @@ -44,7 +45,7 @@ use azul_core::{ LogicalSize, Menu, MenuCallback, MenuItem, MonitorVec, WindowCreateOptions, WindowInternal, WindowState, FullWindowState, ScrollResult, - MouseCursorType, CallCallbacksResult + MouseCursorType, CallCallbacksResult, ProcessEventResult, }, window_state::NodesToCheck, }; @@ -56,7 +57,6 @@ use core::{ mem, ptr, sync::atomic::{AtomicUsize, Ordering as AtomicOrdering}, }; -use gl_context_loader::GenericGlContext; use webrender::{ api::{ units::{ @@ -86,7 +86,9 @@ use winapi::{ um::winuser::WM_APP, }; use self::dpi::DpiFunctions; +use self::gl::{GlFunctions, ExtraWglFunctions, ExtraWglFunctionsLoadError}; use azul_css::FloatValue; +use super::Notifier; type TIMERPTR = winapi::shared::basetsd::UINT_PTR; @@ -102,8 +104,7 @@ const AZ_GPU_SCROLL_RENDER: u32 = WM_APP + 4; const CLASS_NAME: &str = "AzulApplicationClass"; -// TODO: Cache compiled shaders between renderers -const WR_SHADER_CACHE: Option<&Rc>> = None; +use super::WR_SHADER_CACHE; trait RectTrait { fn width(&self) -> u32; @@ -390,23 +391,6 @@ impl From for WindowsStartupError { } } -struct Notifier {} - -impl WrRenderNotifier for Notifier { - fn clone(&self) -> Box { - Box::new(Notifier {}) - } - fn wake_up(&self, composite_needed: bool) {} - fn new_frame_ready( - &self, - _: WrDocumentId, - _scrolled: bool, - composite_needed: bool, - _render_time: Option, - ) { - } -} - #[derive(Debug, Clone)] struct SharedApplicationData { inner: Rc>, @@ -497,1090 +481,6 @@ impl Drop for DwmFunctions { } } -// OpenGL functions from wglGetProcAddress OR loaded from opengl32.dll -struct GlFunctions { - _opengl32_dll_handle: Option, - functions: Rc, // implements Rc! -} - -impl fmt::Debug for GlFunctions { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - self._opengl32_dll_handle.map(|f| f as usize).fmt(f)?; - Ok(()) - } -} - -impl GlFunctions { - // Initializes the DLL, but does not load the functions yet - fn initialize() -> Self { - // zero-initialize all function pointers - let context: GenericGlContext = unsafe { mem::zeroed() }; - - let opengl32_dll = load_dll("opengl32.dll"); - - Self { - _opengl32_dll_handle: opengl32_dll, - functions: Rc::new(context), - } - } - - // Assuming the OpenGL context is current, loads the OpenGL function pointers - fn load(&mut self) { - fn get_func(s: &str, opengl32_dll: Option) -> *mut gl_context_loader::c_void { - use winapi::um::{libloaderapi::GetProcAddress, wingdi::wglGetProcAddress}; - - let mut func_name = encode_ascii(s); - let addr1 = unsafe { wglGetProcAddress(func_name.as_mut_ptr()) }; - (if addr1 != ptr::null_mut() { - addr1 - } else { - if let Some(opengl32_dll) = opengl32_dll { - unsafe { GetProcAddress(opengl32_dll, func_name.as_mut_ptr()) } - } else { - addr1 - } - }) as *mut gl_context_loader::c_void - } - - self.functions = Rc::new(GenericGlContext { - glAccum: get_func("glAccum", self._opengl32_dll_handle), - glActiveTexture: get_func("glActiveTexture", self._opengl32_dll_handle), - glAlphaFunc: get_func("glAlphaFunc", self._opengl32_dll_handle), - glAreTexturesResident: get_func("glAreTexturesResident", self._opengl32_dll_handle), - glArrayElement: get_func("glArrayElement", self._opengl32_dll_handle), - glAttachShader: get_func("glAttachShader", self._opengl32_dll_handle), - glBegin: get_func("glBegin", self._opengl32_dll_handle), - glBeginConditionalRender: get_func( - "glBeginConditionalRender", - self._opengl32_dll_handle, - ), - glBeginQuery: get_func("glBeginQuery", self._opengl32_dll_handle), - glBeginTransformFeedback: get_func( - "glBeginTransformFeedback", - self._opengl32_dll_handle, - ), - glBindAttribLocation: get_func("glBindAttribLocation", self._opengl32_dll_handle), - glBindBuffer: get_func("glBindBuffer", self._opengl32_dll_handle), - glBindBufferBase: get_func("glBindBufferBase", self._opengl32_dll_handle), - glBindBufferRange: get_func("glBindBufferRange", self._opengl32_dll_handle), - glBindFragDataLocation: get_func("glBindFragDataLocation", self._opengl32_dll_handle), - glBindFragDataLocationIndexed: get_func( - "glBindFragDataLocationIndexed", - self._opengl32_dll_handle, - ), - glBindFramebuffer: get_func("glBindFramebuffer", self._opengl32_dll_handle), - glBindRenderbuffer: get_func("glBindRenderbuffer", self._opengl32_dll_handle), - glBindSampler: get_func("glBindSampler", self._opengl32_dll_handle), - glBindTexture: get_func("glBindTexture", self._opengl32_dll_handle), - glBindVertexArray: get_func("glBindVertexArray", self._opengl32_dll_handle), - glBindVertexArrayAPPLE: get_func("glBindVertexArrayAPPLE", self._opengl32_dll_handle), - glBitmap: get_func("glBitmap", self._opengl32_dll_handle), - glBlendBarrierKHR: get_func("glBlendBarrierKHR", self._opengl32_dll_handle), - glBlendColor: get_func("glBlendColor", self._opengl32_dll_handle), - glBlendEquation: get_func("glBlendEquation", self._opengl32_dll_handle), - glBlendEquationSeparate: get_func("glBlendEquationSeparate", self._opengl32_dll_handle), - glBlendFunc: get_func("glBlendFunc", self._opengl32_dll_handle), - glBlendFuncSeparate: get_func("glBlendFuncSeparate", self._opengl32_dll_handle), - glBlitFramebuffer: get_func("glBlitFramebuffer", self._opengl32_dll_handle), - glBufferData: get_func("glBufferData", self._opengl32_dll_handle), - glBufferStorage: get_func("glBufferStorage", self._opengl32_dll_handle), - glBufferSubData: get_func("glBufferSubData", self._opengl32_dll_handle), - glCallList: get_func("glCallList", self._opengl32_dll_handle), - glCallLists: get_func("glCallLists", self._opengl32_dll_handle), - glCheckFramebufferStatus: get_func( - "glCheckFramebufferStatus", - self._opengl32_dll_handle, - ), - glClampColor: get_func("glClampColor", self._opengl32_dll_handle), - glClear: get_func("glClear", self._opengl32_dll_handle), - glClearAccum: get_func("glClearAccum", self._opengl32_dll_handle), - glClearBufferfi: get_func("glClearBufferfi", self._opengl32_dll_handle), - glClearBufferfv: get_func("glClearBufferfv", self._opengl32_dll_handle), - glClearBufferiv: get_func("glClearBufferiv", self._opengl32_dll_handle), - glClearBufferuiv: get_func("glClearBufferuiv", self._opengl32_dll_handle), - glClearColor: get_func("glClearColor", self._opengl32_dll_handle), - glClearDepth: get_func("glClearDepth", self._opengl32_dll_handle), - glClearIndex: get_func("glClearIndex", self._opengl32_dll_handle), - glClearStencil: get_func("glClearStencil", self._opengl32_dll_handle), - glClientActiveTexture: get_func("glClientActiveTexture", self._opengl32_dll_handle), - glClientWaitSync: get_func("glClientWaitSync", self._opengl32_dll_handle), - glClipPlane: get_func("glClipPlane", self._opengl32_dll_handle), - glColor3b: get_func("glColor3b", self._opengl32_dll_handle), - glColor3bv: get_func("glColor3bv", self._opengl32_dll_handle), - glColor3d: get_func("glColor3d", self._opengl32_dll_handle), - glColor3dv: get_func("glColor3dv", self._opengl32_dll_handle), - glColor3f: get_func("glColor3f", self._opengl32_dll_handle), - glColor3fv: get_func("glColor3fv", self._opengl32_dll_handle), - glColor3i: get_func("glColor3i", self._opengl32_dll_handle), - glColor3iv: get_func("glColor3iv", self._opengl32_dll_handle), - glColor3s: get_func("glColor3s", self._opengl32_dll_handle), - glColor3sv: get_func("glColor3sv", self._opengl32_dll_handle), - glColor3ub: get_func("glColor3ub", self._opengl32_dll_handle), - glColor3ubv: get_func("glColor3ubv", self._opengl32_dll_handle), - glColor3ui: get_func("glColor3ui", self._opengl32_dll_handle), - glColor3uiv: get_func("glColor3uiv", self._opengl32_dll_handle), - glColor3us: get_func("glColor3us", self._opengl32_dll_handle), - glColor3usv: get_func("glColor3usv", self._opengl32_dll_handle), - glColor4b: get_func("glColor4b", self._opengl32_dll_handle), - glColor4bv: get_func("glColor4bv", self._opengl32_dll_handle), - glColor4d: get_func("glColor4d", self._opengl32_dll_handle), - glColor4dv: get_func("glColor4dv", self._opengl32_dll_handle), - glColor4f: get_func("glColor4f", self._opengl32_dll_handle), - glColor4fv: get_func("glColor4fv", self._opengl32_dll_handle), - glColor4i: get_func("glColor4i", self._opengl32_dll_handle), - glColor4iv: get_func("glColor4iv", self._opengl32_dll_handle), - glColor4s: get_func("glColor4s", self._opengl32_dll_handle), - glColor4sv: get_func("glColor4sv", self._opengl32_dll_handle), - glColor4ub: get_func("glColor4ub", self._opengl32_dll_handle), - glColor4ubv: get_func("glColor4ubv", self._opengl32_dll_handle), - glColor4ui: get_func("glColor4ui", self._opengl32_dll_handle), - glColor4uiv: get_func("glColor4uiv", self._opengl32_dll_handle), - glColor4us: get_func("glColor4us", self._opengl32_dll_handle), - glColor4usv: get_func("glColor4usv", self._opengl32_dll_handle), - glColorMask: get_func("glColorMask", self._opengl32_dll_handle), - glColorMaski: get_func("glColorMaski", self._opengl32_dll_handle), - glColorMaterial: get_func("glColorMaterial", self._opengl32_dll_handle), - glColorP3ui: get_func("glColorP3ui", self._opengl32_dll_handle), - glColorP3uiv: get_func("glColorP3uiv", self._opengl32_dll_handle), - glColorP4ui: get_func("glColorP4ui", self._opengl32_dll_handle), - glColorP4uiv: get_func("glColorP4uiv", self._opengl32_dll_handle), - glColorPointer: get_func("glColorPointer", self._opengl32_dll_handle), - glCompileShader: get_func("glCompileShader", self._opengl32_dll_handle), - glCompressedTexImage1D: get_func("glCompressedTexImage1D", self._opengl32_dll_handle), - glCompressedTexImage2D: get_func("glCompressedTexImage2D", self._opengl32_dll_handle), - glCompressedTexImage3D: get_func("glCompressedTexImage3D", self._opengl32_dll_handle), - glCompressedTexSubImage1D: get_func( - "glCompressedTexSubImage1D", - self._opengl32_dll_handle, - ), - glCompressedTexSubImage2D: get_func( - "glCompressedTexSubImage2D", - self._opengl32_dll_handle, - ), - glCompressedTexSubImage3D: get_func( - "glCompressedTexSubImage3D", - self._opengl32_dll_handle, - ), - glCopyBufferSubData: get_func("glCopyBufferSubData", self._opengl32_dll_handle), - glCopyImageSubData: get_func("glCopyImageSubData", self._opengl32_dll_handle), - glCopyPixels: get_func("glCopyPixels", self._opengl32_dll_handle), - glCopyTexImage1D: get_func("glCopyTexImage1D", self._opengl32_dll_handle), - glCopyTexImage2D: get_func("glCopyTexImage2D", self._opengl32_dll_handle), - glCopyTexSubImage1D: get_func("glCopyTexSubImage1D", self._opengl32_dll_handle), - glCopyTexSubImage2D: get_func("glCopyTexSubImage2D", self._opengl32_dll_handle), - glCopyTexSubImage3D: get_func("glCopyTexSubImage3D", self._opengl32_dll_handle), - glCreateProgram: get_func("glCreateProgram", self._opengl32_dll_handle), - glCreateShader: get_func("glCreateShader", self._opengl32_dll_handle), - glCullFace: get_func("glCullFace", self._opengl32_dll_handle), - glDebugMessageCallback: get_func("glDebugMessageCallback", self._opengl32_dll_handle), - glDebugMessageCallbackKHR: get_func( - "glDebugMessageCallbackKHR", - self._opengl32_dll_handle, - ), - glDebugMessageControl: get_func("glDebugMessageControl", self._opengl32_dll_handle), - glDebugMessageControlKHR: get_func( - "glDebugMessageControlKHR", - self._opengl32_dll_handle, - ), - glDebugMessageInsert: get_func("glDebugMessageInsert", self._opengl32_dll_handle), - glDebugMessageInsertKHR: get_func("glDebugMessageInsertKHR", self._opengl32_dll_handle), - glDeleteBuffers: get_func("glDeleteBuffers", self._opengl32_dll_handle), - glDeleteFencesAPPLE: get_func("glDeleteFencesAPPLE", self._opengl32_dll_handle), - glDeleteFramebuffers: get_func("glDeleteFramebuffers", self._opengl32_dll_handle), - glDeleteLists: get_func("glDeleteLists", self._opengl32_dll_handle), - glDeleteProgram: get_func("glDeleteProgram", self._opengl32_dll_handle), - glDeleteQueries: get_func("glDeleteQueries", self._opengl32_dll_handle), - glDeleteRenderbuffers: get_func("glDeleteRenderbuffers", self._opengl32_dll_handle), - glDeleteSamplers: get_func("glDeleteSamplers", self._opengl32_dll_handle), - glDeleteShader: get_func("glDeleteShader", self._opengl32_dll_handle), - glDeleteSync: get_func("glDeleteSync", self._opengl32_dll_handle), - glDeleteTextures: get_func("glDeleteTextures", self._opengl32_dll_handle), - glDeleteVertexArrays: get_func("glDeleteVertexArrays", self._opengl32_dll_handle), - glDeleteVertexArraysAPPLE: get_func( - "glDeleteVertexArraysAPPLE", - self._opengl32_dll_handle, - ), - glDepthFunc: get_func("glDepthFunc", self._opengl32_dll_handle), - glDepthMask: get_func("glDepthMask", self._opengl32_dll_handle), - glDepthRange: get_func("glDepthRange", self._opengl32_dll_handle), - glDetachShader: get_func("glDetachShader", self._opengl32_dll_handle), - glDisable: get_func("glDisable", self._opengl32_dll_handle), - glDisableClientState: get_func("glDisableClientState", self._opengl32_dll_handle), - glDisableVertexAttribArray: get_func( - "glDisableVertexAttribArray", - self._opengl32_dll_handle, - ), - glDisablei: get_func("glDisablei", self._opengl32_dll_handle), - glDrawArrays: get_func("glDrawArrays", self._opengl32_dll_handle), - glDrawArraysInstanced: get_func("glDrawArraysInstanced", self._opengl32_dll_handle), - glDrawBuffer: get_func("glDrawBuffer", self._opengl32_dll_handle), - glDrawBuffers: get_func("glDrawBuffers", self._opengl32_dll_handle), - glDrawElements: get_func("glDrawElements", self._opengl32_dll_handle), - glDrawElementsBaseVertex: get_func( - "glDrawElementsBaseVertex", - self._opengl32_dll_handle, - ), - glDrawElementsInstanced: get_func("glDrawElementsInstanced", self._opengl32_dll_handle), - glDrawElementsInstancedBaseVertex: get_func( - "glDrawElementsInstancedBaseVertex", - self._opengl32_dll_handle, - ), - glDrawPixels: get_func("glDrawPixels", self._opengl32_dll_handle), - glDrawRangeElements: get_func("glDrawRangeElements", self._opengl32_dll_handle), - glDrawRangeElementsBaseVertex: get_func( - "glDrawRangeElementsBaseVertex", - self._opengl32_dll_handle, - ), - glEdgeFlag: get_func("glEdgeFlag", self._opengl32_dll_handle), - glEdgeFlagPointer: get_func("glEdgeFlagPointer", self._opengl32_dll_handle), - glEdgeFlagv: get_func("glEdgeFlagv", self._opengl32_dll_handle), - glEnable: get_func("glEnable", self._opengl32_dll_handle), - glEnableClientState: get_func("glEnableClientState", self._opengl32_dll_handle), - glEnableVertexAttribArray: get_func( - "glEnableVertexAttribArray", - self._opengl32_dll_handle, - ), - glEnablei: get_func("glEnablei", self._opengl32_dll_handle), - glEnd: get_func("glEnd", self._opengl32_dll_handle), - glEndConditionalRender: get_func("glEndConditionalRender", self._opengl32_dll_handle), - glEndList: get_func("glEndList", self._opengl32_dll_handle), - glEndQuery: get_func("glEndQuery", self._opengl32_dll_handle), - glEndTransformFeedback: get_func("glEndTransformFeedback", self._opengl32_dll_handle), - glEvalCoord1d: get_func("glEvalCoord1d", self._opengl32_dll_handle), - glEvalCoord1dv: get_func("glEvalCoord1dv", self._opengl32_dll_handle), - glEvalCoord1f: get_func("glEvalCoord1f", self._opengl32_dll_handle), - glEvalCoord1fv: get_func("glEvalCoord1fv", self._opengl32_dll_handle), - glEvalCoord2d: get_func("glEvalCoord2d", self._opengl32_dll_handle), - glEvalCoord2dv: get_func("glEvalCoord2dv", self._opengl32_dll_handle), - glEvalCoord2f: get_func("glEvalCoord2f", self._opengl32_dll_handle), - glEvalCoord2fv: get_func("glEvalCoord2fv", self._opengl32_dll_handle), - glEvalMesh1: get_func("glEvalMesh1", self._opengl32_dll_handle), - glEvalMesh2: get_func("glEvalMesh2", self._opengl32_dll_handle), - glEvalPoint1: get_func("glEvalPoint1", self._opengl32_dll_handle), - glEvalPoint2: get_func("glEvalPoint2", self._opengl32_dll_handle), - glFeedbackBuffer: get_func("glFeedbackBuffer", self._opengl32_dll_handle), - glFenceSync: get_func("glFenceSync", self._opengl32_dll_handle), - glFinish: get_func("glFinish", self._opengl32_dll_handle), - glFinishFenceAPPLE: get_func("glFinishFenceAPPLE", self._opengl32_dll_handle), - glFinishObjectAPPLE: get_func("glFinishObjectAPPLE", self._opengl32_dll_handle), - glFlush: get_func("glFlush", self._opengl32_dll_handle), - glFlushMappedBufferRange: get_func( - "glFlushMappedBufferRange", - self._opengl32_dll_handle, - ), - glFogCoordPointer: get_func("glFogCoordPointer", self._opengl32_dll_handle), - glFogCoordd: get_func("glFogCoordd", self._opengl32_dll_handle), - glFogCoorddv: get_func("glFogCoorddv", self._opengl32_dll_handle), - glFogCoordf: get_func("glFogCoordf", self._opengl32_dll_handle), - glFogCoordfv: get_func("glFogCoordfv", self._opengl32_dll_handle), - glFogf: get_func("glFogf", self._opengl32_dll_handle), - glFogfv: get_func("glFogfv", self._opengl32_dll_handle), - glFogi: get_func("glFogi", self._opengl32_dll_handle), - glFogiv: get_func("glFogiv", self._opengl32_dll_handle), - glFramebufferRenderbuffer: get_func( - "glFramebufferRenderbuffer", - self._opengl32_dll_handle, - ), - glFramebufferTexture: get_func("glFramebufferTexture", self._opengl32_dll_handle), - glFramebufferTexture1D: get_func("glFramebufferTexture1D", self._opengl32_dll_handle), - glFramebufferTexture2D: get_func("glFramebufferTexture2D", self._opengl32_dll_handle), - glFramebufferTexture3D: get_func("glFramebufferTexture3D", self._opengl32_dll_handle), - glFramebufferTextureLayer: get_func( - "glFramebufferTextureLayer", - self._opengl32_dll_handle, - ), - glFrontFace: get_func("glFrontFace", self._opengl32_dll_handle), - glFrustum: get_func("glFrustum", self._opengl32_dll_handle), - glGenBuffers: get_func("glGenBuffers", self._opengl32_dll_handle), - glGenFencesAPPLE: get_func("glGenFencesAPPLE", self._opengl32_dll_handle), - glGenFramebuffers: get_func("glGenFramebuffers", self._opengl32_dll_handle), - glGenLists: get_func("glGenLists", self._opengl32_dll_handle), - glGenQueries: get_func("glGenQueries", self._opengl32_dll_handle), - glGenRenderbuffers: get_func("glGenRenderbuffers", self._opengl32_dll_handle), - glGenSamplers: get_func("glGenSamplers", self._opengl32_dll_handle), - glGenTextures: get_func("glGenTextures", self._opengl32_dll_handle), - glGenVertexArrays: get_func("glGenVertexArrays", self._opengl32_dll_handle), - glGenVertexArraysAPPLE: get_func("glGenVertexArraysAPPLE", self._opengl32_dll_handle), - glGenerateMipmap: get_func("glGenerateMipmap", self._opengl32_dll_handle), - glGetActiveAttrib: get_func("glGetActiveAttrib", self._opengl32_dll_handle), - glGetActiveUniform: get_func("glGetActiveUniform", self._opengl32_dll_handle), - glGetActiveUniformBlockName: get_func( - "glGetActiveUniformBlockName", - self._opengl32_dll_handle, - ), - glGetActiveUniformBlockiv: get_func( - "glGetActiveUniformBlockiv", - self._opengl32_dll_handle, - ), - glGetActiveUniformName: get_func("glGetActiveUniformName", self._opengl32_dll_handle), - glGetActiveUniformsiv: get_func("glGetActiveUniformsiv", self._opengl32_dll_handle), - glGetAttachedShaders: get_func("glGetAttachedShaders", self._opengl32_dll_handle), - glGetAttribLocation: get_func("glGetAttribLocation", self._opengl32_dll_handle), - glGetBooleani_v: get_func("glGetBooleani_v", self._opengl32_dll_handle), - glGetBooleanv: get_func("glGetBooleanv", self._opengl32_dll_handle), - glGetBufferParameteri64v: get_func( - "glGetBufferParameteri64v", - self._opengl32_dll_handle, - ), - glGetBufferParameteriv: get_func("glGetBufferParameteriv", self._opengl32_dll_handle), - glGetBufferPointerv: get_func("glGetBufferPointerv", self._opengl32_dll_handle), - glGetBufferSubData: get_func("glGetBufferSubData", self._opengl32_dll_handle), - glGetClipPlane: get_func("glGetClipPlane", self._opengl32_dll_handle), - glGetCompressedTexImage: get_func("glGetCompressedTexImage", self._opengl32_dll_handle), - glGetDebugMessageLog: get_func("glGetDebugMessageLog", self._opengl32_dll_handle), - glGetDebugMessageLogKHR: get_func("glGetDebugMessageLogKHR", self._opengl32_dll_handle), - glGetDoublev: get_func("glGetDoublev", self._opengl32_dll_handle), - glGetError: get_func("glGetError", self._opengl32_dll_handle), - glGetFloatv: get_func("glGetFloatv", self._opengl32_dll_handle), - glGetFragDataIndex: get_func("glGetFragDataIndex", self._opengl32_dll_handle), - glGetFragDataLocation: get_func("glGetFragDataLocation", self._opengl32_dll_handle), - glGetFramebufferAttachmentParameteriv: get_func( - "glGetFramebufferAttachmentParameteriv", - self._opengl32_dll_handle, - ), - glGetInteger64i_v: get_func("glGetInteger64i_v", self._opengl32_dll_handle), - glGetInteger64v: get_func("glGetInteger64v", self._opengl32_dll_handle), - glGetIntegeri_v: get_func("glGetIntegeri_v", self._opengl32_dll_handle), - glGetIntegerv: get_func("glGetIntegerv", self._opengl32_dll_handle), - glGetLightfv: get_func("glGetLightfv", self._opengl32_dll_handle), - glGetLightiv: get_func("glGetLightiv", self._opengl32_dll_handle), - glGetMapdv: get_func("glGetMapdv", self._opengl32_dll_handle), - glGetMapfv: get_func("glGetMapfv", self._opengl32_dll_handle), - glGetMapiv: get_func("glGetMapiv", self._opengl32_dll_handle), - glGetMaterialfv: get_func("glGetMaterialfv", self._opengl32_dll_handle), - glGetMaterialiv: get_func("glGetMaterialiv", self._opengl32_dll_handle), - glGetMultisamplefv: get_func("glGetMultisamplefv", self._opengl32_dll_handle), - glGetObjectLabel: get_func("glGetObjectLabel", self._opengl32_dll_handle), - glGetObjectLabelKHR: get_func("glGetObjectLabelKHR", self._opengl32_dll_handle), - glGetObjectPtrLabel: get_func("glGetObjectPtrLabel", self._opengl32_dll_handle), - glGetObjectPtrLabelKHR: get_func("glGetObjectPtrLabelKHR", self._opengl32_dll_handle), - glGetPixelMapfv: get_func("glGetPixelMapfv", self._opengl32_dll_handle), - glGetPixelMapuiv: get_func("glGetPixelMapuiv", self._opengl32_dll_handle), - glGetPixelMapusv: get_func("glGetPixelMapusv", self._opengl32_dll_handle), - glGetPointerv: get_func("glGetPointerv", self._opengl32_dll_handle), - glGetPointervKHR: get_func("glGetPointervKHR", self._opengl32_dll_handle), - glGetPolygonStipple: get_func("glGetPolygonStipple", self._opengl32_dll_handle), - glGetProgramBinary: get_func("glGetProgramBinary", self._opengl32_dll_handle), - glGetProgramInfoLog: get_func("glGetProgramInfoLog", self._opengl32_dll_handle), - glGetProgramiv: get_func("glGetProgramiv", self._opengl32_dll_handle), - glGetQueryObjecti64v: get_func("glGetQueryObjecti64v", self._opengl32_dll_handle), - glGetQueryObjectiv: get_func("glGetQueryObjectiv", self._opengl32_dll_handle), - glGetQueryObjectui64v: get_func("glGetQueryObjectui64v", self._opengl32_dll_handle), - glGetQueryObjectuiv: get_func("glGetQueryObjectuiv", self._opengl32_dll_handle), - glGetQueryiv: get_func("glGetQueryiv", self._opengl32_dll_handle), - glGetRenderbufferParameteriv: get_func( - "glGetRenderbufferParameteriv", - self._opengl32_dll_handle, - ), - glGetSamplerParameterIiv: get_func( - "glGetSamplerParameterIiv", - self._opengl32_dll_handle, - ), - glGetSamplerParameterIuiv: get_func( - "glGetSamplerParameterIuiv", - self._opengl32_dll_handle, - ), - glGetSamplerParameterfv: get_func("glGetSamplerParameterfv", self._opengl32_dll_handle), - glGetSamplerParameteriv: get_func("glGetSamplerParameteriv", self._opengl32_dll_handle), - glGetShaderInfoLog: get_func("glGetShaderInfoLog", self._opengl32_dll_handle), - glGetShaderSource: get_func("glGetShaderSource", self._opengl32_dll_handle), - glGetShaderiv: get_func("glGetShaderiv", self._opengl32_dll_handle), - glGetString: get_func("glGetString", self._opengl32_dll_handle), - glGetStringi: get_func("glGetStringi", self._opengl32_dll_handle), - glGetSynciv: get_func("glGetSynciv", self._opengl32_dll_handle), - glGetTexEnvfv: get_func("glGetTexEnvfv", self._opengl32_dll_handle), - glGetTexEnviv: get_func("glGetTexEnviv", self._opengl32_dll_handle), - glGetTexGendv: get_func("glGetTexGendv", self._opengl32_dll_handle), - glGetTexGenfv: get_func("glGetTexGenfv", self._opengl32_dll_handle), - glGetTexGeniv: get_func("glGetTexGeniv", self._opengl32_dll_handle), - glGetTexImage: get_func("glGetTexImage", self._opengl32_dll_handle), - glGetTexLevelParameterfv: get_func( - "glGetTexLevelParameterfv", - self._opengl32_dll_handle, - ), - glGetTexLevelParameteriv: get_func( - "glGetTexLevelParameteriv", - self._opengl32_dll_handle, - ), - glGetTexParameterIiv: get_func("glGetTexParameterIiv", self._opengl32_dll_handle), - glGetTexParameterIuiv: get_func("glGetTexParameterIuiv", self._opengl32_dll_handle), - glGetTexParameterPointervAPPLE: get_func( - "glGetTexParameterPointervAPPLE", - self._opengl32_dll_handle, - ), - glGetTexParameterfv: get_func("glGetTexParameterfv", self._opengl32_dll_handle), - glGetTexParameteriv: get_func("glGetTexParameteriv", self._opengl32_dll_handle), - glGetTransformFeedbackVarying: get_func( - "glGetTransformFeedbackVarying", - self._opengl32_dll_handle, - ), - glGetUniformBlockIndex: get_func("glGetUniformBlockIndex", self._opengl32_dll_handle), - glGetUniformIndices: get_func("glGetUniformIndices", self._opengl32_dll_handle), - glGetUniformLocation: get_func("glGetUniformLocation", self._opengl32_dll_handle), - glGetUniformfv: get_func("glGetUniformfv", self._opengl32_dll_handle), - glGetUniformiv: get_func("glGetUniformiv", self._opengl32_dll_handle), - glGetUniformuiv: get_func("glGetUniformuiv", self._opengl32_dll_handle), - glGetVertexAttribIiv: get_func("glGetVertexAttribIiv", self._opengl32_dll_handle), - glGetVertexAttribIuiv: get_func("glGetVertexAttribIuiv", self._opengl32_dll_handle), - glGetVertexAttribPointerv: get_func( - "glGetVertexAttribPointerv", - self._opengl32_dll_handle, - ), - glGetVertexAttribdv: get_func("glGetVertexAttribdv", self._opengl32_dll_handle), - glGetVertexAttribfv: get_func("glGetVertexAttribfv", self._opengl32_dll_handle), - glGetVertexAttribiv: get_func("glGetVertexAttribiv", self._opengl32_dll_handle), - glHint: get_func("glHint", self._opengl32_dll_handle), - glIndexMask: get_func("glIndexMask", self._opengl32_dll_handle), - glIndexPointer: get_func("glIndexPointer", self._opengl32_dll_handle), - glIndexd: get_func("glIndexd", self._opengl32_dll_handle), - glIndexdv: get_func("glIndexdv", self._opengl32_dll_handle), - glIndexf: get_func("glIndexf", self._opengl32_dll_handle), - glIndexfv: get_func("glIndexfv", self._opengl32_dll_handle), - glIndexi: get_func("glIndexi", self._opengl32_dll_handle), - glIndexiv: get_func("glIndexiv", self._opengl32_dll_handle), - glIndexs: get_func("glIndexs", self._opengl32_dll_handle), - glIndexsv: get_func("glIndexsv", self._opengl32_dll_handle), - glIndexub: get_func("glIndexub", self._opengl32_dll_handle), - glIndexubv: get_func("glIndexubv", self._opengl32_dll_handle), - glInitNames: get_func("glInitNames", self._opengl32_dll_handle), - glInsertEventMarkerEXT: get_func("glInsertEventMarkerEXT", self._opengl32_dll_handle), - glInterleavedArrays: get_func("glInterleavedArrays", self._opengl32_dll_handle), - glInvalidateBufferData: get_func("glInvalidateBufferData", self._opengl32_dll_handle), - glInvalidateBufferSubData: get_func( - "glInvalidateBufferSubData", - self._opengl32_dll_handle, - ), - glInvalidateFramebuffer: get_func("glInvalidateFramebuffer", self._opengl32_dll_handle), - glInvalidateSubFramebuffer: get_func( - "glInvalidateSubFramebuffer", - self._opengl32_dll_handle, - ), - glInvalidateTexImage: get_func("glInvalidateTexImage", self._opengl32_dll_handle), - glInvalidateTexSubImage: get_func("glInvalidateTexSubImage", self._opengl32_dll_handle), - glIsBuffer: get_func("glIsBuffer", self._opengl32_dll_handle), - glIsEnabled: get_func("glIsEnabled", self._opengl32_dll_handle), - glIsEnabledi: get_func("glIsEnabledi", self._opengl32_dll_handle), - glIsFenceAPPLE: get_func("glIsFenceAPPLE", self._opengl32_dll_handle), - glIsFramebuffer: get_func("glIsFramebuffer", self._opengl32_dll_handle), - glIsList: get_func("glIsList", self._opengl32_dll_handle), - glIsProgram: get_func("glIsProgram", self._opengl32_dll_handle), - glIsQuery: get_func("glIsQuery", self._opengl32_dll_handle), - glIsRenderbuffer: get_func("glIsRenderbuffer", self._opengl32_dll_handle), - glIsSampler: get_func("glIsSampler", self._opengl32_dll_handle), - glIsShader: get_func("glIsShader", self._opengl32_dll_handle), - glIsSync: get_func("glIsSync", self._opengl32_dll_handle), - glIsTexture: get_func("glIsTexture", self._opengl32_dll_handle), - glIsVertexArray: get_func("glIsVertexArray", self._opengl32_dll_handle), - glIsVertexArrayAPPLE: get_func("glIsVertexArrayAPPLE", self._opengl32_dll_handle), - glLightModelf: get_func("glLightModelf", self._opengl32_dll_handle), - glLightModelfv: get_func("glLightModelfv", self._opengl32_dll_handle), - glLightModeli: get_func("glLightModeli", self._opengl32_dll_handle), - glLightModeliv: get_func("glLightModeliv", self._opengl32_dll_handle), - glLightf: get_func("glLightf", self._opengl32_dll_handle), - glLightfv: get_func("glLightfv", self._opengl32_dll_handle), - glLighti: get_func("glLighti", self._opengl32_dll_handle), - glLightiv: get_func("glLightiv", self._opengl32_dll_handle), - glLineStipple: get_func("glLineStipple", self._opengl32_dll_handle), - glLineWidth: get_func("glLineWidth", self._opengl32_dll_handle), - glLinkProgram: get_func("glLinkProgram", self._opengl32_dll_handle), - glListBase: get_func("glListBase", self._opengl32_dll_handle), - glLoadIdentity: get_func("glLoadIdentity", self._opengl32_dll_handle), - glLoadMatrixd: get_func("glLoadMatrixd", self._opengl32_dll_handle), - glLoadMatrixf: get_func("glLoadMatrixf", self._opengl32_dll_handle), - glLoadName: get_func("glLoadName", self._opengl32_dll_handle), - glLoadTransposeMatrixd: get_func("glLoadTransposeMatrixd", self._opengl32_dll_handle), - glLoadTransposeMatrixf: get_func("glLoadTransposeMatrixf", self._opengl32_dll_handle), - glLogicOp: get_func("glLogicOp", self._opengl32_dll_handle), - glMap1d: get_func("glMap1d", self._opengl32_dll_handle), - glMap1f: get_func("glMap1f", self._opengl32_dll_handle), - glMap2d: get_func("glMap2d", self._opengl32_dll_handle), - glMap2f: get_func("glMap2f", self._opengl32_dll_handle), - glMapBuffer: get_func("glMapBuffer", self._opengl32_dll_handle), - glMapBufferRange: get_func("glMapBufferRange", self._opengl32_dll_handle), - glMapGrid1d: get_func("glMapGrid1d", self._opengl32_dll_handle), - glMapGrid1f: get_func("glMapGrid1f", self._opengl32_dll_handle), - glMapGrid2d: get_func("glMapGrid2d", self._opengl32_dll_handle), - glMapGrid2f: get_func("glMapGrid2f", self._opengl32_dll_handle), - glMaterialf: get_func("glMaterialf", self._opengl32_dll_handle), - glMaterialfv: get_func("glMaterialfv", self._opengl32_dll_handle), - glMateriali: get_func("glMateriali", self._opengl32_dll_handle), - glMaterialiv: get_func("glMaterialiv", self._opengl32_dll_handle), - glMatrixMode: get_func("glMatrixMode", self._opengl32_dll_handle), - glMultMatrixd: get_func("glMultMatrixd", self._opengl32_dll_handle), - glMultMatrixf: get_func("glMultMatrixf", self._opengl32_dll_handle), - glMultTransposeMatrixd: get_func("glMultTransposeMatrixd", self._opengl32_dll_handle), - glMultTransposeMatrixf: get_func("glMultTransposeMatrixf", self._opengl32_dll_handle), - glMultiDrawArrays: get_func("glMultiDrawArrays", self._opengl32_dll_handle), - glMultiDrawElements: get_func("glMultiDrawElements", self._opengl32_dll_handle), - glMultiDrawElementsBaseVertex: get_func( - "glMultiDrawElementsBaseVertex", - self._opengl32_dll_handle, - ), - glMultiTexCoord1d: get_func("glMultiTexCoord1d", self._opengl32_dll_handle), - glMultiTexCoord1dv: get_func("glMultiTexCoord1dv", self._opengl32_dll_handle), - glMultiTexCoord1f: get_func("glMultiTexCoord1f", self._opengl32_dll_handle), - glMultiTexCoord1fv: get_func("glMultiTexCoord1fv", self._opengl32_dll_handle), - glMultiTexCoord1i: get_func("glMultiTexCoord1i", self._opengl32_dll_handle), - glMultiTexCoord1iv: get_func("glMultiTexCoord1iv", self._opengl32_dll_handle), - glMultiTexCoord1s: get_func("glMultiTexCoord1s", self._opengl32_dll_handle), - glMultiTexCoord1sv: get_func("glMultiTexCoord1sv", self._opengl32_dll_handle), - glMultiTexCoord2d: get_func("glMultiTexCoord2d", self._opengl32_dll_handle), - glMultiTexCoord2dv: get_func("glMultiTexCoord2dv", self._opengl32_dll_handle), - glMultiTexCoord2f: get_func("glMultiTexCoord2f", self._opengl32_dll_handle), - glMultiTexCoord2fv: get_func("glMultiTexCoord2fv", self._opengl32_dll_handle), - glMultiTexCoord2i: get_func("glMultiTexCoord2i", self._opengl32_dll_handle), - glMultiTexCoord2iv: get_func("glMultiTexCoord2iv", self._opengl32_dll_handle), - glMultiTexCoord2s: get_func("glMultiTexCoord2s", self._opengl32_dll_handle), - glMultiTexCoord2sv: get_func("glMultiTexCoord2sv", self._opengl32_dll_handle), - glMultiTexCoord3d: get_func("glMultiTexCoord3d", self._opengl32_dll_handle), - glMultiTexCoord3dv: get_func("glMultiTexCoord3dv", self._opengl32_dll_handle), - glMultiTexCoord3f: get_func("glMultiTexCoord3f", self._opengl32_dll_handle), - glMultiTexCoord3fv: get_func("glMultiTexCoord3fv", self._opengl32_dll_handle), - glMultiTexCoord3i: get_func("glMultiTexCoord3i", self._opengl32_dll_handle), - glMultiTexCoord3iv: get_func("glMultiTexCoord3iv", self._opengl32_dll_handle), - glMultiTexCoord3s: get_func("glMultiTexCoord3s", self._opengl32_dll_handle), - glMultiTexCoord3sv: get_func("glMultiTexCoord3sv", self._opengl32_dll_handle), - glMultiTexCoord4d: get_func("glMultiTexCoord4d", self._opengl32_dll_handle), - glMultiTexCoord4dv: get_func("glMultiTexCoord4dv", self._opengl32_dll_handle), - glMultiTexCoord4f: get_func("glMultiTexCoord4f", self._opengl32_dll_handle), - glMultiTexCoord4fv: get_func("glMultiTexCoord4fv", self._opengl32_dll_handle), - glMultiTexCoord4i: get_func("glMultiTexCoord4i", self._opengl32_dll_handle), - glMultiTexCoord4iv: get_func("glMultiTexCoord4iv", self._opengl32_dll_handle), - glMultiTexCoord4s: get_func("glMultiTexCoord4s", self._opengl32_dll_handle), - glMultiTexCoord4sv: get_func("glMultiTexCoord4sv", self._opengl32_dll_handle), - glMultiTexCoordP1ui: get_func("glMultiTexCoordP1ui", self._opengl32_dll_handle), - glMultiTexCoordP1uiv: get_func("glMultiTexCoordP1uiv", self._opengl32_dll_handle), - glMultiTexCoordP2ui: get_func("glMultiTexCoordP2ui", self._opengl32_dll_handle), - glMultiTexCoordP2uiv: get_func("glMultiTexCoordP2uiv", self._opengl32_dll_handle), - glMultiTexCoordP3ui: get_func("glMultiTexCoordP3ui", self._opengl32_dll_handle), - glMultiTexCoordP3uiv: get_func("glMultiTexCoordP3uiv", self._opengl32_dll_handle), - glMultiTexCoordP4ui: get_func("glMultiTexCoordP4ui", self._opengl32_dll_handle), - glMultiTexCoordP4uiv: get_func("glMultiTexCoordP4uiv", self._opengl32_dll_handle), - glNewList: get_func("glNewList", self._opengl32_dll_handle), - glNormal3b: get_func("glNormal3b", self._opengl32_dll_handle), - glNormal3bv: get_func("glNormal3bv", self._opengl32_dll_handle), - glNormal3d: get_func("glNormal3d", self._opengl32_dll_handle), - glNormal3dv: get_func("glNormal3dv", self._opengl32_dll_handle), - glNormal3f: get_func("glNormal3f", self._opengl32_dll_handle), - glNormal3fv: get_func("glNormal3fv", self._opengl32_dll_handle), - glNormal3i: get_func("glNormal3i", self._opengl32_dll_handle), - glNormal3iv: get_func("glNormal3iv", self._opengl32_dll_handle), - glNormal3s: get_func("glNormal3s", self._opengl32_dll_handle), - glNormal3sv: get_func("glNormal3sv", self._opengl32_dll_handle), - glNormalP3ui: get_func("glNormalP3ui", self._opengl32_dll_handle), - glNormalP3uiv: get_func("glNormalP3uiv", self._opengl32_dll_handle), - glNormalPointer: get_func("glNormalPointer", self._opengl32_dll_handle), - glObjectLabel: get_func("glObjectLabel", self._opengl32_dll_handle), - glObjectLabelKHR: get_func("glObjectLabelKHR", self._opengl32_dll_handle), - glObjectPtrLabel: get_func("glObjectPtrLabel", self._opengl32_dll_handle), - glObjectPtrLabelKHR: get_func("glObjectPtrLabelKHR", self._opengl32_dll_handle), - glOrtho: get_func("glOrtho", self._opengl32_dll_handle), - glPassThrough: get_func("glPassThrough", self._opengl32_dll_handle), - glPixelMapfv: get_func("glPixelMapfv", self._opengl32_dll_handle), - glPixelMapuiv: get_func("glPixelMapuiv", self._opengl32_dll_handle), - glPixelMapusv: get_func("glPixelMapusv", self._opengl32_dll_handle), - glPixelStoref: get_func("glPixelStoref", self._opengl32_dll_handle), - glPixelStorei: get_func("glPixelStorei", self._opengl32_dll_handle), - glPixelTransferf: get_func("glPixelTransferf", self._opengl32_dll_handle), - glPixelTransferi: get_func("glPixelTransferi", self._opengl32_dll_handle), - glPixelZoom: get_func("glPixelZoom", self._opengl32_dll_handle), - glPointParameterf: get_func("glPointParameterf", self._opengl32_dll_handle), - glPointParameterfv: get_func("glPointParameterfv", self._opengl32_dll_handle), - glPointParameteri: get_func("glPointParameteri", self._opengl32_dll_handle), - glPointParameteriv: get_func("glPointParameteriv", self._opengl32_dll_handle), - glPointSize: get_func("glPointSize", self._opengl32_dll_handle), - glPolygonMode: get_func("glPolygonMode", self._opengl32_dll_handle), - glPolygonOffset: get_func("glPolygonOffset", self._opengl32_dll_handle), - glPolygonStipple: get_func("glPolygonStipple", self._opengl32_dll_handle), - glPopAttrib: get_func("glPopAttrib", self._opengl32_dll_handle), - glPopClientAttrib: get_func("glPopClientAttrib", self._opengl32_dll_handle), - glPopDebugGroup: get_func("glPopDebugGroup", self._opengl32_dll_handle), - glPopDebugGroupKHR: get_func("glPopDebugGroupKHR", self._opengl32_dll_handle), - glPopGroupMarkerEXT: get_func("glPopGroupMarkerEXT", self._opengl32_dll_handle), - glPopMatrix: get_func("glPopMatrix", self._opengl32_dll_handle), - glPopName: get_func("glPopName", self._opengl32_dll_handle), - glPrimitiveRestartIndex: get_func("glPrimitiveRestartIndex", self._opengl32_dll_handle), - glPrioritizeTextures: get_func("glPrioritizeTextures", self._opengl32_dll_handle), - glProgramBinary: get_func("glProgramBinary", self._opengl32_dll_handle), - glProgramParameteri: get_func("glProgramParameteri", self._opengl32_dll_handle), - glProvokingVertex: get_func("glProvokingVertex", self._opengl32_dll_handle), - glPushAttrib: get_func("glPushAttrib", self._opengl32_dll_handle), - glPushClientAttrib: get_func("glPushClientAttrib", self._opengl32_dll_handle), - glPushDebugGroup: get_func("glPushDebugGroup", self._opengl32_dll_handle), - glPushDebugGroupKHR: get_func("glPushDebugGroupKHR", self._opengl32_dll_handle), - glPushGroupMarkerEXT: get_func("glPushGroupMarkerEXT", self._opengl32_dll_handle), - glPushMatrix: get_func("glPushMatrix", self._opengl32_dll_handle), - glPushName: get_func("glPushName", self._opengl32_dll_handle), - glQueryCounter: get_func("glQueryCounter", self._opengl32_dll_handle), - glRasterPos2d: get_func("glRasterPos2d", self._opengl32_dll_handle), - glRasterPos2dv: get_func("glRasterPos2dv", self._opengl32_dll_handle), - glRasterPos2f: get_func("glRasterPos2f", self._opengl32_dll_handle), - glRasterPos2fv: get_func("glRasterPos2fv", self._opengl32_dll_handle), - glRasterPos2i: get_func("glRasterPos2i", self._opengl32_dll_handle), - glRasterPos2iv: get_func("glRasterPos2iv", self._opengl32_dll_handle), - glRasterPos2s: get_func("glRasterPos2s", self._opengl32_dll_handle), - glRasterPos2sv: get_func("glRasterPos2sv", self._opengl32_dll_handle), - glRasterPos3d: get_func("glRasterPos3d", self._opengl32_dll_handle), - glRasterPos3dv: get_func("glRasterPos3dv", self._opengl32_dll_handle), - glRasterPos3f: get_func("glRasterPos3f", self._opengl32_dll_handle), - glRasterPos3fv: get_func("glRasterPos3fv", self._opengl32_dll_handle), - glRasterPos3i: get_func("glRasterPos3i", self._opengl32_dll_handle), - glRasterPos3iv: get_func("glRasterPos3iv", self._opengl32_dll_handle), - glRasterPos3s: get_func("glRasterPos3s", self._opengl32_dll_handle), - glRasterPos3sv: get_func("glRasterPos3sv", self._opengl32_dll_handle), - glRasterPos4d: get_func("glRasterPos4d", self._opengl32_dll_handle), - glRasterPos4dv: get_func("glRasterPos4dv", self._opengl32_dll_handle), - glRasterPos4f: get_func("glRasterPos4f", self._opengl32_dll_handle), - glRasterPos4fv: get_func("glRasterPos4fv", self._opengl32_dll_handle), - glRasterPos4i: get_func("glRasterPos4i", self._opengl32_dll_handle), - glRasterPos4iv: get_func("glRasterPos4iv", self._opengl32_dll_handle), - glRasterPos4s: get_func("glRasterPos4s", self._opengl32_dll_handle), - glRasterPos4sv: get_func("glRasterPos4sv", self._opengl32_dll_handle), - glReadBuffer: get_func("glReadBuffer", self._opengl32_dll_handle), - glReadPixels: get_func("glReadPixels", self._opengl32_dll_handle), - glRectd: get_func("glRectd", self._opengl32_dll_handle), - glRectdv: get_func("glRectdv", self._opengl32_dll_handle), - glRectf: get_func("glRectf", self._opengl32_dll_handle), - glRectfv: get_func("glRectfv", self._opengl32_dll_handle), - glRecti: get_func("glRecti", self._opengl32_dll_handle), - glRectiv: get_func("glRectiv", self._opengl32_dll_handle), - glRects: get_func("glRects", self._opengl32_dll_handle), - glRectsv: get_func("glRectsv", self._opengl32_dll_handle), - glRenderMode: get_func("glRenderMode", self._opengl32_dll_handle), - glRenderbufferStorage: get_func("glRenderbufferStorage", self._opengl32_dll_handle), - glRenderbufferStorageMultisample: get_func( - "glRenderbufferStorageMultisample", - self._opengl32_dll_handle, - ), - glRotated: get_func("glRotated", self._opengl32_dll_handle), - glRotatef: get_func("glRotatef", self._opengl32_dll_handle), - glSampleCoverage: get_func("glSampleCoverage", self._opengl32_dll_handle), - glSampleMaski: get_func("glSampleMaski", self._opengl32_dll_handle), - glSamplerParameterIiv: get_func("glSamplerParameterIiv", self._opengl32_dll_handle), - glSamplerParameterIuiv: get_func("glSamplerParameterIuiv", self._opengl32_dll_handle), - glSamplerParameterf: get_func("glSamplerParameterf", self._opengl32_dll_handle), - glSamplerParameterfv: get_func("glSamplerParameterfv", self._opengl32_dll_handle), - glSamplerParameteri: get_func("glSamplerParameteri", self._opengl32_dll_handle), - glSamplerParameteriv: get_func("glSamplerParameteriv", self._opengl32_dll_handle), - glScaled: get_func("glScaled", self._opengl32_dll_handle), - glScalef: get_func("glScalef", self._opengl32_dll_handle), - glScissor: get_func("glScissor", self._opengl32_dll_handle), - glSecondaryColor3b: get_func("glSecondaryColor3b", self._opengl32_dll_handle), - glSecondaryColor3bv: get_func("glSecondaryColor3bv", self._opengl32_dll_handle), - glSecondaryColor3d: get_func("glSecondaryColor3d", self._opengl32_dll_handle), - glSecondaryColor3dv: get_func("glSecondaryColor3dv", self._opengl32_dll_handle), - glSecondaryColor3f: get_func("glSecondaryColor3f", self._opengl32_dll_handle), - glSecondaryColor3fv: get_func("glSecondaryColor3fv", self._opengl32_dll_handle), - glSecondaryColor3i: get_func("glSecondaryColor3i", self._opengl32_dll_handle), - glSecondaryColor3iv: get_func("glSecondaryColor3iv", self._opengl32_dll_handle), - glSecondaryColor3s: get_func("glSecondaryColor3s", self._opengl32_dll_handle), - glSecondaryColor3sv: get_func("glSecondaryColor3sv", self._opengl32_dll_handle), - glSecondaryColor3ub: get_func("glSecondaryColor3ub", self._opengl32_dll_handle), - glSecondaryColor3ubv: get_func("glSecondaryColor3ubv", self._opengl32_dll_handle), - glSecondaryColor3ui: get_func("glSecondaryColor3ui", self._opengl32_dll_handle), - glSecondaryColor3uiv: get_func("glSecondaryColor3uiv", self._opengl32_dll_handle), - glSecondaryColor3us: get_func("glSecondaryColor3us", self._opengl32_dll_handle), - glSecondaryColor3usv: get_func("glSecondaryColor3usv", self._opengl32_dll_handle), - glSecondaryColorP3ui: get_func("glSecondaryColorP3ui", self._opengl32_dll_handle), - glSecondaryColorP3uiv: get_func("glSecondaryColorP3uiv", self._opengl32_dll_handle), - glSecondaryColorPointer: get_func("glSecondaryColorPointer", self._opengl32_dll_handle), - glSelectBuffer: get_func("glSelectBuffer", self._opengl32_dll_handle), - glSetFenceAPPLE: get_func("glSetFenceAPPLE", self._opengl32_dll_handle), - glShadeModel: get_func("glShadeModel", self._opengl32_dll_handle), - glShaderSource: get_func("glShaderSource", self._opengl32_dll_handle), - glShaderStorageBlockBinding: get_func( - "glShaderStorageBlockBinding", - self._opengl32_dll_handle, - ), - glStencilFunc: get_func("glStencilFunc", self._opengl32_dll_handle), - glStencilFuncSeparate: get_func("glStencilFuncSeparate", self._opengl32_dll_handle), - glStencilMask: get_func("glStencilMask", self._opengl32_dll_handle), - glStencilMaskSeparate: get_func("glStencilMaskSeparate", self._opengl32_dll_handle), - glStencilOp: get_func("glStencilOp", self._opengl32_dll_handle), - glStencilOpSeparate: get_func("glStencilOpSeparate", self._opengl32_dll_handle), - glTestFenceAPPLE: get_func("glTestFenceAPPLE", self._opengl32_dll_handle), - glTestObjectAPPLE: get_func("glTestObjectAPPLE", self._opengl32_dll_handle), - glTexBuffer: get_func("glTexBuffer", self._opengl32_dll_handle), - glTexCoord1d: get_func("glTexCoord1d", self._opengl32_dll_handle), - glTexCoord1dv: get_func("glTexCoord1dv", self._opengl32_dll_handle), - glTexCoord1f: get_func("glTexCoord1f", self._opengl32_dll_handle), - glTexCoord1fv: get_func("glTexCoord1fv", self._opengl32_dll_handle), - glTexCoord1i: get_func("glTexCoord1i", self._opengl32_dll_handle), - glTexCoord1iv: get_func("glTexCoord1iv", self._opengl32_dll_handle), - glTexCoord1s: get_func("glTexCoord1s", self._opengl32_dll_handle), - glTexCoord1sv: get_func("glTexCoord1sv", self._opengl32_dll_handle), - glTexCoord2d: get_func("glTexCoord2d", self._opengl32_dll_handle), - glTexCoord2dv: get_func("glTexCoord2dv", self._opengl32_dll_handle), - glTexCoord2f: get_func("glTexCoord2f", self._opengl32_dll_handle), - glTexCoord2fv: get_func("glTexCoord2fv", self._opengl32_dll_handle), - glTexCoord2i: get_func("glTexCoord2i", self._opengl32_dll_handle), - glTexCoord2iv: get_func("glTexCoord2iv", self._opengl32_dll_handle), - glTexCoord2s: get_func("glTexCoord2s", self._opengl32_dll_handle), - glTexCoord2sv: get_func("glTexCoord2sv", self._opengl32_dll_handle), - glTexCoord3d: get_func("glTexCoord3d", self._opengl32_dll_handle), - glTexCoord3dv: get_func("glTexCoord3dv", self._opengl32_dll_handle), - glTexCoord3f: get_func("glTexCoord3f", self._opengl32_dll_handle), - glTexCoord3fv: get_func("glTexCoord3fv", self._opengl32_dll_handle), - glTexCoord3i: get_func("glTexCoord3i", self._opengl32_dll_handle), - glTexCoord3iv: get_func("glTexCoord3iv", self._opengl32_dll_handle), - glTexCoord3s: get_func("glTexCoord3s", self._opengl32_dll_handle), - glTexCoord3sv: get_func("glTexCoord3sv", self._opengl32_dll_handle), - glTexCoord4d: get_func("glTexCoord4d", self._opengl32_dll_handle), - glTexCoord4dv: get_func("glTexCoord4dv", self._opengl32_dll_handle), - glTexCoord4f: get_func("glTexCoord4f", self._opengl32_dll_handle), - glTexCoord4fv: get_func("glTexCoord4fv", self._opengl32_dll_handle), - glTexCoord4i: get_func("glTexCoord4i", self._opengl32_dll_handle), - glTexCoord4iv: get_func("glTexCoord4iv", self._opengl32_dll_handle), - glTexCoord4s: get_func("glTexCoord4s", self._opengl32_dll_handle), - glTexCoord4sv: get_func("glTexCoord4sv", self._opengl32_dll_handle), - glTexCoordP1ui: get_func("glTexCoordP1ui", self._opengl32_dll_handle), - glTexCoordP1uiv: get_func("glTexCoordP1uiv", self._opengl32_dll_handle), - glTexCoordP2ui: get_func("glTexCoordP2ui", self._opengl32_dll_handle), - glTexCoordP2uiv: get_func("glTexCoordP2uiv", self._opengl32_dll_handle), - glTexCoordP3ui: get_func("glTexCoordP3ui", self._opengl32_dll_handle), - glTexCoordP3uiv: get_func("glTexCoordP3uiv", self._opengl32_dll_handle), - glTexCoordP4ui: get_func("glTexCoordP4ui", self._opengl32_dll_handle), - glTexCoordP4uiv: get_func("glTexCoordP4uiv", self._opengl32_dll_handle), - glTexCoordPointer: get_func("glTexCoordPointer", self._opengl32_dll_handle), - glTexEnvf: get_func("glTexEnvf", self._opengl32_dll_handle), - glTexEnvfv: get_func("glTexEnvfv", self._opengl32_dll_handle), - glTexEnvi: get_func("glTexEnvi", self._opengl32_dll_handle), - glTexEnviv: get_func("glTexEnviv", self._opengl32_dll_handle), - glTexGend: get_func("glTexGend", self._opengl32_dll_handle), - glTexGendv: get_func("glTexGendv", self._opengl32_dll_handle), - glTexGenf: get_func("glTexGenf", self._opengl32_dll_handle), - glTexGenfv: get_func("glTexGenfv", self._opengl32_dll_handle), - glTexGeni: get_func("glTexGeni", self._opengl32_dll_handle), - glTexGeniv: get_func("glTexGeniv", self._opengl32_dll_handle), - glTexImage1D: get_func("glTexImage1D", self._opengl32_dll_handle), - glTexImage2D: get_func("glTexImage2D", self._opengl32_dll_handle), - glTexImage2DMultisample: get_func("glTexImage2DMultisample", self._opengl32_dll_handle), - glTexImage3D: get_func("glTexImage3D", self._opengl32_dll_handle), - glTexImage3DMultisample: get_func("glTexImage3DMultisample", self._opengl32_dll_handle), - glTexParameterIiv: get_func("glTexParameterIiv", self._opengl32_dll_handle), - glTexParameterIuiv: get_func("glTexParameterIuiv", self._opengl32_dll_handle), - glTexParameterf: get_func("glTexParameterf", self._opengl32_dll_handle), - glTexParameterfv: get_func("glTexParameterfv", self._opengl32_dll_handle), - glTexParameteri: get_func("glTexParameteri", self._opengl32_dll_handle), - glTexParameteriv: get_func("glTexParameteriv", self._opengl32_dll_handle), - glTexStorage1D: get_func("glTexStorage1D", self._opengl32_dll_handle), - glTexStorage2D: get_func("glTexStorage2D", self._opengl32_dll_handle), - glTexStorage3D: get_func("glTexStorage3D", self._opengl32_dll_handle), - glTexSubImage1D: get_func("glTexSubImage1D", self._opengl32_dll_handle), - glTexSubImage2D: get_func("glTexSubImage2D", self._opengl32_dll_handle), - glTexSubImage3D: get_func("glTexSubImage3D", self._opengl32_dll_handle), - glTextureRangeAPPLE: get_func("glTextureRangeAPPLE", self._opengl32_dll_handle), - glTransformFeedbackVaryings: get_func( - "glTransformFeedbackVaryings", - self._opengl32_dll_handle, - ), - glTranslated: get_func("glTranslated", self._opengl32_dll_handle), - glTranslatef: get_func("glTranslatef", self._opengl32_dll_handle), - glUniform1f: get_func("glUniform1f", self._opengl32_dll_handle), - glUniform1fv: get_func("glUniform1fv", self._opengl32_dll_handle), - glUniform1i: get_func("glUniform1i", self._opengl32_dll_handle), - glUniform1iv: get_func("glUniform1iv", self._opengl32_dll_handle), - glUniform1ui: get_func("glUniform1ui", self._opengl32_dll_handle), - glUniform1uiv: get_func("glUniform1uiv", self._opengl32_dll_handle), - glUniform2f: get_func("glUniform2f", self._opengl32_dll_handle), - glUniform2fv: get_func("glUniform2fv", self._opengl32_dll_handle), - glUniform2i: get_func("glUniform2i", self._opengl32_dll_handle), - glUniform2iv: get_func("glUniform2iv", self._opengl32_dll_handle), - glUniform2ui: get_func("glUniform2ui", self._opengl32_dll_handle), - glUniform2uiv: get_func("glUniform2uiv", self._opengl32_dll_handle), - glUniform3f: get_func("glUniform3f", self._opengl32_dll_handle), - glUniform3fv: get_func("glUniform3fv", self._opengl32_dll_handle), - glUniform3i: get_func("glUniform3i", self._opengl32_dll_handle), - glUniform3iv: get_func("glUniform3iv", self._opengl32_dll_handle), - glUniform3ui: get_func("glUniform3ui", self._opengl32_dll_handle), - glUniform3uiv: get_func("glUniform3uiv", self._opengl32_dll_handle), - glUniform4f: get_func("glUniform4f", self._opengl32_dll_handle), - glUniform4fv: get_func("glUniform4fv", self._opengl32_dll_handle), - glUniform4i: get_func("glUniform4i", self._opengl32_dll_handle), - glUniform4iv: get_func("glUniform4iv", self._opengl32_dll_handle), - glUniform4ui: get_func("glUniform4ui", self._opengl32_dll_handle), - glUniform4uiv: get_func("glUniform4uiv", self._opengl32_dll_handle), - glUniformBlockBinding: get_func("glUniformBlockBinding", self._opengl32_dll_handle), - glUniformMatrix2fv: get_func("glUniformMatrix2fv", self._opengl32_dll_handle), - glUniformMatrix2x3fv: get_func("glUniformMatrix2x3fv", self._opengl32_dll_handle), - glUniformMatrix2x4fv: get_func("glUniformMatrix2x4fv", self._opengl32_dll_handle), - glUniformMatrix3fv: get_func("glUniformMatrix3fv", self._opengl32_dll_handle), - glUniformMatrix3x2fv: get_func("glUniformMatrix3x2fv", self._opengl32_dll_handle), - glUniformMatrix3x4fv: get_func("glUniformMatrix3x4fv", self._opengl32_dll_handle), - glUniformMatrix4fv: get_func("glUniformMatrix4fv", self._opengl32_dll_handle), - glUniformMatrix4x2fv: get_func("glUniformMatrix4x2fv", self._opengl32_dll_handle), - glUniformMatrix4x3fv: get_func("glUniformMatrix4x3fv", self._opengl32_dll_handle), - glUnmapBuffer: get_func("glUnmapBuffer", self._opengl32_dll_handle), - glUseProgram: get_func("glUseProgram", self._opengl32_dll_handle), - glValidateProgram: get_func("glValidateProgram", self._opengl32_dll_handle), - glVertex2d: get_func("glVertex2d", self._opengl32_dll_handle), - glVertex2dv: get_func("glVertex2dv", self._opengl32_dll_handle), - glVertex2f: get_func("glVertex2f", self._opengl32_dll_handle), - glVertex2fv: get_func("glVertex2fv", self._opengl32_dll_handle), - glVertex2i: get_func("glVertex2i", self._opengl32_dll_handle), - glVertex2iv: get_func("glVertex2iv", self._opengl32_dll_handle), - glVertex2s: get_func("glVertex2s", self._opengl32_dll_handle), - glVertex2sv: get_func("glVertex2sv", self._opengl32_dll_handle), - glVertex3d: get_func("glVertex3d", self._opengl32_dll_handle), - glVertex3dv: get_func("glVertex3dv", self._opengl32_dll_handle), - glVertex3f: get_func("glVertex3f", self._opengl32_dll_handle), - glVertex3fv: get_func("glVertex3fv", self._opengl32_dll_handle), - glVertex3i: get_func("glVertex3i", self._opengl32_dll_handle), - glVertex3iv: get_func("glVertex3iv", self._opengl32_dll_handle), - glVertex3s: get_func("glVertex3s", self._opengl32_dll_handle), - glVertex3sv: get_func("glVertex3sv", self._opengl32_dll_handle), - glVertex4d: get_func("glVertex4d", self._opengl32_dll_handle), - glVertex4dv: get_func("glVertex4dv", self._opengl32_dll_handle), - glVertex4f: get_func("glVertex4f", self._opengl32_dll_handle), - glVertex4fv: get_func("glVertex4fv", self._opengl32_dll_handle), - glVertex4i: get_func("glVertex4i", self._opengl32_dll_handle), - glVertex4iv: get_func("glVertex4iv", self._opengl32_dll_handle), - glVertex4s: get_func("glVertex4s", self._opengl32_dll_handle), - glVertex4sv: get_func("glVertex4sv", self._opengl32_dll_handle), - glVertexAttrib1d: get_func("glVertexAttrib1d", self._opengl32_dll_handle), - glVertexAttrib1dv: get_func("glVertexAttrib1dv", self._opengl32_dll_handle), - glVertexAttrib1f: get_func("glVertexAttrib1f", self._opengl32_dll_handle), - glVertexAttrib1fv: get_func("glVertexAttrib1fv", self._opengl32_dll_handle), - glVertexAttrib1s: get_func("glVertexAttrib1s", self._opengl32_dll_handle), - glVertexAttrib1sv: get_func("glVertexAttrib1sv", self._opengl32_dll_handle), - glVertexAttrib2d: get_func("glVertexAttrib2d", self._opengl32_dll_handle), - glVertexAttrib2dv: get_func("glVertexAttrib2dv", self._opengl32_dll_handle), - glVertexAttrib2f: get_func("glVertexAttrib2f", self._opengl32_dll_handle), - glVertexAttrib2fv: get_func("glVertexAttrib2fv", self._opengl32_dll_handle), - glVertexAttrib2s: get_func("glVertexAttrib2s", self._opengl32_dll_handle), - glVertexAttrib2sv: get_func("glVertexAttrib2sv", self._opengl32_dll_handle), - glVertexAttrib3d: get_func("glVertexAttrib3d", self._opengl32_dll_handle), - glVertexAttrib3dv: get_func("glVertexAttrib3dv", self._opengl32_dll_handle), - glVertexAttrib3f: get_func("glVertexAttrib3f", self._opengl32_dll_handle), - glVertexAttrib3fv: get_func("glVertexAttrib3fv", self._opengl32_dll_handle), - glVertexAttrib3s: get_func("glVertexAttrib3s", self._opengl32_dll_handle), - glVertexAttrib3sv: get_func("glVertexAttrib3sv", self._opengl32_dll_handle), - glVertexAttrib4Nbv: get_func("glVertexAttrib4Nbv", self._opengl32_dll_handle), - glVertexAttrib4Niv: get_func("glVertexAttrib4Niv", self._opengl32_dll_handle), - glVertexAttrib4Nsv: get_func("glVertexAttrib4Nsv", self._opengl32_dll_handle), - glVertexAttrib4Nub: get_func("glVertexAttrib4Nub", self._opengl32_dll_handle), - glVertexAttrib4Nubv: get_func("glVertexAttrib4Nubv", self._opengl32_dll_handle), - glVertexAttrib4Nuiv: get_func("glVertexAttrib4Nuiv", self._opengl32_dll_handle), - glVertexAttrib4Nusv: get_func("glVertexAttrib4Nusv", self._opengl32_dll_handle), - glVertexAttrib4bv: get_func("glVertexAttrib4bv", self._opengl32_dll_handle), - glVertexAttrib4d: get_func("glVertexAttrib4d", self._opengl32_dll_handle), - glVertexAttrib4dv: get_func("glVertexAttrib4dv", self._opengl32_dll_handle), - glVertexAttrib4f: get_func("glVertexAttrib4f", self._opengl32_dll_handle), - glVertexAttrib4fv: get_func("glVertexAttrib4fv", self._opengl32_dll_handle), - glVertexAttrib4iv: get_func("glVertexAttrib4iv", self._opengl32_dll_handle), - glVertexAttrib4s: get_func("glVertexAttrib4s", self._opengl32_dll_handle), - glVertexAttrib4sv: get_func("glVertexAttrib4sv", self._opengl32_dll_handle), - glVertexAttrib4ubv: get_func("glVertexAttrib4ubv", self._opengl32_dll_handle), - glVertexAttrib4uiv: get_func("glVertexAttrib4uiv", self._opengl32_dll_handle), - glVertexAttrib4usv: get_func("glVertexAttrib4usv", self._opengl32_dll_handle), - glVertexAttribDivisor: get_func("glVertexAttribDivisor", self._opengl32_dll_handle), - glVertexAttribI1i: get_func("glVertexAttribI1i", self._opengl32_dll_handle), - glVertexAttribI1iv: get_func("glVertexAttribI1iv", self._opengl32_dll_handle), - glVertexAttribI1ui: get_func("glVertexAttribI1ui", self._opengl32_dll_handle), - glVertexAttribI1uiv: get_func("glVertexAttribI1uiv", self._opengl32_dll_handle), - glVertexAttribI2i: get_func("glVertexAttribI2i", self._opengl32_dll_handle), - glVertexAttribI2iv: get_func("glVertexAttribI2iv", self._opengl32_dll_handle), - glVertexAttribI2ui: get_func("glVertexAttribI2ui", self._opengl32_dll_handle), - glVertexAttribI2uiv: get_func("glVertexAttribI2uiv", self._opengl32_dll_handle), - glVertexAttribI3i: get_func("glVertexAttribI3i", self._opengl32_dll_handle), - glVertexAttribI3iv: get_func("glVertexAttribI3iv", self._opengl32_dll_handle), - glVertexAttribI3ui: get_func("glVertexAttribI3ui", self._opengl32_dll_handle), - glVertexAttribI3uiv: get_func("glVertexAttribI3uiv", self._opengl32_dll_handle), - glVertexAttribI4bv: get_func("glVertexAttribI4bv", self._opengl32_dll_handle), - glVertexAttribI4i: get_func("glVertexAttribI4i", self._opengl32_dll_handle), - glVertexAttribI4iv: get_func("glVertexAttribI4iv", self._opengl32_dll_handle), - glVertexAttribI4sv: get_func("glVertexAttribI4sv", self._opengl32_dll_handle), - glVertexAttribI4ubv: get_func("glVertexAttribI4ubv", self._opengl32_dll_handle), - glVertexAttribI4ui: get_func("glVertexAttribI4ui", self._opengl32_dll_handle), - glVertexAttribI4uiv: get_func("glVertexAttribI4uiv", self._opengl32_dll_handle), - glVertexAttribI4usv: get_func("glVertexAttribI4usv", self._opengl32_dll_handle), - glVertexAttribIPointer: get_func("glVertexAttribIPointer", self._opengl32_dll_handle), - glVertexAttribP1ui: get_func("glVertexAttribP1ui", self._opengl32_dll_handle), - glVertexAttribP1uiv: get_func("glVertexAttribP1uiv", self._opengl32_dll_handle), - glVertexAttribP2ui: get_func("glVertexAttribP2ui", self._opengl32_dll_handle), - glVertexAttribP2uiv: get_func("glVertexAttribP2uiv", self._opengl32_dll_handle), - glVertexAttribP3ui: get_func("glVertexAttribP3ui", self._opengl32_dll_handle), - glVertexAttribP3uiv: get_func("glVertexAttribP3uiv", self._opengl32_dll_handle), - glVertexAttribP4ui: get_func("glVertexAttribP4ui", self._opengl32_dll_handle), - glVertexAttribP4uiv: get_func("glVertexAttribP4uiv", self._opengl32_dll_handle), - glVertexAttribPointer: get_func("glVertexAttribPointer", self._opengl32_dll_handle), - glVertexP2ui: get_func("glVertexP2ui", self._opengl32_dll_handle), - glVertexP2uiv: get_func("glVertexP2uiv", self._opengl32_dll_handle), - glVertexP3ui: get_func("glVertexP3ui", self._opengl32_dll_handle), - glVertexP3uiv: get_func("glVertexP3uiv", self._opengl32_dll_handle), - glVertexP4ui: get_func("glVertexP4ui", self._opengl32_dll_handle), - glVertexP4uiv: get_func("glVertexP4uiv", self._opengl32_dll_handle), - glVertexPointer: get_func("glVertexPointer", self._opengl32_dll_handle), - glViewport: get_func("glViewport", self._opengl32_dll_handle), - glWaitSync: get_func("glWaitSync", self._opengl32_dll_handle), - glWindowPos2d: get_func("glWindowPos2d", self._opengl32_dll_handle), - glWindowPos2dv: get_func("glWindowPos2dv", self._opengl32_dll_handle), - glWindowPos2f: get_func("glWindowPos2f", self._opengl32_dll_handle), - glWindowPos2fv: get_func("glWindowPos2fv", self._opengl32_dll_handle), - glWindowPos2i: get_func("glWindowPos2i", self._opengl32_dll_handle), - glWindowPos2iv: get_func("glWindowPos2iv", self._opengl32_dll_handle), - glWindowPos2s: get_func("glWindowPos2s", self._opengl32_dll_handle), - glWindowPos2sv: get_func("glWindowPos2sv", self._opengl32_dll_handle), - glWindowPos3d: get_func("glWindowPos3d", self._opengl32_dll_handle), - glWindowPos3dv: get_func("glWindowPos3dv", self._opengl32_dll_handle), - glWindowPos3f: get_func("glWindowPos3f", self._opengl32_dll_handle), - glWindowPos3fv: get_func("glWindowPos3fv", self._opengl32_dll_handle), - glWindowPos3i: get_func("glWindowPos3i", self._opengl32_dll_handle), - glWindowPos3iv: get_func("glWindowPos3iv", self._opengl32_dll_handle), - glWindowPos3s: get_func("glWindowPos3s", self._opengl32_dll_handle), - glWindowPos3sv: get_func("glWindowPos3sv", self._opengl32_dll_handle), - }); - } -} - -impl Drop for GlFunctions { - fn drop(&mut self) { - use winapi::um::libloaderapi::FreeLibrary; - if let Some(opengl32) = self._opengl32_dll_handle { - unsafe { - FreeLibrary(opengl32); - } - } - } -} - -#[derive(Default)] -struct ExtraWglFunctions { - wglCreateContextAttribsARB: Option HGLRC>, - wglSwapIntervalEXT: Option i32>, - wglChoosePixelFormatARB: Option BOOL>, -} - -impl fmt::Debug for ExtraWglFunctions { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - self.wglCreateContextAttribsARB.map(|f| f as usize).fmt(f)?; - self.wglSwapIntervalEXT.map(|f| f as usize).fmt(f)?; - self.wglChoosePixelFormatARB.map(|f| f as usize).fmt(f)?; - Ok(()) - } -} - -#[derive(Debug, Copy, Clone)] -pub enum ExtraWglFunctionsLoadError { - FailedToCreateDummyWindow, - FailedToFindPixelFormat, - FailedToSetPixelFormat, - FailedToCreateDummyGlContext, - FailedToActivateDummyGlContext, -} - -impl ExtraWglFunctions { - pub fn load() -> Result { - - use winapi::um::{ - libloaderapi::GetModuleHandleW, - winuser::{ - CreateWindowExW, GetDC, - ReleaseDC, DestroyWindow, - CW_USEDEFAULT - }, - wingdi::{ - wglGetProcAddress, ChoosePixelFormat, - SetPixelFormat, wglCreateContext, - wglMakeCurrent, wglDeleteContext, - }, - }; - use self::ExtraWglFunctionsLoadError::*; - - unsafe { - - let mut hidden_class_name = encode_wide(CLASS_NAME); - let mut hidden_window_title = encode_wide("Dummy Window"); - - let dummy_window = CreateWindowExW( - 0, - hidden_class_name.as_mut_ptr(), - hidden_window_title.as_mut_ptr(), - 0, - CW_USEDEFAULT, - CW_USEDEFAULT, - CW_USEDEFAULT, - CW_USEDEFAULT, - ptr::null_mut(), - ptr::null_mut(), - GetModuleHandleW(ptr::null_mut()), - ptr::null_mut(), - ); - - if dummy_window.is_null() { - return Err(FailedToCreateDummyWindow); - } - - let dummy_dc = GetDC(dummy_window); - - let mut pfd = get_default_pfd(); - - let pixel_format = ChoosePixelFormat(dummy_dc, &pfd); - if pixel_format == 0 { - return Err(FailedToFindPixelFormat); - } - - if SetPixelFormat(dummy_dc, pixel_format, &pfd) != TRUE { - return Err(FailedToSetPixelFormat); - } - - let dummy_context = wglCreateContext(dummy_dc); - if dummy_context.is_null() { - return Err(FailedToCreateDummyGlContext); - } - - if wglMakeCurrent(dummy_dc, dummy_context) != TRUE { - return Err(FailedToActivateDummyGlContext); - } - - let mut extra_functions = ExtraWglFunctions::default(); - - extra_functions.wglChoosePixelFormatARB = { - let mut func_name_1 = encode_ascii("wglChoosePixelFormatARB"); - let mut func_name_2 = encode_ascii("wglChoosePixelFormatEXT"); - - let wgl1_result = unsafe { wglGetProcAddress(func_name_1.as_mut_ptr()) }; - let wgl2_result = unsafe { wglGetProcAddress(func_name_2.as_mut_ptr()) }; - - if wgl1_result != ptr::null_mut() { - Some(unsafe { mem::transmute(wgl1_result) }) - } else if wgl2_result != ptr::null_mut() { - Some(unsafe { mem::transmute(wgl2_result) }) - } else { - None - } - }; - - extra_functions.wglCreateContextAttribsARB = { - let mut func_name = encode_ascii("wglCreateContextAttribsARB"); - let proc_address = unsafe { wglGetProcAddress(func_name.as_mut_ptr()) }; - if proc_address == ptr::null_mut() { - None - } else { - Some(unsafe { mem::transmute(proc_address) }) - } - }; - - extra_functions.wglSwapIntervalEXT = { - let mut func_name = encode_ascii("wglSwapIntervalEXT"); - let proc_address = unsafe { wglGetProcAddress(func_name.as_mut_ptr()) }; - if proc_address == ptr::null_mut() { - None - } else { - Some(unsafe { mem::transmute(proc_address) }) - } - }; - - wglMakeCurrent(dummy_dc, ptr::null_mut()); - wglDeleteContext(dummy_context); - ReleaseDC(dummy_window, dummy_dc); - DestroyWindow(dummy_window); - - return Ok(extra_functions); - } - } -} - struct Window { /// HWND handle of the plaform window hwnd: HWND, @@ -1832,30 +732,14 @@ impl Window { } // Invoke callback to initialize UI for the first time - let (mut renderer, sender) = match WrRenderer::new( + let wr2 = WrRenderer::new( gl.functions.clone(), Box::new(Notifier {}), - WrRendererOptions { - resource_override_path: None, - use_optimized_shaders: true, - enable_aa: true, - enable_subpixel_aa: true, - force_subpixel_aa: true, - clear_color: WrColorF { - r: 0.0, - g: 0.0, - b: 0.0, - a: 0.0, - }, // transparent - panic_on_gl_error: false, - precache_flags: WrShaderPrecacheFlags::EMPTY, - cached_programs: Some(WrProgramCache::new(None)), - enable_multithreading: true, - debug_flags: wr_translate_debug_flags(&options.state.debug_state), - ..WrRendererOptions::default() - }, + super::default_renderer_options(&options), WR_SHADER_CACHE, - ) { + ); + + let (mut renderer, sender) = match wr { Ok(o) => o, Err(e) => unsafe { if let Some(hrc) = opengl_context.as_mut() { @@ -1868,7 +752,6 @@ impl Window { }, }; - renderer.set_external_image_handler(Box::new(Compositor::default())); let mut render_api = sender.create_api(); @@ -3915,392 +2798,6 @@ unsafe extern "system" fn WindowProc( }; } -#[derive(Debug, Copy, Clone, PartialEq, Eq)] -enum ProcessEventResult { - DoNothing = 0, - ShouldReRenderCurrentWindow = 1, - ShouldUpdateDisplayListCurrentWindow = 2, - // GPU transforms changed: do another hit-test and recurse - // until nothing has changed anymore - UpdateHitTesterAndProcessAgain = 3, - // Only refresh the display (in case of pure scroll or GPU-only events) - ShouldRegenerateDomCurrentWindow = 4, - ShouldRegenerateDomAllWindows = 5, -} - -impl ProcessEventResult { - fn order(&self) -> usize { - use self::ProcessEventResult::*; - match self { - DoNothing => 0, - ShouldReRenderCurrentWindow => 1, - ShouldUpdateDisplayListCurrentWindow => 2, - UpdateHitTesterAndProcessAgain => 3, - ShouldRegenerateDomCurrentWindow => 4, - ShouldRegenerateDomAllWindows => 5, - } - } -} - -impl PartialOrd for ProcessEventResult { - fn partial_cmp(&self, other: &Self) -> Option { - self.order().partial_cmp(&other.order()) - } -} - -impl Ord for ProcessEventResult { - fn cmp(&self, other: &Self) -> std::cmp::Ordering { - self.order().cmp(&other.order()) - } -} - -impl ProcessEventResult { - fn max_self(self, other: Self) -> Self { - self.max(other) - } -} - -// Assuming that current_window_state and the previous_window_state of the window -// are set correctly and the hit-test has been performed, will call the callbacks -// and return what the application should do next -#[must_use] -fn process_event( - hinstance: HINSTANCE, - window: &mut Window, - fc_cache: &mut LazyFcCache, - image_cache: &mut ImageCache, - config: &AppConfig, - new_windows: &mut Vec, - destroyed_windows: &mut Vec, -) -> ProcessEventResult { - - use azul_core::window_state::{ - Events, NodesToCheck, CallbacksOfHitTest, - StyleAndLayoutChanges, - }; - use azul_core::window::FullWindowState; - use azul_core::callbacks::Update; - - // TODO: - // window.internal.current_window_state.monitor = - // win32_translate_monitor(MonitorFromWindow(window.hwnd, MONITOR_DEFAULTTONEAREST)); - - // Get events - let events = Events::new( - &window.internal.current_window_state, - &window.internal.previous_window_state, - ); - - // Get nodes for events - let nodes_to_check = NodesToCheck::new( - &window.internal.current_window_state.last_hit_test, - &events - ); - - // Invoke callbacks on nodes - let callback_result = fc_cache.apply_closure(|fc_cache| { - - use azul_core::window::{RawWindowHandle, WindowsHandle}; - - // Get callbacks for nodes - let mut callbacks = CallbacksOfHitTest::new(&nodes_to_check, &events, &window.internal.layout_results); - - let window_handle = RawWindowHandle::Windows(WindowsHandle { - hwnd: window.hwnd as *mut _, - hinstance: hinstance as *mut _, - }); - let current_scroll_states = window.internal.get_current_scroll_states(); - - // Invoke user-defined callbacks in the UI - callbacks.call( - &window.internal.previous_window_state, - &window.internal.current_window_state, - &window_handle, - ¤t_scroll_states, - &window.gl_context_ptr, - &mut window.internal.layout_results, - &mut window.internal.scroll_states, - image_cache, - fc_cache, - &config.system_callbacks, - &window.internal.renderer_resources, - ) - }); - - return process_callback_results( - callback_result, - window, - &nodes_to_check, - image_cache, - fc_cache, - new_windows, - destroyed_windows - ); -} - -#[must_use] -fn process_timer( - timer_id: usize, - hinstance: HINSTANCE, - window: &mut Window, - fc_cache: &mut LazyFcCache, - image_cache: &mut ImageCache, - config: &AppConfig, - new_windows: &mut Vec, - destroyed_windows: &mut Vec -) -> ProcessEventResult { - - use azul_core::window::{RawWindowHandle, WindowsHandle}; - - let callback_result = fc_cache.apply_closure(|fc_cache| { - - let window_handle = RawWindowHandle::Windows(WindowsHandle { - hwnd: window.hwnd as *mut _, - hinstance: hinstance as *mut _, - }); - - let frame_start = (config.system_callbacks.get_system_time_fn.cb)(); - window.internal.run_single_timer( - timer_id, - frame_start, - &window_handle, - &window.gl_context_ptr, - image_cache, - fc_cache, - &config.system_callbacks, - ) - }); - - return process_callback_results( - callback_result, - window, - &NodesToCheck::empty( - window.internal.current_window_state.mouse_state.mouse_down(), - window.internal.current_window_state.focused_node, - ), - image_cache, - fc_cache, - new_windows, - destroyed_windows - ); -} - -#[must_use] -fn process_threads( - hinstance: HINSTANCE, - data: &mut RefAny, - window: &mut Window, - fc_cache: &mut LazyFcCache, - image_cache: &mut ImageCache, - config: &AppConfig, - new_windows: &mut Vec, - destroyed_windows: &mut Vec -) -> ProcessEventResult { - - use azul_core::window::{RawWindowHandle, WindowsHandle}; - - let callback_result = fc_cache.apply_closure(|fc_cache| { - - let window_handle = RawWindowHandle::Windows(WindowsHandle { - hwnd: window.hwnd as *mut _, - hinstance: hinstance as *mut _, - }); - - let frame_start = (config.system_callbacks.get_system_time_fn.cb)(); - window.internal.run_all_threads( - data, - &window_handle, - &window.gl_context_ptr, - image_cache, - fc_cache, - &config.system_callbacks, - ) - }); - - return process_callback_results( - callback_result, - window, - &NodesToCheck::empty( - window.internal.current_window_state.mouse_state.mouse_down(), - window.internal.current_window_state.focused_node, - ), - image_cache, - fc_cache, - new_windows, - destroyed_windows - ); -} - -#[must_use] -fn process_callback_results( - mut callback_results: CallCallbacksResult, - window: &mut Window, - nodes_to_check: &NodesToCheck, - image_cache: &mut ImageCache, - fc_cache: &mut LazyFcCache, - new_windows: &mut Vec, - destroyed_windows: &mut Vec, -) -> ProcessEventResult { - - use azul_core::callbacks::Update; - use azul_core::window_state::{StyleAndLayoutChanges, NodesToCheck}; - use crate::wr_translate::wr_translate_document_id; - - let mut result = ProcessEventResult::DoNothing; - - if callback_results.images_changed.is_some() || - callback_results.image_masks_changed.is_some() { - - let updated_images = window.internal.renderer_resources.update_image_resources( - &window.internal.layout_results, - callback_results.images_changed.unwrap_or_default(), - callback_results.image_masks_changed.unwrap_or_default(), - &crate::app::CALLBACKS, - &*image_cache, - &mut window.internal.gl_texture_cache, - window.internal.document_id, - window.internal.epoch, - ); - - if !updated_images.is_empty() { - let mut txn = WrTransaction::new(); - wr_synchronize_updated_images(updated_images, &window.internal.document_id, &mut txn); - window.render_api.send_transaction(wr_translate_document_id(window.internal.document_id), txn); - result = result.max_self(ProcessEventResult::ShouldReRenderCurrentWindow); - } - } - - window.start_stop_timers( - callback_results.timers.unwrap_or_default(), - callback_results.timers_removed.unwrap_or_default() - ); - window.start_stop_threads( - callback_results.threads.unwrap_or_default(), - callback_results.threads_removed.unwrap_or_default() - ); - - for w in callback_results.windows_created { - new_windows.push(w); - } - - - let scroll = window.internal.current_window_state.process_system_scroll(&window.internal.scroll_states); - let need_scroll_render = scroll.is_some(); - - if let Some(modified) = callback_results.modified_window_state.as_ref() { - if modified.flags.is_about_to_close { - destroyed_windows.push(window.hwnd as usize); - } - window.internal.current_window_state = FullWindowState::from_window_state( - modified, - window.internal.current_window_state.dropped_file.clone(), - window.internal.current_window_state.hovered_file.clone(), - window.internal.current_window_state.focused_node.clone(), - window.internal.current_window_state.last_hit_test.clone(), - ); - if modified.size.get_layout_size() != window.internal.current_window_state.size.get_layout_size() { - result = result.max_self(ProcessEventResult::UpdateHitTesterAndProcessAgain); - } else if !need_scroll_render { - result = result.max_self(ProcessEventResult::ShouldReRenderCurrentWindow); - } - } - - synchronize_window_state_with_os( - window.hwnd, - window.internal.previous_window_state.as_ref(), - &window.internal.current_window_state - ); - - let layout_callback_changed = window.internal.current_window_state.layout_callback_changed( - &window.internal.previous_window_state - ); - - if layout_callback_changed { - return ProcessEventResult::ShouldRegenerateDomCurrentWindow; - } else { - match callback_results.callbacks_update_screen { - Update::RefreshDom => { - return ProcessEventResult::ShouldRegenerateDomCurrentWindow; - }, - Update::RefreshDomAllWindows => { - return ProcessEventResult::ShouldRegenerateDomAllWindows; - }, - Update::DoNothing => { }, - } - } - - // Re-layout and re-style the window.internal.layout_results - let mut style_layout_changes = StyleAndLayoutChanges::new( - &nodes_to_check, - &mut window.internal.layout_results, - &image_cache, - &mut window.internal.renderer_resources, - window.internal.current_window_state.size.get_layout_size(), - &window.internal.document_id, - callback_results.css_properties_changed.as_ref(), - callback_results.words_changed.as_ref(), - &callback_results.update_focused_node, - azul_layout::do_the_relayout, - ); - - - if let Some(rsn) = style_layout_changes.nodes_that_changed_size.as_ref() { - - let updated_images = fc_cache.apply_closure(|fc_cache| { - LayoutResult::resize_images( - window.internal.id_namespace, - window.internal.document_id, - window.internal.epoch, - DomId::ROOT_ID, - &image_cache, - &window.gl_context_ptr, - &mut window.internal.layout_results, - &mut window.internal.gl_texture_cache, - &mut window.internal.renderer_resources, - &crate::app::CALLBACKS, - azul_layout::do_the_relayout, - fc_cache, - &window.internal.current_window_state.size, - window.internal.current_window_state.theme, - &rsn, - ) - }); - - if !updated_images.is_empty() { - let mut txn = WrTransaction::new(); - wr_synchronize_updated_images(updated_images, &window.internal.document_id, &mut txn); - window.render_api.send_transaction(wr_translate_document_id(window.internal.document_id), txn); - } - } - - // FOCUS CHANGE HAPPENS HERE! - if let Some(focus_change) = style_layout_changes.focus_change.clone() { - window.internal.current_window_state.focused_node = focus_change.new; - } - - // Perform a system or user scroll event: only - // scroll nodes that were not scrolled in the current frame - // - // Update the scroll states of the nodes, returning what nodes were actually scrolled this frame - if let Some(scroll) = scroll { - // Does a system scroll and re-invokes the IFrame - // callbacks if scrolled out of view - window.do_system_scroll(scroll); - window.internal.current_window_state.mouse_state.reset_scroll_to_zero(); - } - - if style_layout_changes.did_resize_nodes() { - // at least update the hit-tester - result.max_self(ProcessEventResult::UpdateHitTesterAndProcessAgain) - } else if style_layout_changes.need_regenerate_display_list() { - result.max_self(ProcessEventResult::ShouldUpdateDisplayListCurrentWindow) - } else if need_scroll_render || style_layout_changes.need_redraw() { - result.max_self(ProcessEventResult::ShouldReRenderCurrentWindow) - } else { - result - } -} - fn create_windows(hinstance: HINSTANCE, app: &mut SharedApplicationData, new: Vec) { for opts in new { if let Ok(w) = Window::create(hinstance, opts, app.clone()) { @@ -4320,52 +2817,7 @@ fn destroy_windows(app: &mut ApplicationData, old: Vec) { } } -fn run_all_threads() { - // TODO -} - -// Initializes the OS window -fn initialize_os_window( - hwnd: HWND, - initial_state: &WindowState, - internal_state: &WindowState -) { - - /* - - window.set_title(new_state.title.as_str()); - window.set_maximized(new_state.flags.is_maximized); - - if new_state.flags.is_fullscreen { - window.set_fullscreen(Some(Fullscreen::Borderless(window.current_monitor()))); - } else { - window.set_fullscreen(None); - } - - window.set_decorations(new_state.flags.has_decorations); - window.set_inner_size(translate_logical_size(new_state.size.dimensions)); - window.set_min_inner_size(new_state.size.min_dimensions.into_option().map(translate_logical_size)); - window.set_min_inner_size(new_state.size.max_dimensions.into_option().map(translate_logical_size)); - - if let WindowPosition::Initialized(new_position) = new_state.position { - let new_position: PhysicalPosition = new_position.into(); - window.set_outer_position(translate_logical_position(new_position.to_logical(new_state.size.hidpi_factor))); - } - - if let ImePosition::Initialized(new_ime_position) = new_state.ime_position { - window.set_ime_position(translate_logical_position(new_ime_position)); - } - - window.set_always_on_top(new_state.flags.is_always_on_top); - window.set_resizable(new_state.flags.is_resizable); - */ -} - -fn synchronize_window_state_with_os( - window: HWND, - previous_state: Option<&FullWindowState>, - current_state: &FullWindowState -) { +pub(crate) fn synchronize_window_state_with_os(window: &Window) { // TODO: window.set_title } diff --git a/azul-desktop/src/wr_translate.rs b/azul-desktop/src/wr_translate.rs index b7a3e168c..dd90cd076 100644 --- a/azul-desktop/src/wr_translate.rs +++ b/azul-desktop/src/wr_translate.rs @@ -360,7 +360,7 @@ pub(crate) fn wr_synchronize_updated_images( } /// Returns the size fo the built display list -#[cfg(not(test))] +#[cfg(not(any(all(macos, test), all(windows, test))))] pub(crate) fn rebuild_display_list( internal: &mut WindowInternal, render_api: &mut WrRenderApi, diff --git a/examples/rust/android/Cargo.toml b/examples/rust/android/Cargo.toml new file mode 100644 index 000000000..e69de29bb diff --git a/examples/rust/android/src/main.rs b/examples/rust/android/src/main.rs new file mode 100644 index 000000000..8a55e8035 --- /dev/null +++ b/examples/rust/android/src/main.rs @@ -0,0 +1,3 @@ +fn main() { + +} \ No newline at end of file diff --git a/examples/rust/ios/Cargo.toml b/examples/rust/ios/Cargo.toml new file mode 100644 index 000000000..b87de144a --- /dev/null +++ b/examples/rust/ios/Cargo.toml @@ -0,0 +1,19 @@ +[package] +name = "azul-ios" +version = "0.1.0" +edition = "2021" +publish = false + +[lib] +crate-type = ["staticlib"] + +[dependencies] +azul = { path = "../../../api/rust" } + +[package.metadata.ios] +build_targets = ["aarch64-apple-ios", "aarch64-apple-ios-sim", "x86_64-apple-ios"] +dependencies = ["OpenGLES.framework", "GLKit.framework"] +deployment_target = "13.0" +bundle_id_prefix = "rs.azul.example" +code_sign_identity = "Apple Developer" +development_team = "XXXXXX" diff --git a/examples/rust/ios/README.md b/examples/rust/ios/README.md new file mode 100644 index 000000000..3d08f51ee --- /dev/null +++ b/examples/rust/ios/README.md @@ -0,0 +1,27 @@ +# azul-ios example + +Running an azul APP on iOS or iPad requires you to install XCode with a simulator pack first. + +``` +brew install xcode +brew install xcodegen # installs xcode code generator +rustup target add aarch64-apple-ios x86_64-apple-ios aarch64-apple-ios-sim +cargo install cargo-xcodebuild # installs xcode tools for cargo +cargo xcodebuild boot # list simulator devices and copy the hash + + Simulator device id is required. List of avaliable devices: + SimulatorDevice { udid: "FC33C0D4-3D49-4EE6-8AAE-F2D9A74BFBD6", name: "iPhone 16 Pro", state: Shutdown } + SimulatorDevice { udid: "3ABFCBFD-878B-45E4-A372-E37CF4482EAF", name: "iPhone 16 Pro Max", state: Shutdown } + SimulatorDevice { udid: "81BF050A-6580-48F5-A71F-73D0B271D75E", name: "iPhone 16", state: Shutdown } + SimulatorDevice { udid: "22097FFB-BD41-437F-8EF2-FDA92FF56B9E", name: "iPhone 16 Plus", state: Shutdown } + SimulatorDevice { udid: "9E079DF1-5CD2-43AE-909E-98F83D309164", name: "iPhone SE (3rd generation)", state: Shutdown } + SimulatorDevice { udid: "5DDB35D1-71C6-43CE-AF2E-49680860E1A0", name: "iPad Pro 11-inch (M4)", state: Shutdown } + SimulatorDevice { udid: "752E4D65-0E95-4962-9220-E8186CA7D7EA", name: "iPad Pro 13-inch (M4)", state: Shutdown } + SimulatorDevice { udid: "53A54F7C-A2BB-4CBF-A9C9-A8CA2C3369AB", name: "iPad Air 11-inch (M2)", state: Shutdown } + SimulatorDevice { udid: "5AD77D2D-44D0-41EB-ABC9-9700D8B55764", name: "iPad Air 13-inch (M2)", state: Shutdown } + SimulatorDevice { udid: "200CAE34-D017-4893-83C7-F4EC5B1713F2", name: "iPad mini (A17 Pro)", state: Shutdown } + SimulatorDevice { udid: "9C6674A8-6B0B-4A57-B383-53B62F3EE601", name: "iPad (10th generation)", state: Shutdown } + +cargo xcodebuild boot 5DDB35D1-71C6-43CE-AF2E-49680860E1A0 # wait for the "iPad Pro 11-inch" simulation to boot + +``` \ No newline at end of file diff --git a/examples/rust/ios/src/lib.rs b/examples/rust/ios/src/lib.rs new file mode 100644 index 000000000..cc20f7d08 --- /dev/null +++ b/examples/rust/ios/src/lib.rs @@ -0,0 +1,52 @@ +use azul::prelude::*; +use azul::str::String as AzString; +use azul::widgets::{Button, Label}; + +struct DataModel { + counter: usize, +} + +extern "C" fn myLayoutFunc( + data: &mut RefAny, + _: &mut LayoutCallbackInfo +) -> StyledDom { + + let counter = match data.downcast_ref::() { + Some(d) => format!("{}", d.counter), + None => return StyledDom::default(), + }; + + let mut label = Dom::text(counter); + label.set_inline_style("font-size: 50px"); + + let mut button = Button::new("Update counter"); + button.set_on_click(data.clone(), myOnClick); + let mut button = button.dom(); + button.set_inline_style("flex-grow: 1"); + + Dom::body() + .with_child(label) + .with_child(button) + .style(Css::empty()) +} + +extern "C" +fn myOnClick(data: &mut RefAny, _: &mut CallbackInfo) -> Update { + let mut data = match data.downcast_mut::() { + Some(s) => s, + None => return Update::DoNothing, // error + }; + + data.counter += 1; + + Update::RefreshDom +} + +#[no_mangle] +pub extern "C" fn main_rs() { + let data = DataModel { counter: 0 }; + let config = AppConfig::new(LayoutSolver::Default); + let app = App::new(RefAny::new(data), config); + let window = WindowCreateOptions::new(myLayoutFunc); + app.run(window); +} \ No newline at end of file