116 lines
3.6 KiB
WebGPU Shading Language
116 lines
3.6 KiB
WebGPU Shading Language
struct Settings {
|
|
colorA: vec3<f32>,
|
|
backgroundColorPadding0: f32,
|
|
colorB: vec3<f32>,
|
|
backgroundColorPadding1: f32,
|
|
colorC: vec3<f32>,
|
|
backgroundColorPadding2: f32,
|
|
backgroundColor: vec3<f32>,
|
|
clarity: f32,
|
|
traceNormalizationFloor: f32,
|
|
brushColorBase: f32,
|
|
brushColorStrengthMultiplier: f32,
|
|
backgroundGrainStrength: f32,
|
|
};
|
|
|
|
@group(1) @binding(0) var<uniform> settings: Settings;
|
|
@group(1) @binding(2) var trailMap: texture_2d<f32>;
|
|
@group(1) @binding(3) var sourceMap: texture_2d<f32>;
|
|
|
|
const NOISE_TEXTURE_MASK = 2047u;
|
|
|
|
@fragment
|
|
fn fragment(@builtin(position) position: vec4<f32>) -> @location(0) vec4<f32> {
|
|
let pixel = vec2<i32>(position.xy);
|
|
let traces = textureLoad(trailMap, pixel, 0);
|
|
let sources = textureLoad(sourceMap, pixel, 0);
|
|
return renderColor(traces, sources, pixel);
|
|
}
|
|
|
|
@fragment
|
|
fn fragmentNoSource(@builtin(position) position: vec4<f32>) -> @location(0) vec4<f32> {
|
|
let pixel = vec2<i32>(position.xy);
|
|
let traces = textureLoad(trailMap, pixel, 0);
|
|
return renderColor(traces, vec4<f32>(0.0), pixel);
|
|
}
|
|
|
|
fn renderColor(traces: vec4<f32>, sources: vec4<f32>, pixel: vec2<i32>) -> vec4<f32> {
|
|
let background = getTexturedBackground(pixel);
|
|
let tracesMax = maxComponent(traces.rgb);
|
|
let sourcesMax = maxComponent(sources.rgb);
|
|
if max(tracesMax, sourcesMax) <= 0.0 {
|
|
return vec4(background, 1);
|
|
}
|
|
|
|
let traceStrengths = vec3(
|
|
clarity(traces.r),
|
|
clarity(traces.g),
|
|
clarity(traces.b)
|
|
);
|
|
if sourcesMax <= 0.0 {
|
|
let traceColor =
|
|
traceStrengths.r * settings.colorA
|
|
+ traceStrengths.g * settings.colorB
|
|
+ traceStrengths.b * settings.colorC;
|
|
let normalizedTraceColor = normalizeColorIntensity(traceColor);
|
|
let traceStrength = maxComponent(traceStrengths);
|
|
return vec4(mix(background, clamp(normalizedTraceColor, vec3(0), vec3(1)), traceStrength), 1);
|
|
}
|
|
|
|
let sourceStrengths = vec3(
|
|
clarity(sources.r),
|
|
clarity(sources.g),
|
|
clarity(sources.b)
|
|
);
|
|
let strengths = max(traceStrengths, sourceStrengths);
|
|
let traceColor =
|
|
strengths.r * settings.colorA
|
|
+ strengths.g * settings.colorB
|
|
+ strengths.b * settings.colorC;
|
|
let normalizedTraceColor = normalizeColorIntensity(traceColor);
|
|
let brushColor =
|
|
sourceStrengths.r * settings.colorA
|
|
+ sourceStrengths.g * settings.colorB
|
|
+ sourceStrengths.b * settings.colorC;
|
|
let normalizedBrushColor = normalizeColorIntensity(brushColor);
|
|
let brushStrength = maxComponent(sourceStrengths);
|
|
let brushVisibility = clamp(
|
|
brushStrength * (
|
|
settings.brushColorBase +
|
|
brushStrength * settings.brushColorStrengthMultiplier
|
|
),
|
|
0,
|
|
1
|
|
);
|
|
let color = max(normalizedTraceColor, normalizedBrushColor);
|
|
|
|
let strength = max(maxComponent(strengths), brushVisibility);
|
|
return vec4(mix(background, clamp(color, vec3(0), vec3(1)), strength), 1);
|
|
}
|
|
|
|
fn maxComponent(v: vec3<f32>) -> f32 {
|
|
return max(max(v.r, v.g), v.b);
|
|
}
|
|
|
|
fn clarity(strength: f32) -> f32 {
|
|
return pow(clamp(strength, 0, 1), settings.clarity);
|
|
}
|
|
|
|
fn normalizeColorIntensity(color: vec3<f32>) -> vec3<f32> {
|
|
let brightestChannel = maxComponent(color);
|
|
return color / max(settings.traceNormalizationFloor, brightestChannel);
|
|
}
|
|
|
|
fn getTexturedBackground(pixel: vec2<i32>) -> vec3<f32> {
|
|
if settings.backgroundGrainStrength == 0.0 {
|
|
return clamp(settings.backgroundColor, vec3(0), vec3(1));
|
|
}
|
|
let noiseCoord = vec2<i32>(vec2<u32>(pixel) & vec2<u32>(NOISE_TEXTURE_MASK));
|
|
let grain = textureLoad(noise, noiseCoord, 0).r - 0.5;
|
|
|
|
return clamp(
|
|
settings.backgroundColor + vec3(grain * settings.backgroundGrainStrength),
|
|
vec3(0),
|
|
vec3(1)
|
|
);
|
|
}
|