eric/matrix
1
0
Fork 0
mirror of https://github.com/Rezmason/matrix.git synced 2026-04-17 13:59:30 -07:00
Code Issues Packages Projects Releases Wiki Activity

All the post processing passes are now based on compute pipelines instead of render pipelines.

Browse Source
This commit is contained in:
Rezmason
2021-11-11 21:50:27 -08:00
parent 9ad655ca2e
commit db928bbe7a
13 changed files with 157 additions and 335 deletions
Download Patch File Download Diff File Expand all files Collapse all files

31
shaders/wgsl/imagePass.wgsl
View File

@@ -2,29 +2,30 @@
[[group(0), binding(1)]] var tex : texture_2d<f32>;
[[group(0), binding(2)]] var bloomTex : texture_2d<f32>;
[[group(0), binding(3)]] var backgroundTex : texture_2d<f32>;
[[group(0), binding(4)]] var outputTex : texture_storage_2d<rgba8unorm, write>;
struct VertOutput {
[[builtin(position)]] Position : vec4<f32>;
[[location(0)]] uv : vec2<f32>;
struct ComputeInput {
[[builtin(global_invocation_id)]] id : vec3<u32>;
};
[[stage(vertex)]] fn vertMain([[builtin(vertex_index)]] index : u32) -> VertOutput {
var uv = vec2<f32>(f32(index % 2u), f32((index + 1u) % 6u / 3u));
var position = vec4<f32>(uv * 2.0 - 1.0, 1.0, 1.0);
return VertOutput(position, uv);
}
[[stage(compute), workgroup_size(32, 1, 1)]] fn computeMain(input : ComputeInput) {
[[stage(fragment)]] fn fragMain(input : VertOutput) -> [[location(0)]] vec4<f32> {
// Resolve the invocation ID to a single cell
var coord = vec2<i32>(input.id.xy);
var screenSize = textureDimensions(tex);
var uv = input.uv;
uv.y = 1.0 - uv.y;
if (coord.x >= screenSize.x) {
return;
}
var bgColor = textureSample( backgroundTex, linearSampler, uv ).rgb;
var uv = vec2<f32>(coord) / vec2<f32>(screenSize);
var bgColor = textureSampleLevel( backgroundTex, linearSampler, uv, 0.0 ).rgb;
// Combine the texture and bloom, then blow it out to reveal more of the image
var brightness = min(1.0, textureSample( tex, linearSampler, uv ).r * 2.0);
brightness = brightness + textureSample( bloomTex, linearSampler, uv ).r;
var brightness = min(1.0, textureSampleLevel( tex, linearSampler, uv, 0.0 ).r * 2.0);
brightness = brightness + textureSampleLevel( bloomTex, linearSampler, uv, 0.0 ).r;
brightness = pow(brightness, 1.5);
return vec4<f32>(bgColor * brightness, 1.0);
textureStore(outputTex, coord, vec4<f32>(bgColor * brightness, 1.0));
}

29
shaders/wgsl/palettePass.wgsl
View File

@@ -18,10 +18,10 @@
[[group(0), binding(3)]] var linearSampler : sampler;
[[group(0), binding(4)]] var tex : texture_2d<f32>;
[[group(0), binding(5)]] var bloomTex : texture_2d<f32>;
[[group(0), binding(6)]] var outputTex : texture_storage_2d<rgba8unorm, write>;
struct VertOutput {
[[builtin(position)]] Position : vec4<f32>;
[[location(0)]] uv : vec2<f32>;
struct ComputeInput {
[[builtin(global_invocation_id)]] id : vec3<u32>;
};
let PI : f32 = 3.14159265359;
@@ -35,18 +35,20 @@ fn randomFloat( uv : vec2<f32> ) -> f32 {
return fract(sin(sn) * c);
}
[[stage(vertex)]] fn vertMain([[builtin(vertex_index)]] index : u32) -> VertOutput {
var uv = vec2<f32>(f32(index % 2u), f32((index + 1u) % 6u / 3u));
var position = vec4<f32>(uv * 2.0 - 1.0, 1.0, 1.0);
return VertOutput(position, uv);
}
[[stage(fragment)]] fn fragMain(input : VertOutput) -> [[location(0)]] vec4<f32> {
[[stage(compute), workgroup_size(32, 1, 1)]] fn computeMain(input : ComputeInput) {
var uv = input.uv;
uv.y = 1.0 - uv.y;
// Resolve the invocation ID to a single cell
var coord = vec2<i32>(input.id.xy);
var screenSize = textureDimensions(tex);
var brightnessRGB = textureSample( tex, linearSampler, uv ) + textureSample( bloomTex, linearSampler, uv );
if (coord.x >= screenSize.x) {
return;
}
var uv = vec2<f32>(coord) / vec2<f32>(screenSize);
var brightnessRGB = textureSampleLevel( tex, linearSampler, uv, 0.0 ) + textureSampleLevel( bloomTex, linearSampler, uv, 0.0 );
// Combine the texture and bloom
var brightness = brightnessRGB.r + brightnessRGB.g + brightnessRGB.b;
@@ -57,5 +59,6 @@ fn randomFloat( uv : vec2<f32> ) -> f32 {
var paletteIndex = clamp(i32(brightness * 512.0), 0, 511);
// Map the brightness to a position in the palette texture
return vec4<f32>(palette.colors[paletteIndex] + config.backgroundColor, 1.0);
textureStore(outputTex, coord, vec4<f32>(palette.colors[paletteIndex] + config.backgroundColor, 1.0));
}

66
shaders/wgsl/postProcessingPass.wgsl
View File

@@ -1,66 +0,0 @@
[[block]] struct Config {
foo : i32;
};
// The properties that change over time get their own buffer.
[[block]] struct Time {
seconds : f32;
frames : i32;
};
[[group(0), binding(0)]] var<uniform> config : Config;
[[group(0), binding(1)]] var<uniform> time : Time;
[[group(0), binding(2)]] var inputTex : texture_2d<f32>;
[[group(0), binding(3)]] var outputTex : texture_storage_2d<rgba8unorm, write>;
// Shader params
struct ComputeInput {
[[builtin(global_invocation_id)]] id : vec3<u32>;
};
// Constants
let NUM_VERTICES_PER_QUAD : i32 = 6; // 2 * 3
let PI : f32 = 3.14159265359;
let TWO_PI : f32 = 6.28318530718;
let SQRT_2 : f32 = 1.4142135623730951;
let SQRT_5 : f32 = 2.23606797749979;
// Helper functions for generating randomness, borrowed from elsewhere
fn randomFloat( uv : vec2<f32> ) -> f32 {
let a = 12.9898;
let b = 78.233;
let c = 43758.5453;
let dt = dot( uv, vec2<f32>( a, b ) );
let sn = dt % PI;
return fract(sin(sn) * c);
}
fn randomVec2( uv : vec2<f32> ) -> vec2<f32> {
return fract(vec2<f32>(sin(uv.x * 591.32 + uv.y * 154.077), cos(uv.x * 391.32 + uv.y * 49.077)));
}
fn wobble(x : f32) -> f32 {
return x + 0.3 * sin(SQRT_2 * x) + 0.2 * sin(SQRT_5 * x);
}
[[stage(compute), workgroup_size(32, 1, 1)]] fn computeMain(input : ComputeInput) {
// Resolve the invocation ID to a single cell
var coord = vec2<i32>(input.id.xy);
var screenSize = textureDimensions(inputTex);
if (coord.x >= screenSize.x) {
return;
}
var foo = config.foo;
var seconds = time.seconds;
var inputColor = textureLoad(inputTex, coord, 0);
var outputColor = inputColor;
textureStore(outputTex, coord, outputColor);
}

32
shaders/wgsl/resurrectionPass.wgsl
View File

@@ -13,10 +13,10 @@
[[group(0), binding(2)]] var linearSampler : sampler;
[[group(0), binding(3)]] var tex : texture_2d<f32>;
[[group(0), binding(4)]] var bloomTex : texture_2d<f32>;
[[group(0), binding(5)]] var outputTex : texture_storage_2d<rgba8unorm, write>;
struct VertOutput {
[[builtin(position)]] Position : vec4<f32>;
[[location(0)]] uv : vec2<f32>;
struct ComputeInput {
[[builtin(global_invocation_id)]] id : vec3<u32>;
};
let PI : f32 = 3.14159265359;
@@ -55,36 +55,36 @@ fn hslToRgb(h : f32, s : f32, l : f32) -> vec3<f32> {
);
}
[[stage(vertex)]] fn vertMain([[builtin(vertex_index)]] index : u32) -> VertOutput {
var uv = vec2<f32>(f32(index % 2u), f32((index + 1u) % 6u / 3u));
var position = vec4<f32>(uv * 2.0 - 1.0, 1.0, 1.0);
return VertOutput(position, uv);
}
[[stage(compute), workgroup_size(32, 1, 1)]] fn computeMain(input : ComputeInput) {
[[stage(fragment)]] fn fragMain(input : VertOutput) -> [[location(0)]] vec4<f32> {
// Resolve the invocation ID to a single cell
var coord = vec2<i32>(input.id.xy);
var screenSize = textureDimensions(tex);
var uv = input.uv;
uv.y = 1.0 - uv.y;
if (coord.x >= screenSize.x) {
return;
}
var uv = vec2<f32>(coord) / vec2<f32>(screenSize);
// Mix the texture and bloom based on distance from center,
// to approximate a lens blur
var brightness = mix(
textureSample( tex, linearSampler, uv ).rgb,
textureSample( bloomTex, linearSampler, uv ).rgb,
(0.7 - length(input.uv - 0.5))
textureSampleLevel( tex, linearSampler, uv, 0.0 ).rgb,
textureSampleLevel( bloomTex, linearSampler, uv, 0.0 ).rgb,
(0.7 - length(uv - 0.5))
) * 1.25;
// Dither: subtract a random value from the brightness
brightness = brightness - randomFloat( uv + vec2<f32>(time.seconds) ) * config.ditherMagnitude;
// Calculate a hue based on distance from center
var hue = 0.35 + (length(input.uv - vec2<f32>(0.5, 1.0)) * -0.4 + 0.2);
var hue = 0.35 + (length(uv - vec2<f32>(0.5, 1.0)) * -0.4 + 0.2);
// Convert HSL to RGB
var rgb = hslToRgb(hue, 0.8, max(0., brightness.r)) * vec3<f32>(0.8, 1.0, 0.7);
// Calculate a separate RGB for upward-flowing glyphs
var resurrectionRGB = hslToRgb(0.13, 1.0, max(0., brightness.g) * 0.9);
return vec4<f32>(rgb + resurrectionRGB + config.backgroundColor, 1.0);
textureStore(outputTex, coord, vec4<f32>(rgb + resurrectionRGB + config.backgroundColor, 1.0));
}

31
shaders/wgsl/stripePass.wgsl
View File

@@ -14,10 +14,10 @@
[[group(0), binding(3)]] var tex : texture_2d<f32>;
[[group(0), binding(4)]] var bloomTex : texture_2d<f32>;
[[group(0), binding(5)]] var stripeTexture : texture_2d<f32>;
[[group(0), binding(6)]] var outputTex : texture_storage_2d<rgba8unorm, write>;
struct VertOutput {
[[builtin(position)]] Position : vec4<f32>;
[[location(0)]] uv : vec2<f32>;
struct ComputeInput {
[[builtin(global_invocation_id)]] id : vec3<u32>;
};
let PI : f32 = 3.14159265359;
@@ -31,25 +31,26 @@ fn randomFloat( uv : vec2<f32> ) -> f32 {
return fract(sin(sn) * c);
}
[[stage(vertex)]] fn vertMain([[builtin(vertex_index)]] index : u32) -> VertOutput {
var uv = vec2<f32>(f32(index % 2u), f32((index + 1u) % 6u / 3u));
var position = vec4<f32>(uv * 2.0 - 1.0, 1.0, 1.0);
return VertOutput(position, uv);
}
[[stage(compute), workgroup_size(32, 1, 1)]] fn computeMain(input : ComputeInput) {
[[stage(fragment)]] fn fragMain(input : VertOutput) -> [[location(0)]] vec4<f32> {
// Resolve the invocation ID to a single cell
var coord = vec2<i32>(input.id.xy);
var screenSize = textureDimensions(tex);
var uv = input.uv;
uv.y = 1.0 - uv.y;
if (coord.x >= screenSize.x) {
return;
}
var color = textureSample( stripeTexture, linearSampler, uv ).rgb;
var uv = vec2<f32>(coord) / vec2<f32>(screenSize);
var color = textureSampleLevel( stripeTexture, linearSampler, uv, 0.0 ).rgb;
// Combine the texture and bloom
var brightness = min(1.0, textureSample( tex, linearSampler, uv ).r * 2.0);
brightness = brightness + textureSample( bloomTex, linearSampler, uv ).r;
var brightness = min(1.0, textureSampleLevel( tex, linearSampler, uv, 0.0 ).r * 2.0);
brightness = brightness + textureSampleLevel( bloomTex, linearSampler, uv, 0.0 ).r;
// Dither: subtract a random value from the brightness
brightness = brightness - randomFloat( uv + vec2<f32>(time.seconds) ) * config.ditherMagnitude;
return vec4<f32>(color * brightness + config.backgroundColor, 1.0);
textureStore(outputTex, coord, vec4<f32>(color * brightness + config.backgroundColor, 1.0));
}