From f408734ff5a4ac2ba57e31734445de9bf38e86f0 Mon Sep 17 00:00:00 2001 From: Dmitry Stepanov Date: Thu, 20 Feb 2025 15:29:16 +0300 Subject: [PATCH] replace flat shader uses with specific ones with native shaders --- fyrox-impl/src/renderer/flat_shader.rs | 48 ------- fyrox-impl/src/renderer/light.rs | 122 ++++++++---------- fyrox-impl/src/renderer/light_volume.rs | 103 ++++----------- fyrox-impl/src/renderer/mod.rs | 83 +++++------- fyrox-impl/src/renderer/shaders/blit.shader | 69 ++++++++++ fyrox-impl/src/renderer/shaders/flat_fs.glsl | 10 -- fyrox-impl/src/renderer/shaders/flat_vs.glsl | 14 -- .../src/renderer/shaders/pixel_counter.shader | 62 +++++++++ fyrox-impl/src/renderer/shaders/ui.shader | 48 ++++++- .../renderer/shaders/volume_marker_lit.shader | 39 ++++++ .../renderer/shaders/volume_marker_vol.shader | 62 +++++++++ fyrox-impl/src/renderer/ui_renderer.rs | 48 ++----- 12 files changed, 398 insertions(+), 310 deletions(-) delete mode 100644 fyrox-impl/src/renderer/flat_shader.rs create mode 100644 fyrox-impl/src/renderer/shaders/blit.shader delete mode 100644 fyrox-impl/src/renderer/shaders/flat_fs.glsl delete mode 100644 fyrox-impl/src/renderer/shaders/flat_vs.glsl create mode 100644 fyrox-impl/src/renderer/shaders/pixel_counter.shader create mode 100644 fyrox-impl/src/renderer/shaders/volume_marker_lit.shader create mode 100644 fyrox-impl/src/renderer/shaders/volume_marker_vol.shader diff --git a/fyrox-impl/src/renderer/flat_shader.rs b/fyrox-impl/src/renderer/flat_shader.rs deleted file mode 100644 index cb4d935d0b..0000000000 --- a/fyrox-impl/src/renderer/flat_shader.rs +++ /dev/null @@ -1,48 +0,0 @@ -// Copyright (c) 2019-present Dmitry Stepanov and Fyrox Engine contributors. -// -// Permission is hereby granted, free of charge, to any person obtaining a copy -// of this software and associated documentation files (the "Software"), to deal -// in the Software without restriction, including without limitation the rights -// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -// copies of the Software, and to permit persons to whom the Software is -// furnished to do so, subject to the following conditions: -// -// The above copyright notice and this permission notice shall be included in all -// copies or substantial portions of the Software. -// -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -// SOFTWARE. - -use crate::{ - core::sstorage::ImmutableString, - renderer::framework::{ - error::FrameworkError, gpu_program::UniformLocation, server::GraphicsServer, - }, -}; -use fyrox_graphics::gpu_program::GpuProgram; - -pub struct FlatShader { - pub program: GpuProgram, - pub uniform_buffer_binding: usize, - pub diffuse_texture: UniformLocation, -} - -impl FlatShader { - pub fn new(server: &dyn GraphicsServer) -> Result { - let fragment_source = include_str!("shaders/flat_fs.glsl"); - let vertex_source = include_str!("shaders/flat_vs.glsl"); - - let program = server.create_program("FlatShader", vertex_source, fragment_source)?; - Ok(Self { - uniform_buffer_binding: program - .uniform_block_index(&ImmutableString::new("Uniforms"))?, - diffuse_texture: program.uniform_location(&ImmutableString::new("diffuseTexture"))?, - program, - }) - } -} diff --git a/fyrox-impl/src/renderer/light.rs b/fyrox-impl/src/renderer/light.rs index baae0967ff..9037eb8548 100644 --- a/fyrox-impl/src/renderer/light.rs +++ b/fyrox-impl/src/renderer/light.rs @@ -33,16 +33,11 @@ use crate::{ }, uniform::{UniformBufferCache, UniformMemoryAllocator}, }, - flat_shader::FlatShader, framework::{ - buffer::BufferUsage, - error::FrameworkError, - framebuffer::{BufferLocation, GpuFrameBuffer, ResourceBindGroup, ResourceBinding}, - geometry_buffer::GpuGeometryBuffer, - server::GraphicsServer, - uniform::StaticUniformBuffer, - ColorMask, CompareFunc, CullFace, DrawParameters, ElementRange, GeometryBufferExt, - StencilAction, StencilFunc, StencilOp, + buffer::BufferUsage, error::FrameworkError, framebuffer::GpuFrameBuffer, + geometry_buffer::GpuGeometryBuffer, server::GraphicsServer, ColorMask, CompareFunc, + CullFace, DrawParameters, ElementRange, GeometryBufferExt, StencilAction, StencilFunc, + StencilOp, }, gbuffer::GBuffer, light_volume::LightVolumeRenderer, @@ -78,12 +73,13 @@ pub struct DeferredLightRenderer { sphere: GpuGeometryBuffer, cone: GpuGeometryBuffer, skybox: GpuGeometryBuffer, - flat_shader: FlatShader, skybox_shader: RenderPassContainer, spot_shadow_map_renderer: SpotShadowMapRenderer, point_shadow_map_renderer: PointShadowMapRenderer, csm_renderer: CsmRenderer, light_volume: LightVolumeRenderer, + volume_marker: RenderPassContainer, + pixel_counter: RenderPassContainer, } pub(crate) struct DeferredRendererContext<'a> { @@ -209,7 +205,6 @@ impl DeferredLightRenderer { BufferUsage::StaticDraw, server, )?, - flat_shader: FlatShader::new(server)?, skybox_shader: RenderPassContainer::from_str( server, include_str!("shaders/skybox.shader"), @@ -230,6 +225,14 @@ impl DeferredLightRenderer { quality_defaults.csm_settings.size, quality_defaults.csm_settings.precision, )?, + volume_marker: RenderPassContainer::from_str( + server, + include_str!("shaders/volume_marker_lit.shader"), + )?, + pixel_counter: RenderPassContainer::from_str( + server, + include_str!("shaders/pixel_counter.shader"), + )?, }) } @@ -505,44 +508,39 @@ impl DeferredLightRenderer { let mut light_view_projection = Matrix4::identity(); // Mark lit areas in stencil buffer to do light calculations only on them. - let uniform_buffer = uniform_buffer_cache.write( - StaticUniformBuffer::<256>::new().with(&(view_projection * bounding_shape_matrix)), - )?; - + let shape_wvp_matrix = view_projection * bounding_shape_matrix; for (cull_face, stencil_action) in [ (CullFace::Front, StencilAction::Incr), (CullFace::Back, StencilAction::Decr), ] { - pass_stats += frame_buffer.draw( + let draw_params = DrawParameters { + cull_face: Some(cull_face), + color_write: ColorMask::all(false), + depth_write: false, + stencil_test: Some(StencilFunc { + func: CompareFunc::Always, + ..Default::default() + }), + stencil_op: StencilOp { + zfail: stencil_action, + ..Default::default() + }, + depth_test: Some(CompareFunc::Less), + blend: None, + scissor_box: None, + }; + let properties = + PropertyGroup::from([property("worldViewProjection", &shape_wvp_matrix)]); + let material = RenderMaterial::from([binding("properties", &properties)]); + pass_stats += self.volume_marker.run_pass( + &ImmutableString::new("Primary"), + frame_buffer, bounding_shape, viewport, - &self.flat_shader.program, - &DrawParameters { - cull_face: Some(cull_face), - color_write: ColorMask::all(false), - depth_write: false, - stencil_test: Some(StencilFunc { - func: CompareFunc::Always, - ..Default::default() - }), - stencil_op: StencilOp { - zfail: stencil_action, - ..Default::default() - }, - depth_test: Some(CompareFunc::Less), - blend: None, - scissor_box: None, - }, - &[ResourceBindGroup { - bindings: &[ResourceBinding::Buffer { - buffer: uniform_buffer.clone(), - binding: BufferLocation::Auto { - shader_location: self.flat_shader.uniform_buffer_binding, - }, - data_usage: Default::default(), - }], - }], - ElementRange::Full, + &material, + uniform_buffer_cache, + Default::default(), + Some(&draw_params), )?; } @@ -557,37 +555,19 @@ impl DeferredLightRenderer { if visibility_cache.needs_occlusion_query(camera_global_position, light.handle) { // Draw full screen quad, that will be used to count pixels that passed the stencil test // on the stencil buffer's content generated by two previous drawing commands. - let uniform_buffer = uniform_buffer_cache - .write(StaticUniformBuffer::<256>::new().with(&frame_matrix))?; - visibility_cache.begin_query(server, camera_global_position, light.handle)?; - pass_stats += frame_buffer.draw( + let properties = + PropertyGroup::from([property("worldViewProjection", &frame_matrix)]); + let material = RenderMaterial::from([binding("properties", &properties)]); + pass_stats += self.pixel_counter.run_pass( + &ImmutableString::new("Primary"), + frame_buffer, &self.quad, viewport, - &self.flat_shader.program, - &DrawParameters { - cull_face: None, - color_write: ColorMask::all(false), - depth_write: false, - stencil_test: Some(StencilFunc { - func: CompareFunc::NotEqual, - ..Default::default() - }), - depth_test: None, - blend: None, - stencil_op: Default::default(), - scissor_box: None, - }, - &[ResourceBindGroup { - bindings: &[ResourceBinding::Buffer { - buffer: uniform_buffer, - binding: BufferLocation::Auto { - shader_location: self.flat_shader.uniform_buffer_binding, - }, - data_usage: Default::default(), - }], - }], - ElementRange::Full, + &material, + uniform_buffer_cache, + Default::default(), + None, )?; visibility_cache.end_query(); } diff --git a/fyrox-impl/src/renderer/light_volume.rs b/fyrox-impl/src/renderer/light_volume.rs index 2d940246d2..dfce461b83 100644 --- a/fyrox-impl/src/renderer/light_volume.rs +++ b/fyrox-impl/src/renderer/light_volume.rs @@ -30,16 +30,9 @@ use crate::{ shader::{binding, property, PropertyGroup, RenderMaterial, RenderPassContainer}, uniform::UniformBufferCache, }, - flat_shader::FlatShader, framework::{ - buffer::BufferUsage, - error::FrameworkError, - framebuffer::{BufferLocation, GpuFrameBuffer, ResourceBindGroup, ResourceBinding}, - geometry_buffer::GpuGeometryBuffer, - server::GraphicsServer, - uniform::StaticUniformBuffer, - ColorMask, CompareFunc, DrawParameters, ElementRange, GeometryBufferExt, StencilAction, - StencilFunc, StencilOp, + buffer::BufferUsage, error::FrameworkError, framebuffer::GpuFrameBuffer, + geometry_buffer::GpuGeometryBuffer, server::GraphicsServer, GeometryBufferExt, }, gbuffer::GBuffer, make_viewport_matrix, RenderPassStatistics, @@ -50,9 +43,9 @@ use crate::{ pub struct LightVolumeRenderer { spot_light_shader: RenderPassContainer, point_light_shader: RenderPassContainer, - flat_shader: FlatShader, cone: GpuGeometryBuffer, sphere: GpuGeometryBuffer, + volume_marker: RenderPassContainer, } impl LightVolumeRenderer { @@ -66,7 +59,6 @@ impl LightVolumeRenderer { server, include_str!("shaders/point_volumetric.shader"), )?, - flat_shader: FlatShader::new(server)?, cone: GpuGeometryBuffer::from_surface_data( &SurfaceData::make_cone( 16, @@ -82,6 +74,10 @@ impl LightVolumeRenderer { BufferUsage::StaticDraw, server, )?, + volume_marker: RenderPassContainer::from_str( + server, + include_str!("shaders/volume_marker_vol.shader"), + )?, }) } @@ -121,7 +117,6 @@ impl LightVolumeRenderer { // Draw cone into stencil buffer - it will mark pixels for further volumetric light // calculations, it will significantly reduce amount of pixels for far lights thus // significantly improve performance. - let k = (full_cone_angle * 0.5 + 1.0f32.to_radians()).tan() * distance; let light_shape_matrix = Isometry3 { rotation: graph.global_rotation(light.handle), @@ -136,40 +131,17 @@ impl LightVolumeRenderer { // Clear stencil only. frame_buffer.clear(viewport, None, None, Some(0)); - stats += frame_buffer.draw( + let properties = PropertyGroup::from([property("worldViewProjection", &mvp)]); + let material = RenderMaterial::from([binding("properties", &properties)]); + stats += self.volume_marker.run_pass( + &ImmutableString::new("Primary"), + frame_buffer, &self.cone, viewport, - &self.flat_shader.program, - &DrawParameters { - cull_face: None, - color_write: ColorMask::all(false), - depth_write: false, - stencil_test: Some(StencilFunc { - func: CompareFunc::Equal, - ref_value: 0xFF, - mask: 0xFFFF_FFFF, - }), - depth_test: Some(CompareFunc::Less), - blend: None, - stencil_op: StencilOp { - fail: StencilAction::Replace, - zfail: StencilAction::Keep, - zpass: StencilAction::Replace, - write_mask: 0xFFFF_FFFF, - }, - scissor_box: None, - }, - &[ResourceBindGroup { - bindings: &[ResourceBinding::Buffer { - buffer: uniform_buffer_cache - .write(StaticUniformBuffer::<256>::new().with(&mvp))?, - binding: BufferLocation::Auto { - shader_location: self.flat_shader.uniform_buffer_binding, - }, - data_usage: Default::default(), - }], - }], - ElementRange::Full, + &material, + uniform_buffer_cache, + Default::default(), + None, )?; // Finally draw fullscreen quad, GPU will calculate scattering only on pixels that were @@ -214,42 +186,17 @@ impl LightVolumeRenderer { * Matrix4::new_nonuniform_scaling(&Vector3::new(k, k, k)); let mvp = view_proj * light_shape_matrix; - let uniform_buffer = - uniform_buffer_cache.write(StaticUniformBuffer::<256>::new().with(&mvp))?; - - stats += frame_buffer.draw( + let properties = PropertyGroup::from([property("worldViewProjection", &mvp)]); + let material = RenderMaterial::from([binding("properties", &properties)]); + stats += self.volume_marker.run_pass( + &ImmutableString::new("Primary"), + frame_buffer, &self.sphere, viewport, - &self.flat_shader.program, - &DrawParameters { - cull_face: None, - color_write: ColorMask::all(false), - depth_write: false, - stencil_test: Some(StencilFunc { - func: CompareFunc::Equal, - ref_value: 0xFF, - mask: 0xFFFF_FFFF, - }), - depth_test: Some(CompareFunc::Less), - blend: None, - stencil_op: StencilOp { - fail: StencilAction::Replace, - zfail: StencilAction::Keep, - zpass: StencilAction::Replace, - write_mask: 0xFFFF_FFFF, - }, - scissor_box: None, - }, - &[ResourceBindGroup { - bindings: &[ResourceBinding::Buffer { - buffer: uniform_buffer, - binding: BufferLocation::Auto { - shader_location: self.flat_shader.uniform_buffer_binding, - }, - data_usage: Default::default(), - }], - }], - ElementRange::Full, + &material, + uniform_buffer_cache, + Default::default(), + None, )?; // Finally draw fullscreen quad, GPU will calculate scattering only on pixels that were diff --git a/fyrox-impl/src/renderer/mod.rs b/fyrox-impl/src/renderer/mod.rs index 1710a88de3..71eb4f8e19 100644 --- a/fyrox-impl/src/renderer/mod.rs +++ b/fyrox-impl/src/renderer/mod.rs @@ -38,7 +38,6 @@ pub mod ui_renderer; pub mod visibility; mod bloom; -mod flat_shader; mod forward_renderer; mod fxaa; mod gbuffer; @@ -72,23 +71,24 @@ use crate::{ bloom::BloomRenderer, bundle::{ObserverInfo, RenderDataBundleStorage, RenderDataBundleStorageOptions}, cache::{ - geometry::GeometryCache, shader::ShaderCache, texture::TextureCache, - uniform::UniformBufferCache, uniform::UniformMemoryAllocator, + geometry::GeometryCache, + shader::{ + binding, property, PropertyGroup, RenderMaterial, RenderPassContainer, ShaderCache, + }, + texture::TextureCache, + uniform::{UniformBufferCache, UniformMemoryAllocator}, }, debug_renderer::DebugRenderer, - flat_shader::FlatShader, forward_renderer::{ForwardRenderContext, ForwardRenderer}, framework::{ - buffer::{BufferKind, BufferUsage}, + buffer::{BufferKind, BufferUsage, GpuBuffer}, error::FrameworkError, - framebuffer::{ - Attachment, AttachmentKind, BufferLocation, ResourceBindGroup, ResourceBinding, - }, + framebuffer::{Attachment, AttachmentKind, DrawCallStatistics, GpuFrameBuffer}, + geometry_buffer::GpuGeometryBuffer, gpu_program::SamplerFallback, - gpu_texture::{GpuTextureDescriptor, GpuTextureKind, PixelKind}, + gpu_texture::{GpuTexture, GpuTextureDescriptor, GpuTextureKind, PixelKind}, server::{GraphicsServer, SharedGraphicsServer}, - uniform::StaticUniformBuffer, - DrawParameters, ElementRange, GeometryBufferExt, PolygonFace, PolygonFillMode, + GeometryBufferExt, PolygonFace, PolygonFillMode, }, fxaa::FxaaRenderer, gbuffer::{GBuffer, GBufferRenderContext}, @@ -101,10 +101,6 @@ use crate::{ scene::{camera::Camera, mesh::surface::SurfaceData, Scene, SceneContainer}, }; use fxhash::FxHashMap; -use fyrox_graphics::buffer::GpuBuffer; -use fyrox_graphics::framebuffer::{DrawCallStatistics, GpuFrameBuffer}; -use fyrox_graphics::geometry_buffer::GpuGeometryBuffer; -use fyrox_graphics::gpu_texture::GpuTexture; use lazy_static::lazy_static; use serde::{Deserialize, Serialize}; pub use stats::*; @@ -660,7 +656,7 @@ pub struct Renderer { backbuffer: GpuFrameBuffer, scene_render_passes: Vec>>, deferred_light_renderer: DeferredLightRenderer, - flat_shader: FlatShader, + blit_shader: RenderPassContainer, /// A set of textures of certain kinds that could be used as a stub in cases when you don't have /// your own texture of this kind. pub fallback_resources: FallbackResources, @@ -844,40 +840,25 @@ fn blit_pixels( uniform_buffer_cache: &mut UniformBufferCache, framebuffer: &GpuFrameBuffer, texture: &GpuTexture, - shader: &FlatShader, + blit_shader: &RenderPassContainer, viewport: Rect, quad: &GpuGeometryBuffer, ) -> Result { - let matrix = make_viewport_matrix(viewport); - let uniform_buffer = - uniform_buffer_cache.write(StaticUniformBuffer::<256>::new().with(&matrix))?; - framebuffer.draw( + let wvp = make_viewport_matrix(viewport); + let properties = PropertyGroup::from([property("worldViewProjection", &wvp)]); + let material = RenderMaterial::from([ + binding("diffuseTexture", texture), + binding("properties", &properties), + ]); + blit_shader.run_pass( + &ImmutableString::new("Primary"), + framebuffer, quad, viewport, - &shader.program, - &DrawParameters { - cull_face: None, - color_write: Default::default(), - depth_write: true, - stencil_test: None, - depth_test: None, - blend: None, - stencil_op: Default::default(), - scissor_box: None, - }, - &[ResourceBindGroup { - bindings: &[ - ResourceBinding::texture(texture, &shader.diffuse_texture), - ResourceBinding::Buffer { - buffer: uniform_buffer, - binding: BufferLocation::Auto { - shader_location: shader.uniform_buffer_binding, - }, - data_usage: Default::default(), - }, - ], - }], - ElementRange::Full, + &material, + uniform_buffer_cache, + Default::default(), + None, ) } @@ -1019,14 +1000,16 @@ impl Renderer { backbuffer: server.back_buffer(), frame_size, deferred_light_renderer: DeferredLightRenderer::new(&*server, frame_size, &settings)?, - flat_shader: FlatShader::new(&*server)?, + blit_shader: RenderPassContainer::from_str( + &*server, + include_str!("shaders/blit.shader"), + )?, fallback_resources, quad: GpuGeometryBuffer::from_surface_data( &SurfaceData::make_unit_xy_quad(), BufferUsage::StaticDraw, &*server, )?, - ui_renderer: UiRenderer::new(&*server)?, quality_settings: settings, debug_renderer: DebugRenderer::new(&*server)?, @@ -1204,7 +1187,6 @@ impl Renderer { fallback_resources: &self.fallback_resources, texture_cache: &mut self.texture_cache, uniform_buffer_cache: &mut self.uniform_buffer_cache, - flat_shader: &self.flat_shader, })?; // Finally register texture in the cache so it will become available as texture in deferred/forward @@ -1532,7 +1514,7 @@ impl Renderer { &mut self.uniform_buffer_cache, &scene_associated_data.ldr_scene_framebuffer, temp_frame_texture, - &self.flat_shader, + &self.blit_shader, viewport, quad, )?; @@ -1583,7 +1565,7 @@ impl Renderer { &mut self.uniform_buffer_cache, &self.backbuffer, scene_associated_data.ldr_scene_frame_texture(), - &self.flat_shader, + &self.blit_shader, window_viewport, &self.quad, )?; @@ -1650,7 +1632,6 @@ impl Renderer { fallback_resources: &self.fallback_resources, texture_cache: &mut self.texture_cache, uniform_buffer_cache: &mut self.uniform_buffer_cache, - flat_shader: &self.flat_shader, })?; } diff --git a/fyrox-impl/src/renderer/shaders/blit.shader b/fyrox-impl/src/renderer/shaders/blit.shader new file mode 100644 index 0000000000..98a60fcd4d --- /dev/null +++ b/fyrox-impl/src/renderer/shaders/blit.shader @@ -0,0 +1,69 @@ +( + name: "Blit", + resources: [ + ( + name: "diffuseTexture", + kind: Texture(kind: Sampler2D, fallback: White), + binding: 0 + ), + ( + name: "properties", + kind: PropertyGroup([ + (name: "worldViewProjection", kind: Matrix4()), + ]), + binding: 0 + ), + ], + passes: [ + ( + name: "Primary", + + draw_parameters: DrawParameters( + cull_face: None, + color_write: ColorMask( + red: true, + green: true, + blue: true, + alpha: true, + ), + depth_write: true, + stencil_test: None, + depth_test: None, + blend: None, + stencil_op: StencilOp( + fail: Keep, + zfail: Keep, + zpass: Keep, + write_mask: 0xFFFF_FFFF, + ), + scissor_box: None + ), + + vertex_shader: + r#" + layout (location = 0) in vec3 vertexPosition; + layout (location = 1) in vec2 vertexTexCoord; + + out vec2 texCoord; + + void main() + { + texCoord = vertexTexCoord; + gl_Position = properties.worldViewProjection * vec4(vertexPosition, 1.0); + } + "#, + + fragment_shader: + r#" + out vec4 FragColor; + + in vec2 texCoord; + + void main() + { + FragColor = texture(diffuseTexture, texCoord); + } + "#, + ) + ] +) \ No newline at end of file diff --git a/fyrox-impl/src/renderer/shaders/flat_fs.glsl b/fyrox-impl/src/renderer/shaders/flat_fs.glsl deleted file mode 100644 index a447f8d846..0000000000 --- a/fyrox-impl/src/renderer/shaders/flat_fs.glsl +++ /dev/null @@ -1,10 +0,0 @@ -uniform sampler2D diffuseTexture; - -out vec4 FragColor; - -in vec2 texCoord; - -void main() -{ - FragColor = texture(diffuseTexture, texCoord); -} \ No newline at end of file diff --git a/fyrox-impl/src/renderer/shaders/flat_vs.glsl b/fyrox-impl/src/renderer/shaders/flat_vs.glsl deleted file mode 100644 index 649dfc4602..0000000000 --- a/fyrox-impl/src/renderer/shaders/flat_vs.glsl +++ /dev/null @@ -1,14 +0,0 @@ -layout (location = 0) in vec3 vertexPosition; -layout (location = 1) in vec2 vertexTexCoord; - -layout (std140) uniform Uniforms { - mat4 worldViewProjection; -}; - -out vec2 texCoord; - -void main() -{ - texCoord = vertexTexCoord; - gl_Position = worldViewProjection * vec4(vertexPosition, 1.0); -} \ No newline at end of file diff --git a/fyrox-impl/src/renderer/shaders/pixel_counter.shader b/fyrox-impl/src/renderer/shaders/pixel_counter.shader new file mode 100644 index 0000000000..84f32fb9f9 --- /dev/null +++ b/fyrox-impl/src/renderer/shaders/pixel_counter.shader @@ -0,0 +1,62 @@ +( + name: "PixelCounter", + resources: [ + ( + name: "properties", + kind: PropertyGroup([ + (name: "worldViewProjection", kind: Matrix4()), + ]), + binding: 0 + ), + ], + passes: [ + ( + name: "Primary", + + draw_parameters: DrawParameters( + cull_face: None, + color_write: ColorMask( + red: false, + green: false, + blue: false, + alpha: false, + ), + depth_write: false, + stencil_test: Some(StencilFunc ( + func: NotEqual, + ref_value: 0, + mask: 0xFFFF_FFFF, + )), + depth_test: None, + blend: None, + stencil_op: StencilOp( + fail: Keep, + zfail: Keep, + zpass: Keep, + write_mask: 0xFFFF_FFFF, + ), + scissor_box: None + ), + + vertex_shader: + r#" + layout (location = 0) in vec3 vertexPosition; + + void main() + { + gl_Position = properties.worldViewProjection * vec4(vertexPosition, 1.0); + } + "#, + + fragment_shader: + r#" + out vec4 FragColor; + + void main() + { + FragColor = vec4(1.0); + } + "#, + ) + ] +) \ No newline at end of file diff --git a/fyrox-impl/src/renderer/shaders/ui.shader b/fyrox-impl/src/renderer/shaders/ui.shader index a076c3254b..a842a57d7f 100644 --- a/fyrox-impl/src/renderer/shaders/ui.shader +++ b/fyrox-impl/src/renderer/shaders/ui.shader @@ -34,7 +34,7 @@ vertex_shader: r#" - layout (location = 0) in vec3 vertexPosition; + layout (location = 0) in vec2 vertexPosition; layout (location = 1) in vec2 vertexTexCoord; layout (location = 2) in vec4 vertexColor; @@ -45,7 +45,7 @@ { texCoord = vertexTexCoord; color = vertexColor; - gl_Position = properties.worldViewProjection * vec4(vertexPosition, 1.0); + gl_Position = properties.worldViewProjection * vec4(vertexPosition, 0.0, 1.0); } "#, @@ -117,6 +117,50 @@ fragColor *= color; } "#, + ), + ( + name: "Clip", + + draw_parameters: DrawParameters( + cull_face: None, + color_write: ColorMask( + red: false, + green: false, + blue: false, + alpha: false, + ), + depth_write: false, + stencil_test: None, + depth_test: None, + blend: None, + stencil_op: StencilOp( + fail: Keep, + zfail: Keep, + zpass: Incr, + write_mask: 0xFFFF_FFFF, + ), + scissor_box: None + ), + + vertex_shader: + r#" + layout (location = 0) in vec2 vertexPosition; + + void main() + { + gl_Position = properties.worldViewProjection * vec4(vertexPosition, 0.0, 1.0); + } + "#, + + fragment_shader: + r#" + out vec4 FragColor; + + void main() + { + FragColor = vec4(1.0); + } + "#, ) ] ) \ No newline at end of file diff --git a/fyrox-impl/src/renderer/shaders/volume_marker_lit.shader b/fyrox-impl/src/renderer/shaders/volume_marker_lit.shader new file mode 100644 index 0000000000..714a2d45e4 --- /dev/null +++ b/fyrox-impl/src/renderer/shaders/volume_marker_lit.shader @@ -0,0 +1,39 @@ +( + name: "VolumeMarkerLighting", + resources: [ + ( + name: "properties", + kind: PropertyGroup([ + (name: "worldViewProjection", kind: Matrix4()), + ]), + binding: 0 + ), + ], + passes: [ + ( + name: "Primary", + + // Drawing params are dynamic. + + vertex_shader: + r#" + layout (location = 0) in vec3 vertexPosition; + + void main() + { + gl_Position = properties.worldViewProjection * vec4(vertexPosition, 1.0); + } + "#, + + fragment_shader: + r#" + out vec4 FragColor; + + void main() + { + FragColor = vec4(1.0); + } + "#, + ) + ] +) \ No newline at end of file diff --git a/fyrox-impl/src/renderer/shaders/volume_marker_vol.shader b/fyrox-impl/src/renderer/shaders/volume_marker_vol.shader new file mode 100644 index 0000000000..d8ec418888 --- /dev/null +++ b/fyrox-impl/src/renderer/shaders/volume_marker_vol.shader @@ -0,0 +1,62 @@ +( + name: "VolumeMarkerVolume", + resources: [ + ( + name: "properties", + kind: PropertyGroup([ + (name: "worldViewProjection", kind: Matrix4()), + ]), + binding: 0 + ), + ], + passes: [ + ( + name: "Primary", + + draw_parameters: DrawParameters( + cull_face: None, + color_write: ColorMask( + red: false, + green: false, + blue: false, + alpha: false, + ), + depth_write: false, + stencil_test: Some(StencilFunc ( + func: Equal, + ref_value: 0xFF, + mask: 0xFFFF_FFFF + )), + depth_test: Some(Less), + blend: None, + stencil_op: StencilOp( + fail: Replace, + zfail: Keep, + zpass: Replace, + write_mask: 0xFFFF_FFFF, + ), + scissor_box: None + ), + + vertex_shader: + r#" + layout (location = 0) in vec3 vertexPosition; + + void main() + { + gl_Position = properties.worldViewProjection * vec4(vertexPosition, 1.0); + } + "#, + + fragment_shader: + r#" + out vec4 FragColor; + + void main() + { + FragColor = vec4(1.0); + } + "#, + ) + ] +) \ No newline at end of file diff --git a/fyrox-impl/src/renderer/ui_renderer.rs b/fyrox-impl/src/renderer/ui_renderer.rs index d610328b70..9ce6bec11e 100644 --- a/fyrox-impl/src/renderer/ui_renderer.rs +++ b/fyrox-impl/src/renderer/ui_renderer.rs @@ -37,19 +37,17 @@ use crate::{ shader::{binding, property, PropertyGroup, RenderMaterial, RenderPassContainer}, uniform::UniformBufferCache, }, - flat_shader::FlatShader, framework::{ buffer::BufferUsage, error::FrameworkError, - framebuffer::{BufferLocation, GpuFrameBuffer, ResourceBindGroup, ResourceBinding}, + framebuffer::GpuFrameBuffer, geometry_buffer::{ AttributeDefinition, AttributeKind, ElementsDescriptor, GeometryBufferDescriptor, GpuGeometryBuffer, VertexBufferData, VertexBufferDescriptor, }, server::GraphicsServer, - uniform::StaticUniformBuffer, BlendFactor, BlendFunc, BlendParameters, ColorMask, CompareFunc, DrawParameters, - ElementRange, ScissorBox, StencilAction, StencilFunc, StencilOp, + ElementRange, ScissorBox, StencilFunc, }, FallbackResources, RenderPassStatistics, TextureCache, }, @@ -83,8 +81,6 @@ pub struct UiRenderContext<'a, 'b, 'c> { pub texture_cache: &'a mut TextureCache, /// A reference to the cache of uniform buffers. pub uniform_buffer_cache: &'a mut UniformBufferCache, - /// A reference to the shader that will be used to draw clipping geometry. - pub flat_shader: &'a FlatShader, } impl UiRenderer { @@ -166,7 +162,6 @@ impl UiRenderer { fallback_resources, texture_cache, uniform_buffer_cache, - flat_shader, } = args; let mut statistics = RenderPassStatistics::default(); @@ -209,37 +204,18 @@ impl UiRenderer { self.clipping_geometry_buffer .set_triangles(&clipping_geometry.triangle_buffer); - let uniform_buffer = - uniform_buffer_cache.write(StaticUniformBuffer::<256>::new().with(&ortho))?; - // Draw - statistics += frame_buffer.draw( - &self.clipping_geometry_buffer, + let properties = PropertyGroup::from([property("worldViewProjection", &ortho)]); + let material = RenderMaterial::from([binding("properties", &properties)]); + statistics += self.render_passes.run_pass( + &ImmutableString::new("Clip"), + frame_buffer, + &self.geometry_buffer, viewport, - &flat_shader.program, - &DrawParameters { - cull_face: None, - color_write: ColorMask::all(false), - depth_write: false, - stencil_test: None, - depth_test: None, - blend: None, - stencil_op: StencilOp { - zpass: StencilAction::Incr, - ..Default::default() - }, - scissor_box, - }, - &[ResourceBindGroup { - bindings: &[ResourceBinding::Buffer { - buffer: uniform_buffer, - binding: BufferLocation::Auto { - shader_location: flat_shader.uniform_buffer_binding, - }, - data_usage: Default::default(), - }], - }], - ElementRange::Full, + &material, + uniform_buffer_cache, + Default::default(), + None, )?; // Make sure main geometry will be drawn only on marked pixels.