From d8a692c4506c1c91c3beee44c60b90c3679ef4b5 Mon Sep 17 00:00:00 2001 From: Lictex Steaven Date: Sat, 16 Apr 2022 03:34:35 +0800 Subject: [PATCH 1/4] add parallel shader compile extension --- src/gl46.rs | 76 ++++++++++++++++++++++++++++++++++++++++++++++++++ src/lib.rs | 10 +++++++ src/native.rs | 23 +++++++++++++++ src/web_sys.rs | 40 ++++++++++++++++++++++++++ 4 files changed, 149 insertions(+) diff --git a/src/gl46.rs b/src/gl46.rs index 25620dd..fa6c701 100644 --- a/src/gl46.rs +++ b/src/gl46.rs @@ -18,6 +18,7 @@ //! * `GL_ARB_framebuffer_object` //! * `GL_ARB_framebuffer_sRGB` //! * `GL_ARB_instanced_arrays` +//! * `GL_ARB_parallel_shader_compile` //! * `GL_ARB_program_interface_query` //! * `GL_ARB_sampler_objects` //! * `GL_ARB_sync` @@ -30,6 +31,7 @@ //! * `GL_EXT_draw_buffers2` //! * `GL_EXT_texture_filter_anisotropic` //! * `GL_KHR_debug` +//! * `GL_KHR_parallel_shader_compile` //! * `GL_NV_copy_buffer` //! //! Supported Features: @@ -4943,6 +4945,8 @@ pub mod struct_commands { self.MapBufferRange_load_with_dyn(get_proc_address); self.MapNamedBuffer_load_with_dyn(get_proc_address); self.MapNamedBufferRange_load_with_dyn(get_proc_address); + self.MaxShaderCompilerThreadsARB_load_with_dyn(get_proc_address); + self.MaxShaderCompilerThreadsKHR_load_with_dyn(get_proc_address); self.MemoryBarrier_load_with_dyn(get_proc_address); self.MemoryBarrierByRegion_load_with_dyn(get_proc_address); self.MinSampleShading_load_with_dyn(get_proc_address); @@ -21120,6 +21124,76 @@ pub mod struct_commands { pub fn MapNamedBufferRange_is_loaded(&self) -> bool { !self.glMapNamedBufferRange_p.load(RELAX).is_null() } + /// [MaxShaderCompilerThreadsARB](http://docs.gl/gl4/MaxShaderCompilerThreadsARB)(count) + #[cfg_attr(feature = "inline", inline)] + #[cfg_attr(feature = "inline_always", inline(always))] + pub unsafe fn MaxShaderCompilerThreadsARB(&self, count: GLuint) { + #[cfg(all(debug_assertions, feature = "debug_trace_calls"))] + { + trace!("calling gl.MaxShaderCompilerThreadsARB({:?});", count); + } + let out = call_atomic_ptr_1arg( + "MaxShaderCompilerThreadsARB", + &self.glMaxShaderCompilerThreadsARB_p, + count + ); + #[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))] + { + self.automatic_glGetError("glMaxShaderCompilerThreadsARB"); + } + out + } + #[doc(hidden)] + pub unsafe fn MaxShaderCompilerThreadsARB_load_with_dyn( + &self, + get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void, + ) -> bool { + load_dyn_name_atomic_ptr( + get_proc_address, + b"glMaxShaderCompilerThreadsARB\0", + &self.glMaxShaderCompilerThreadsARB_p, + ) + } + #[inline] + #[doc(hidden)] + pub fn MaxShaderCompilerThreadsARB_is_loaded(&self) -> bool { + !self.glMaxShaderCompilerThreadsARB_p.load(RELAX).is_null() + } + /// [MaxShaderCompilerThreadsKHR](http://docs.gl/gl4/MaxShaderCompilerThreadsKHR)(count) + #[cfg_attr(feature = "inline", inline)] + #[cfg_attr(feature = "inline_always", inline(always))] + pub unsafe fn MaxShaderCompilerThreadsKHR(&self, count: GLuint) { + #[cfg(all(debug_assertions, feature = "debug_trace_calls"))] + { + trace!("calling gl.MaxShaderCompilerThreadsKHR({:?});", count); + } + let out = call_atomic_ptr_1arg( + "glMaxShaderCompilerThreadsKHR", + &self.glMaxShaderCompilerThreadsKHR_p, + count + ); + #[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))] + { + self.automatic_glGetError("glMaxShaderCompilerThreadsKHR"); + } + out + } + #[doc(hidden)] + pub unsafe fn MaxShaderCompilerThreadsKHR_load_with_dyn( + &self, + get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void, + ) -> bool { + load_dyn_name_atomic_ptr( + get_proc_address, + b"glMaxShaderCompilerThreadsKHR\0", + &self.glMaxShaderCompilerThreadsKHR_p, + ) + } + #[inline] + #[doc(hidden)] + pub fn MaxShaderCompilerThreadsKHR_is_loaded(&self) -> bool { + !self.glMaxShaderCompilerThreadsKHR_p.load(RELAX).is_null() + } /// [glMemoryBarrier](http://docs.gl/gl4/glMemoryBarrier)(barriers) /// * `barriers` group: MemoryBarrierMask #[cfg_attr(feature = "inline", inline)] @@ -35574,6 +35648,8 @@ pub mod struct_commands { glMapBufferRange_p: APcv, glMapNamedBuffer_p: APcv, glMapNamedBufferRange_p: APcv, + glMaxShaderCompilerThreadsARB_p: APcv, + glMaxShaderCompilerThreadsKHR_p: APcv, glMemoryBarrier_p: APcv, glMemoryBarrierByRegion_p: APcv, glMinSampleShading_p: APcv, diff --git a/src/lib.rs b/src/lib.rs index 9b5e327..49a1749 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -128,6 +128,8 @@ pub trait HasContext { unsafe fn compile_shader(&self, shader: Self::Shader); + unsafe fn get_shader_completion_status(&self, shader: Self::Shader) -> bool; + unsafe fn get_shader_compile_status(&self, shader: Self::Shader) -> bool; unsafe fn get_shader_info_log(&self, shader: Self::Shader) -> String; @@ -153,6 +155,8 @@ pub trait HasContext { unsafe fn link_program(&self, program: Self::Program); + unsafe fn get_program_completion_status(&self, program: Self::Program) -> bool; + unsafe fn get_program_link_status(&self, program: Self::Program) -> bool; unsafe fn get_program_info_log(&self, program: Self::Program) -> String; @@ -1233,6 +1237,8 @@ pub trait HasContext { access: u32, format: u32, ); + + unsafe fn max_shader_compiler_threads(&self, count: u32); } pub const ACTIVE_ATOMIC_COUNTER_BUFFERS: u32 = 0x92D9; @@ -1545,6 +1551,8 @@ pub const COMPATIBLE_SUBROUTINES: u32 = 0x8E4B; pub const COMPILE_STATUS: u32 = 0x8B81; +pub const COMPLETION_STATUS: u32 = 0x91B1; + pub const COMPRESSED_R11_EAC: u32 = 0x9270; pub const COMPRESSED_RED: u32 = 0x8225; @@ -2581,6 +2589,8 @@ pub const MAX_SAMPLE_MASK_WORDS: u32 = 0x8E59; pub const MAX_SERVER_WAIT_TIMEOUT: u32 = 0x9111; +pub const MAX_SHADER_COMPILER_THREADS: u32 = 0x91B0; + pub const MAX_SHADER_STORAGE_BLOCK_SIZE: u32 = 0x90DE; pub const MAX_SHADER_STORAGE_BUFFER_BINDINGS: u32 = 0x90DD; diff --git a/src/native.rs b/src/native.rs index 1ad5a9a..2fe52bc 100644 --- a/src/native.rs +++ b/src/native.rs @@ -260,6 +260,13 @@ impl HasContext for Context { gl.CompileShader(shader.0.get()); } + unsafe fn get_shader_completion_status(&self, shader: Self::Shader) -> bool { + let gl = &self.raw; + let mut status = 0; + gl.GetShaderiv(shader.0.get(), COMPLETION_STATUS, &mut status); + 1 == status + } + unsafe fn get_shader_compile_status(&self, shader: Self::Shader) -> bool { let gl = &self.raw; let mut status = 0; @@ -338,6 +345,13 @@ impl HasContext for Context { gl.LinkProgram(program.0.get()); } + unsafe fn get_program_completion_status(&self, program: Self::Program) -> bool { + let gl = &self.raw; + let mut status = 0; + gl.GetProgramiv(program.0.get(), COMPLETION_STATUS, &mut status); + 1 == status + } + unsafe fn get_program_link_status(&self, program: Self::Program) -> bool { let gl = &self.raw; let mut status = 0; @@ -2963,6 +2977,15 @@ impl HasContext for Context { String::from("") } } + + unsafe fn max_shader_compiler_threads(&self, count: u32) { + let gl = &self.raw; + if gl.MaxShaderCompilerThreadsKHR_is_loaded() { + gl.MaxShaderCompilerThreadsKHR(count); + } else { + gl.MaxShaderCompilerThreadsARB(count); + } + } } extern "system" fn raw_debug_message_callback( diff --git a/src/web_sys.rs b/src/web_sys.rs index 7e70867..53f3e86 100644 --- a/src/web_sys.rs +++ b/src/web_sys.rs @@ -917,6 +917,24 @@ impl HasContext for Context { } } + unsafe fn get_shader_completion_status(&self, shader: Self::Shader) -> bool { + let shaders = self.shaders.borrow(); + let raw_shader = shaders.get_unchecked(shader); + if self.extensions.khr_parallel_shader_compile.is_none() { + panic!("Parallel shader compile is not supported") + } + match self.raw { + RawRenderingContext::WebGl1(ref gl) => { + gl.get_shader_parameter(raw_shader, COMPLETION_STATUS) + } + RawRenderingContext::WebGl2(ref gl) => { + gl.get_shader_parameter(raw_shader, COMPLETION_STATUS) + } + } + .as_bool() + .unwrap_or(false) + } + unsafe fn get_shader_compile_status(&self, shader: Self::Shader) -> bool { let shaders = self.shaders.borrow(); let raw_shader = shaders.get_unchecked(shader); @@ -1021,6 +1039,24 @@ impl HasContext for Context { } } + unsafe fn get_program_completion_status(&self, program: Self::Program) -> bool { + let programs = self.programs.borrow(); + let raw_program = programs.get_unchecked(program); + if self.extensions.khr_parallel_shader_compile.is_none() { + panic!("Parallel shader compile is not supported") + } + match self.raw { + RawRenderingContext::WebGl1(ref gl) => { + gl.get_program_parameter(raw_program, COMPLETION_STATUS) + } + RawRenderingContext::WebGl2(ref gl) => { + gl.get_program_parameter(raw_program, COMPLETION_STATUS) + } + } + .as_bool() + .unwrap_or(false) + } + unsafe fn get_program_link_status(&self, program: Self::Program) -> bool { let programs = self.programs.borrow(); let raw_program = programs.get_unchecked(program); @@ -4101,6 +4137,10 @@ impl HasContext for Context { .unwrap(), } } + + unsafe fn max_shader_compiler_threads(&self, _count: u32) { + // WebGL doesn't use this + } } /// Sending texture data requires different data views for different data types. From 1322c5e2a41cc3ce65c1d9c164ce6604f9101d57 Mon Sep 17 00:00:00 2001 From: Ashley Ruglys Date: Sat, 16 Apr 2022 15:54:20 +0200 Subject: [PATCH 2/4] Add a bind raw framebuffer function to the web sys context --- src/web_sys.rs | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/src/web_sys.rs b/src/web_sys.rs index 7e70867..17cb8bd 100644 --- a/src/web_sys.rs +++ b/src/web_sys.rs @@ -705,6 +705,13 @@ impl Context { } } } + + pub unsafe fn bind_raw_framebuffer(&self, target: u32, framebuffer: &WebGlFramebuffer) { + match self.raw { + RawRenderingContext::WebGl1(ref gl) => gl.bind_framebuffer(target, Some(framebuffer)), + RawRenderingContext::WebGl2(ref gl) => gl.bind_framebuffer(target, Some(framebuffer)), + } + } } new_key_type! { pub struct WebShaderKey; } From a2c98d1fd5205b95ed5225af808a9a8598d267d4 Mon Sep 17 00:00:00 2001 From: Ashley Ruglys Date: Sat, 16 Apr 2022 21:24:54 +0200 Subject: [PATCH 3/4] Rename to bind_external_framebuffer --- src/web_sys.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/web_sys.rs b/src/web_sys.rs index 17cb8bd..d43104b 100644 --- a/src/web_sys.rs +++ b/src/web_sys.rs @@ -706,7 +706,7 @@ impl Context { } } - pub unsafe fn bind_raw_framebuffer(&self, target: u32, framebuffer: &WebGlFramebuffer) { + pub unsafe fn bind_external_framebuffer(&self, target: u32, framebuffer: &WebGlFramebuffer) { match self.raw { RawRenderingContext::WebGl1(ref gl) => gl.bind_framebuffer(target, Some(framebuffer)), RawRenderingContext::WebGl2(ref gl) => gl.bind_framebuffer(target, Some(framebuffer)), From f30c8dd2b51c42aff80125909a462fc2fc734657 Mon Sep 17 00:00:00 2001 From: Ashley Ruglys Date: Fri, 20 May 2022 19:45:19 +0200 Subject: [PATCH 4/4] Fix some dead code warnings --- src/lib.rs | 1 + src/version.rs | 3 ++ src/web_sys.rs | 120 +++++++++++++++++++++++++------------------------ 3 files changed, 65 insertions(+), 59 deletions(-) diff --git a/src/lib.rs b/src/lib.rs index 9b5e327..12d2cc3 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -56,6 +56,7 @@ pub struct ActiveTransformFeedback { pub name: String, } +#[allow(dead_code)] #[derive(Debug)] pub struct DebugMessageLogEntry { source: u32, diff --git a/src/version.rs b/src/version.rs index b5c018c..b96961b 100644 --- a/src/version.rs +++ b/src/version.rs @@ -10,6 +10,7 @@ pub struct Version { impl Version { /// Create a new OpenGL version number + #[allow(dead_code)] pub(crate) fn new(major: u32, minor: u32, revision: Option, vendor_info: String) -> Self { Version { major: major, @@ -19,7 +20,9 @@ impl Version { vendor_info, } } + /// Create a new OpenGL ES version number + #[allow(dead_code)] pub(crate) fn new_embedded(major: u32, minor: u32, vendor_info: String) -> Self { Version { major, diff --git a/src/web_sys.rs b/src/web_sys.rs index 7e70867..236de99 100644 --- a/src/web_sys.rs +++ b/src/web_sys.rs @@ -16,6 +16,7 @@ enum RawRenderingContext { WebGl2(WebGl2RenderingContext), } +#[allow(dead_code)] #[derive(Debug)] struct Extensions { pub angle_instanced_arrays: Option, @@ -873,7 +874,7 @@ impl HasContext for Context { } } - unsafe fn create_named_texture(&self, target: u32) -> Result { + unsafe fn create_named_texture(&self, _target: u32) -> Result { unimplemented!() } @@ -1354,7 +1355,7 @@ impl HasContext for Context { } } - unsafe fn named_buffer_data_u8_slice(&self, buffer: Self::Buffer, data: &[u8], usage: u32) { + unsafe fn named_buffer_data_u8_slice(&self, _buffer: Self::Buffer, _data: &[u8], _usage: u32) { unimplemented!() } @@ -1483,21 +1484,21 @@ impl HasContext for Context { unsafe fn copy_image_sub_data( &self, - src_name: Self::Texture, - src_target: u32, - src_level: i32, - src_x: i32, - src_y: i32, - src_z: i32, - dst_name: Self::Texture, - dst_target: u32, - dst_level: i32, - dst_x: i32, - dst_y: i32, - dst_z: i32, - src_width: i32, - src_height: i32, - src_depth: i32, + _src_name: Self::Texture, + _src_target: u32, + _src_level: i32, + _src_x: i32, + _src_y: i32, + _src_z: i32, + _dst_name: Self::Texture, + _dst_target: u32, + _dst_level: i32, + _dst_x: i32, + _dst_y: i32, + _dst_z: i32, + _src_width: i32, + _src_height: i32, + _src_depth: i32, ) { unimplemented!() } @@ -1838,7 +1839,7 @@ impl HasContext for Context { panic!("Draw buffer enable is not supported"); } - unsafe fn enable_vertex_array_attrib(&self, vao: Self::VertexArray, index: u32) { + unsafe fn enable_vertex_array_attrib(&self, _vao: Self::VertexArray, _index: u32) { unimplemented!() } @@ -2268,7 +2269,7 @@ impl HasContext for Context { } } - unsafe fn generate_texture_mipmap(&self, texture: Self::Texture) { + unsafe fn generate_texture_mipmap(&self, _texture: Self::Texture) { unimplemented!() } @@ -3037,7 +3038,7 @@ impl HasContext for Context { } } - unsafe fn texture_parameter_i32(&self, texture: Self::Texture, parameter: u32, value: i32) { + unsafe fn texture_parameter_i32(&self, _texture: Self::Texture, _parameter: u32, _value: i32) { unimplemented!() } @@ -3105,17 +3106,17 @@ impl HasContext for Context { unsafe fn texture_sub_image_3d( &self, - texture: Self::Texture, - level: i32, - x_offset: i32, - y_offset: i32, - z_offset: i32, - width: i32, - height: i32, - depth: i32, - format: u32, - ty: u32, - pixels: PixelUnpackData, + _texture: Self::Texture, + _level: i32, + _x_offset: i32, + _y_offset: i32, + _z_offset: i32, + _width: i32, + _height: i32, + _depth: i32, + _format: u32, + _ty: u32, + _pixels: PixelUnpackData, ) { unimplemented!() } @@ -3299,54 +3300,55 @@ impl HasContext for Context { unsafe fn vertex_array_attrib_binding_f32( &self, - vao: Self::VertexArray, - index: u32, - binding_index: u32, + _vao: Self::VertexArray, + _index: u32, + _binding_index: u32, ) { unimplemented!() } unsafe fn vertex_array_attrib_format_f32( &self, - vao: Self::VertexArray, - index: u32, - size: i32, - data_type: u32, - normalized: bool, - relative_offset: u32, + _vao: Self::VertexArray, + _index: u32, + _size: i32, + _data_type: u32, + _normalized: bool, + _relative_offset: u32, ) { unimplemented!() } unsafe fn vertex_array_attrib_format_i32( &self, - vao: Self::VertexArray, - index: u32, - size: i32, - data_type: u32, - relative_offset: u32, + _vao: Self::VertexArray, + _index: u32, + _size: i32, + _data_type: u32, + _relative_offset: u32, ) { unimplemented!() } unsafe fn vertex_array_element_buffer( &self, - vao: Self::VertexArray, - buffer: Option, + _vao: Self::VertexArray, + _buffer: Option, ) { unimplemented!() } unsafe fn vertex_array_vertex_buffer( &self, - vao: Self::VertexArray, - binding_index: u32, - buffer: Option, - offset: i32, - stride: i32, + _vao: Self::VertexArray, + _binding_index: u32, + _buffer: Option, + _offset: i32, + _stride: i32, ) { unimplemented!() } + unsafe fn vertex_attrib_divisor(&self, index: u32, divisor: u32) { match self.raw { RawRenderingContext::WebGl1(ref _gl) => match &self.extensions.angle_instanced_arrays { @@ -3766,7 +3768,7 @@ impl HasContext for Context { ) { match pixels { PixelPackData::BufferOffset(offset) => match self.raw { - RawRenderingContext::WebGl1(ref gl) => { + RawRenderingContext::WebGl1(ref _gl) => { panic!("Read pixels into buffer offset is not supported") } RawRenderingContext::WebGl2(ref gl) => gl @@ -3805,12 +3807,12 @@ impl HasContext for Context { unsafe fn texture_storage_3d( &self, - texture: Self::Texture, - levels: i32, - internal_format: u32, - width: i32, - height: i32, - depth: i32, + _texture: Self::Texture, + _levels: i32, + _internal_format: u32, + _width: i32, + _height: i32, + _depth: i32, ) { unimplemented!() }