Initial Commit

.cargo/config.toml

@@ -0,0 +1,34 @@
+
+# Add the contents of this file to `config.toml` to enable "fast build" configuration. Please read the notes below.
+
+# NOTE: For maximum performance, build using a nightly compiler
+# If you are using rust stable, remove the "-Zshare-generics=y" below.
+
+[target.x86_64-unknown-linux-gnu]
+linker = "clang"
+rustflags = ["-Clink-arg=-fuse-ld=lld", "-Zshare-generics=y"]
+
+# NOTE: you must install [Mach-O LLD Port](https://lld.llvm.org/MachO/index.html) on mac. you can easily do this by installing llvm which includes lld with the "brew" package manager:
+# `brew install llvm`
+[target.x86_64-apple-darwin]
+rustflags = [
+    "-C",
+    "link-arg=-fuse-ld=/usr/local/opt/llvm/bin/ld64.lld",
+    "-Zshare-generics=y",
+]
+
+[target.aarch64-apple-darwin]
+rustflags = [
+    "-C",
+    "link-arg=-fuse-ld=/opt/homebrew/opt/llvm/bin/ld64.lld",
+    "-Zshare-generics=y",
+]
+
+[target.x86_64-pc-windows-msvc]
+linker = "rust-lld.exe"
+rustflags = ["-Zshare-generics=n"]
+
+# Optional: Uncommenting the following improves compile times, but reduces the amount of debug info to 'line number tables only'
+# In most cases the gains are negligible, but if you are on macos and have slow compile times you should see significant gains.
+#[profile.dev]
+#debug = 1

.gitignore

@@ -0,0 +1 @@
+/target

Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "grex_outline_post_process"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies.bevy]
+version = "0.13"
+features = ["dynamic_linking"]

assets/shaders/outline_post_process.wgsl

@@ -0,0 +1,45 @@
+#import bevy_core_pipeline::fullscreen_vertex_shader::FullscreenVertexOutput;
+
+struct OutlinePostProcessSettings {
+	weight: f32,
+	threshold: f32,
+#ifdef SIXTEEN_BYTE_ALIGNMENT
+	_padding: vec2<f32>,
+#endif
+}
+
+@group(0) @binding(0) var screen_texture: texture_2d<f32>;
+@group(0) @binding(1) var screen_sampler: sampler;
+@group(0) @binding(2) var normal_texture: texture_2d<f32>;
+@group(0) @binding(3) var normal_sampler: sampler;
+@group(0) @binding(4) var<uniform> settings: OutlinePostProcessSettings;
+
+@fragment
+fn fragment(
+	in: FullscreenVertexOutput
+) -> @location(0) vec4<f32> {
+    let screen_color = textureSample(screen_texture, screen_sampler, in.uv);
+    let outline_width = settings.weight / vec2f(textureDimensions(screen_texture)); 
+
+    let uv_top = vec2f(in.uv.x, in.uv.y - outline_width.y);
+    let uv_right = vec2f(in.uv.x + outline_width.x, in.uv.y);
+    let uv_top_right = vec2f(in.uv.x + outline_width.x, in.uv.y - outline_width.y);
+
+    let normal = textureSample(normal_texture, normal_sampler, in.uv);
+    let normal_top = textureSample(normal_texture, normal_sampler, uv_top);
+    let normal_right = textureSample(normal_texture, normal_sampler, uv_right);
+    let normal_top_right = textureSample(normal_texture, normal_sampler, uv_top_right);
+
+    let delta_top = abs(normal - normal_top);
+    let delta_right = abs(normal - normal_right);
+    let delta_top_right = abs(normal - normal_top_right);
+
+    let delta_max = max(delta_top, max(delta_right, delta_top_right));
+    let delta_raw = max(delta_max.x, max(delta_max.y, delta_max.z));
+
+    let delta_clipped = clamp((delta_raw * 2.0) - settings.threshold, 0.0, 1.0);
+
+    let outline = vec4f(delta_clipped, delta_clipped, delta_clipped, 0.0);
+
+    return screen_color - outline;
+}

src/components.rs

@@ -0,0 +1,9 @@
+use bevy::{prelude::*, render::{render_resource::ShaderType, extract_component::ExtractComponent}};
+
+#[derive(Component, ShaderType, ExtractComponent, PartialEq, Clone, Default)]
+pub struct OutlinePostProcessSettings {
+    pub weight: f32,
+    pub threshold: f32,
+    #[cfg(feature = "webgl2")]
+    _padding: Vec2,
+}

src/lib.rs

@@ -0,0 +1,42 @@
+use bevy::{prelude::*, render::{RenderApp, extract_component::{UniformComponentPlugin, ExtractComponentPlugin}, render_graph::{RenderGraphApp, ViewNodeRunner}}, asset::embedded_asset, core_pipeline::core_3d::graph::{Core3d, Node3d}};
+
+pub struct OutlinePostProcessPlugin;
+
+pub mod components;
+mod resources;
+mod nodes;
+
+impl Plugin for OutlinePostProcessPlugin {
+    fn build(&self, app: &mut App) {
+        embedded_asset!(app, "../assets/shaders/outline_post_process.wgsl");
+
+        app.add_plugins((
+            UniformComponentPlugin::<components::OutlinePostProcessSettings>::default(),
+            ExtractComponentPlugin::<components::OutlinePostProcessSettings>::default(),
+        ));
+    
+        let Ok(render_app) = app.get_sub_app_mut(RenderApp) else {
+            return;
+        };
+
+        render_app.add_render_graph_node::<ViewNodeRunner<nodes::OutlineRenderNode>>(
+            Core3d,
+            nodes::OutlineRenderLabel,
+        ).add_render_graph_edges(
+            Core3d, 
+            (
+                Node3d::Tonemapping,
+                nodes::OutlineRenderLabel,
+                Node3d::EndMainPassPostProcessing,
+            ),
+        );
+    }
+    
+    fn finish(&self, app: &mut App) {
+        let Ok(render_app) = app.get_sub_app_mut(RenderApp) else {
+            return;
+        };
+
+        render_app.init_resource::<resources::OutlinePostProcessPipeline>();
+    }
+}

src/nodes.rs

@@ -0,0 +1,75 @@
+use bevy::{prelude::*, render::{render_graph::{ViewNode, NodeRunError, RenderGraphContext, RenderLabel}, view::ViewTarget, renderer::RenderContext, render_resource::{PipelineCache, BindGroupEntries, RenderPassDescriptor, RenderPassColorAttachment, Operations}, extract_component::ComponentUniforms}, core_pipeline::prepass::ViewPrepassTextures, ecs::query::QueryItem};
+
+use super::components;
+use super::resources;
+
+#[derive(RenderLabel, Clone, Eq, PartialEq, Hash, Debug)]
+pub struct OutlineRenderLabel;
+
+#[derive(Default)]
+pub struct OutlineRenderNode;
+
+impl ViewNode for OutlineRenderNode {
+    type ViewQuery = (
+        &'static ViewTarget,
+        &'static ViewPrepassTextures,
+        &'static components::OutlinePostProcessSettings,
+    );
+
+    fn run(
+        &self,
+        _graph: &mut RenderGraphContext,
+        render_context: &mut RenderContext,
+        (view_target, view_prepass_textures, _): QueryItem<Self::ViewQuery>,
+        world: &World,
+    ) -> Result<(), NodeRunError> {
+        let render_pipeline = world.resource::<resources::OutlinePostProcessPipeline>();
+        let pipeline_cache = world.resource::<PipelineCache>();
+        let Some(pipeline) = pipeline_cache.get_render_pipeline(render_pipeline.pipeline_id) else {
+            warn!("Failed to get render pipeline from cache, skipping...");
+            return Ok(());
+        };
+
+        let uniforms = world.resource::<ComponentUniforms<components::OutlinePostProcessSettings>>();
+        let Some(uniform_binding) = uniforms.uniforms().binding() else {
+            error!("Failed to get settings uniform binding");
+            return Ok(());
+        };
+
+        let Some(normal_buffer_view) = view_prepass_textures.normal_view() else {
+            error!("Failed to get normal buffer view");
+            return Ok(());
+        };
+
+        let post_process = view_target.post_process_write();
+
+        let bind_group = render_context.render_device().create_bind_group(
+            "outline_post_process_bind_group",
+            &render_pipeline.layout,
+            &BindGroupEntries::sequential((
+                post_process.source,
+                &render_pipeline.screen_sampler,
+                normal_buffer_view,
+                &render_pipeline.normal_sampler,
+                uniform_binding,
+            )),
+        );
+
+        let mut render_pass = render_context.begin_tracked_render_pass(RenderPassDescriptor {
+            label: Some("outline_post_process_render_pass"),
+            color_attachments: &[Some(RenderPassColorAttachment {
+                view: post_process.destination,
+                ops: Operations::default(),
+                resolve_target: None,
+            })],
+            timestamp_writes: None,
+            depth_stencil_attachment: None,
+            occlusion_query_set: None,
+        });
+
+        render_pass.set_render_pipeline(pipeline);
+        render_pass.set_bind_group(0, &bind_group, &[]);
+        render_pass.draw(0..3, 0..1);
+        Ok(())
+    }
+}

src/resources.rs

@@ -0,0 +1,63 @@
+use bevy::{prelude::*, render::{render_resource::{Sampler, BindGroupLayout, BindGroupLayoutEntries, ShaderStages, binding_types::{texture_2d, sampler, uniform_buffer}, TextureSampleType, SamplerBindingType, SamplerDescriptor, PipelineCache, RenderPipelineDescriptor, CachedRenderPipelineId, PrimitiveState, MultisampleState, FragmentState, ColorTargetState, TextureFormat, ColorWrites}, renderer::RenderDevice, texture::BevyDefault}, core_pipeline::fullscreen_vertex_shader::fullscreen_shader_vertex_state};
+
+use super::components;
+
+#[derive(Resource)]
+pub struct OutlinePostProcessPipeline {
+    pub layout: BindGroupLayout,
+    pub screen_sampler: Sampler,
+    pub normal_sampler: Sampler,
+    pub pipeline_id: CachedRenderPipelineId,
+}
+
+impl FromWorld for OutlinePostProcessPipeline {
+    fn from_world(world: &mut World) -> Self {
+        let render_device = world.resource::<RenderDevice>();
+
+        let layout = render_device.create_bind_group_layout(
+            "outline_post_process_bind_group_layout",
+            &BindGroupLayoutEntries::sequential(
+                ShaderStages::FRAGMENT,
+                (
+                    texture_2d(TextureSampleType::Float{ filterable: true }),
+                    sampler(SamplerBindingType::Filtering),
+                    texture_2d(TextureSampleType::Float{ filterable: true }),
+                    sampler(SamplerBindingType::Filtering),
+                    uniform_buffer::<components::OutlinePostProcessSettings>(false),
+                ),
+            ),
+        );
+
+        let screen_sampler = render_device.create_sampler(&SamplerDescriptor::default());
+        let normal_sampler = render_device.create_sampler(&SamplerDescriptor::default());
+
+        let shader = world.resource::<AssetServer>().load::<Shader>("embedded://grex_outline_post_process/../assets/shaders/outline_post_process.wgsl");
+        
+        let pipeline_id = world.resource_mut::<PipelineCache>().queue_render_pipeline(RenderPipelineDescriptor {
+            label: Some("outline_post_process_render_pipeline".into()),
+            layout: vec![layout.clone()],
+            push_constant_ranges: vec![],
+            vertex: fullscreen_shader_vertex_state(),
+            primitive: PrimitiveState::default(),
+            depth_stencil: None,
+            multisample: MultisampleState::default(),
+            fragment: Some(FragmentState {
+                shader,
+                shader_defs: vec![],
+                entry_point: "fragment".into(),
+                targets: vec![Some(ColorTargetState { 
+                    format: TextureFormat::bevy_default(),
+                    blend: None,
+                    write_mask: ColorWrites::ALL, 
+                })],
+            }),
+        });
+
+        Self {
+            layout,
+            screen_sampler,
+            normal_sampler,
+            pipeline_id,
+        }
+    }
+}