From 0dc873e73f3ad6ec9edb2c22c428ece2ec0f226e Mon Sep 17 00:00:00 2001 From: MMJuno <38060865+MMJuno@users.noreply.github.com> Date: Tue, 24 Apr 2018 02:23:27 -0400 Subject: [PATCH 1/2] Add files via upload Initial version for trying to split up the shader to multi-pass in order to allow further adjustments of the outlines. Higher outline blur and weight settings will thicken up the lines for higher internal resolutions. --- cel/MMJ_Cel_Shader_MP.slangp | 13 +++++++++++++ 1 file changed, 13 insertions(+) create mode 100644 cel/MMJ_Cel_Shader_MP.slangp diff --git a/cel/MMJ_Cel_Shader_MP.slangp b/cel/MMJ_Cel_Shader_MP.slangp new file mode 100644 index 0000000..36ed9af --- /dev/null +++ b/cel/MMJ_Cel_Shader_MP.slangp @@ -0,0 +1,13 @@ +shaders = 4 + +shader0 = shaders/MMJ_Cel_Shader_MP_Blur_H.slang +alias0 = MMJ_BlurPass_H + +shader1 = shaders/MMJ_Cel_Shader_MP_Blur_V.slang +alias1 = MMJ_BlurPass_V + +shader2 = shaders/MMJ_Cel_Shader_MP_Outline.slang +alias2 = MMJ_OutlinePass + +shader3 = shaders/MMJ_Cel_Shader_MP_Color.slang +alias3 = MMJ_ColorPass From ed7e1452bb0838889a8ea1ba8b74da8352f02f51 Mon Sep 17 00:00:00 2001 From: MMJuno <38060865+MMJuno@users.noreply.github.com> Date: Tue, 24 Apr 2018 02:24:04 -0400 Subject: [PATCH 2/2] Add files via upload Initial version for trying to split up the shader to multi-pass in order to allow further adjustments of the outlines. Higher outline blur and weight settings will thicken up the lines for higher internal resolutions. --- cel/shaders/MMJ_Cel_Shader_MP_Blur_H.slang | 65 +++++++++ cel/shaders/MMJ_Cel_Shader_MP_Blur_V.slang | 67 +++++++++ cel/shaders/MMJ_Cel_Shader_MP_Color.slang | 152 ++++++++++++++++++++ cel/shaders/MMJ_Cel_Shader_MP_Outline.slang | 120 ++++++++++++++++ 4 files changed, 404 insertions(+) create mode 100644 cel/shaders/MMJ_Cel_Shader_MP_Blur_H.slang create mode 100644 cel/shaders/MMJ_Cel_Shader_MP_Blur_V.slang create mode 100644 cel/shaders/MMJ_Cel_Shader_MP_Color.slang create mode 100644 cel/shaders/MMJ_Cel_Shader_MP_Outline.slang diff --git a/cel/shaders/MMJ_Cel_Shader_MP_Blur_H.slang b/cel/shaders/MMJ_Cel_Shader_MP_Blur_H.slang new file mode 100644 index 0000000..c6c1532 --- /dev/null +++ b/cel/shaders/MMJ_Cel_Shader_MP_Blur_H.slang @@ -0,0 +1,65 @@ +#version 450 + +#pragma name MMJ_BlurPass_H + +/* +---------------------------------------------------------------- +MMJ's Cel Shader v2.0 - Multi-Pass +---------------------------------------------------------------- +Based on the original blur-gauss-h shader code. + +Used to blur the outlines, which is helpful at higher internal +resolution settings to increase the line thickness. + +Parameters: +----------- +Blur Weight - Horizontal = Adjusts horizontal blur factor. +---------------------------------------------------------------- +*/ + +layout(push_constant) uniform Push +{ + vec4 SourceSize; + float BlurWeightH; +} params; + +#pragma parameter BlurWeightH "Blur Weight - Horizontal" 0.0 0.0 16.0 1.0 + +#define SourceSize params.SourceSize +#define BlurWeightH params.BlurWeightH + +layout(std140, set = 0, binding = 0) uniform UBO +{ + mat4 MVP; +} global; + + +#pragma stage vertex +layout(location = 0) in vec4 Position; +layout(location = 1) in vec2 TexCoord; +layout(location = 0) out vec2 vTexCoord; + +void main() +{ + gl_Position = global.MVP * Position; + vTexCoord = TexCoord; +} + + +#pragma stage fragment +layout(location = 0) in vec2 vTexCoord; +layout(location = 0) out vec4 FragColor; +layout(set = 0, binding = 2) uniform sampler2D Source; + +void main() +{ + vec2 PIXEL_SIZE = SourceSize.zw; + vec4 C = texture(Source, vTexCoord); + float L = 0.0, J = 0.0; + for(int i = 1; i <= BlurWeightH; ++i) { + L = 1.0 / i; + J = 0.5 * i * PIXEL_SIZE.x; + C = mix(C, mix(texture(Source, vTexCoord + vec2(J, 0.0)), texture(Source, vTexCoord - vec2(J, 0.0)), 0.5), L); + } + FragColor = C; +} \ No newline at end of file diff --git a/cel/shaders/MMJ_Cel_Shader_MP_Blur_V.slang b/cel/shaders/MMJ_Cel_Shader_MP_Blur_V.slang new file mode 100644 index 0000000..faa6cf4 --- /dev/null +++ b/cel/shaders/MMJ_Cel_Shader_MP_Blur_V.slang @@ -0,0 +1,67 @@ +#version 450 + +#pragma name MMJ_BlurPass_V + +/* +---------------------------------------------------------------- +MMJ's Cel Shader v2.0 - Multi-Pass +---------------------------------------------------------------- +Based on the original blur-gauss-v shader code. + +Used to blur the outlines, which is helpful at higher internal +resolution settings to increase the line thickness. + +Parameters: +----------- +Blur Weight - Vertical = Adjusts vertical blur factor. +---------------------------------------------------------------- +*/ + +layout(push_constant) uniform Push +{ + vec4 MMJ_BlurPass_HSize; + vec4 OriginalSize; + float BlurWeightV; +} params; + +#pragma parameter BlurWeightV "Blur Weight - Vertical" 0.0 0.0 16.0 1.0 + +#define MMJ_BlurPass_HSize params.MMJ_BlurPass_HSize +#define OriginalSize params.OriginalSize +#define BlurWeightV params.BlurWeightV + +layout(std140, set = 0, binding = 0) uniform UBO +{ + mat4 MVP; +} global; + + +#pragma stage vertex +layout(location = 0) in vec4 Position; +layout(location = 1) in vec2 TexCoord; +layout(location = 0) out vec2 vTexCoord; + +void main() +{ + gl_Position = global.MVP * Position; + vTexCoord = TexCoord; +} + + +#pragma stage fragment +layout(location = 0) in vec2 vTexCoord; +layout(location = 0) out vec4 FragColor; +layout(set = 0, binding = 2) uniform sampler2D MMJ_BlurPass_H; + +void main() +{ + vec2 PIXEL_SIZE = OriginalSize.zw; + vec4 C = texture(MMJ_BlurPass_H, vTexCoord); + float L = 0.0, J = 0.0; + for(int i = 1; i <= BlurWeightV; ++i) { + L = 1.0 / i; + J = 0.5 * i * PIXEL_SIZE.y; + C = mix(C, mix(texture(MMJ_BlurPass_H, vTexCoord + vec2(0.0, J)), texture(MMJ_BlurPass_H, vTexCoord - vec2(0.0, J)), 0.5), L); + } + FragColor = C; +} \ No newline at end of file diff --git a/cel/shaders/MMJ_Cel_Shader_MP_Color.slang b/cel/shaders/MMJ_Cel_Shader_MP_Color.slang new file mode 100644 index 0000000..b24cb18 --- /dev/null +++ b/cel/shaders/MMJ_Cel_Shader_MP_Color.slang @@ -0,0 +1,152 @@ +#version 450 + +#pragma name MMJ_ColorPass + +/* +---------------------------------------------------------------- +MMJ's Cel Shader v2.0 - Multi-Pass +---------------------------------------------------------------- +Parameters: +----------- +Color Saturation = Increase or decrease color saturation. + +Color Levels = Determines number of color "bands". + +Color Weight = Changes the strength of the color adjustments. +---------------------------------------------------------------- +*/ + +layout(push_constant) uniform Push +{ + vec4 MMJ_OutlineSize; + vec4 OriginalSize; + float ColorLevels; + float ColorSaturation; + float ColorWeight; +} params; + +#pragma parameter ColorLevels "Color Levels" 12.0 1.0 32.0 1.0 +#pragma parameter ColorSaturation "Color Saturation" 1.15 0.00 2.00 0.05 +#pragma parameter ColorWeight "Color Weight" 0.50 0.00 1.00 0.05 + +#define MMJ_OutlineSize params.MMJ_OutlineSize +#define OriginalSize params.OriginalSize +#define ColorLevels params.ColorLevels +#define ColorSaturation params.ColorSaturation +#define ColorWeight params.ColorWeight + +layout(std140, set = 0, binding = 0) uniform UBO +{ + mat4 MVP; +} global; + + +#pragma stage vertex +layout(location = 0) in vec4 Position; +layout(location = 1) in vec2 TexCoord; +layout(location = 0) out vec2 vTexCoord; + +void main() +{ + gl_Position = global.MVP * Position; + vTexCoord = TexCoord; +} + + +#pragma stage fragment +layout(location = 0) in vec2 vTexCoord; +layout(location = 0) out vec4 FragColor; +layout(set = 0, binding = 2) uniform sampler2D Original; +layout(set = 0, binding = 3) uniform sampler2D MMJ_OutlinePass; + +vec3 RGB2HSL(vec3 cRGB) +{ + float cR = cRGB[0], cG = cRGB[1], cB = cRGB[2]; + float vMin = min(min(cR, cG), cB), vMax = max(max(cR, cG), cB); + float dMax = vMax - vMin, vS = 0.0, vH = 0.0, vL = (vMax + vMin) / 2.0; + + // gray, no chroma + if(dMax == 0.0) { + vH = 0.0; vS = vH; + + // chromatic data + } else { + if(vL < 0.5) { vS = dMax / (vMax + vMin); } + else { vS = dMax / (2.0 - vMax - vMin); } + + float dR = (((vMax - cR) * 0.1667) + (dMax * 0.5)) / dMax; + float dG = (((vMax - cG) * 0.1667) + (dMax * 0.5)) / dMax; + float dB = (((vMax - cB) * 0.1667) + (dMax * 0.5)) / dMax; + + if (cR >= vMax) { vH = dB - dG; } + else if(cG >= vMax) { vH = 0.3333 + dR - dB; } + else if(cB >= vMax) { vH = 0.6667 + dG - dR; } + + if (vH < 0.0) { vH += 1.0; } + else if(vH > 1.0) { vH -= 1.0; } + } + return vec3(vH, vS, vL); +} + +float Hue2RGB(float v1, float v2, float vH) +{ + float v3 = 0.0; + + if (vH < 0.0) { vH += 1.0; } + else if(vH > 1.0) { vH -= 1.0; } + + if ((6.0 * vH) < 1.0) { v3 = v1 + (v2 - v1) * 6.0 * vH; } + else if((2.0 * vH) < 1.0) { v3 = v2; } + else if((3.0 * vH) < 2.0) { v3 = v1 + (v2 - v1) * (0.6667 - vH) * 6.0; } + else { v3 = v1; } + + return v3; +} + +vec3 HSL2RGB(vec3 vHSL) +{ + float cR = 0.0, cG = cR, cB = cR; + + if(vHSL[1] == 0.0) { + cR = vHSL[2], cG = cR, cB = cR; + + } else { + float v1 = 0.0, v2 = v1; + + if(vHSL[2] < 0.5) { v2 = vHSL[2] * (1.0 + vHSL[1] ); } + else { v2 = (vHSL[2] + vHSL[1] ) - (vHSL[1] * vHSL[2] ); } + + v1 = 2.0 * vHSL[2] - v2; + + cR = Hue2RGB(v1, v2, vHSL[0] + 0.3333); + cG = Hue2RGB(v1, v2, vHSL[0] ); + cB = Hue2RGB(v1, v2, vHSL[0] - 0.3333); + } + return vec3(cR, cG, cB); +} + +vec3 colorAdjust(vec3 cRGB) +{ + vec3 cHSL = RGB2HSL(cRGB); + + float cr = 1.0 / ColorLevels; + + // brightness modifier + float BrtModify = mod(cHSL[2], cr); + + cHSL[1] *= ColorSaturation; + cHSL[2] += (cHSL[2] * cr - BrtModify); + cRGB = 1.2 * HSL2RGB(cHSL); + + return cRGB; +} + +void main() +{ + vec3 cOriginal = texture(Original, vTexCoord).rgb; + vec3 cOutline = texture(MMJ_OutlinePass, vTexCoord).rgb; + + vec3 cNew = cOriginal; + cNew = min(vec3(1.0), min(cNew, cNew + dot(vec3(1.0), cNew))); + FragColor.rgb = mix(cOriginal * cOutline, colorAdjust(cNew * cOutline), ColorWeight); +} \ No newline at end of file diff --git a/cel/shaders/MMJ_Cel_Shader_MP_Outline.slang b/cel/shaders/MMJ_Cel_Shader_MP_Outline.slang new file mode 100644 index 0000000..c71b2fd --- /dev/null +++ b/cel/shaders/MMJ_Cel_Shader_MP_Outline.slang @@ -0,0 +1,120 @@ +#version 450 + +#pragma name MMJ_OutlinePass + +/* +---------------------------------------------------------------- +MMJ's Cel Shader v2.0 - Multi-Pass +---------------------------------------------------------------- +Parameters: +----------- +Outline Weight = Adjusts darkness of the outlines. + +At lower internal resolutions, smaller values work better to +reduce the appearance of lines around individual areas of some +textures. At higher internal resolutions, setting both a higher +outline weight value plus increased blur factors will work +together to thicken the appearance of the lines. +---------------------------------------------------------------- +*/ + +layout(push_constant) uniform Push +{ + vec4 MMJ_BlurPass_VSize; + float OutlineWeight; +} params; + +#pragma parameter OutlineWeight "Outline Weight" 1.0 0.0 10.0 0.1 + +#define MMJ_BlurPass_VSize params.MMJ_BlurPass_VSize +#define OutlineWeight params.OutlineWeight + +layout(std140, set = 0, binding = 0) uniform UBO +{ + mat4 MVP; +} global; + + +#pragma stage vertex +layout(location = 0) in vec4 Position; +layout(location = 1) in vec2 TexCoord; +layout(location = 0) out vec2 vTexCoord; +layout(location = 1) out vec4 TEX0; +layout(location = 2) out vec4 TEX1; +layout(location = 3) out vec4 TEX2; +layout(location = 4) out vec4 TEX3; +layout(location = 5) out vec4 TEX4; +layout(location = 6) out vec4 TEX5; + +void main() +{ + gl_Position = global.MVP * Position; + vTexCoord = TexCoord; + + TEX0 = vTexCoord.xyxy; + + vec4 offset; + + offset.xy = -(offset.zw = vec2(MMJ_BlurPass_VSize.z, 0.0)); + TEX1 = TEX0 + offset; + TEX5 = TEX1 + offset; + + offset.xy = -(offset.zw = vec2(0.0, MMJ_BlurPass_VSize.w)); + TEX2 = TEX0 + offset; + TEX3 = TEX1 + offset; + TEX4 = TEX2 + offset; +} + + +#pragma stage fragment +layout(location = 0) in vec2 vTexCoord; +layout(location = 1) in vec4 TEX0; +layout(location = 2) in vec4 TEX1; +layout(location = 3) in vec4 TEX2; +layout(location = 4) in vec4 TEX3; +layout(location = 5) in vec4 TEX4; +layout(location = 6) in vec4 TEX5; +layout(location = 0) out vec4 FragColor; +layout(set = 0, binding = 2) uniform sampler2D MMJ_BlurPass_V; + +void main() +{ + vec3 c00 = texture(MMJ_BlurPass_V, TEX3.xy).rgb; + vec3 c01 = texture(MMJ_BlurPass_V, TEX2.xy).rgb; + vec3 c02 = texture(MMJ_BlurPass_V, TEX3.zy).rgb; + vec3 c03 = texture(MMJ_BlurPass_V, TEX1.xy).rgb; + vec3 c04 = texture(MMJ_BlurPass_V, TEX0.xy).rgb; + vec3 c05 = texture(MMJ_BlurPass_V, TEX1.zw).rgb; + vec3 c06 = texture(MMJ_BlurPass_V, TEX3.xw).rgb; + vec3 c07 = texture(MMJ_BlurPass_V, TEX2.zw).rgb; + vec3 c08 = texture(MMJ_BlurPass_V, TEX3.zw).rgb; + vec3 c09 = texture(MMJ_BlurPass_V, TEX4.xy).rgb; + vec3 c10 = texture(MMJ_BlurPass_V, TEX4.zw).rgb; + vec3 c11 = texture(MMJ_BlurPass_V, TEX5.xy).rgb; + vec3 c12 = texture(MMJ_BlurPass_V, TEX5.zw).rgb; + + vec3 cNew = (c00 + c01 + c02 + c03 + c04 + c05 + c06 + c07 + c08 + c09 + c10 + c11 + c12) / 13.0; + + vec3 o = vec3(1.0), h = vec3(0.05), hz = h; + float k = 0.005, kz = 0.007, i = 0.0; + + vec3 cz = (cNew + h) / (dot(o, cNew) + k); + + hz = (cz - ((c00 + h) / (dot(o, c00) + k))); i = kz / (dot(hz, hz) + kz); + hz = (cz - ((c01 + h) / (dot(o, c01) + k))); i += kz / (dot(hz, hz) + kz); + hz = (cz - ((c02 + h) / (dot(o, c02) + k))); i += kz / (dot(hz, hz) + kz); + hz = (cz - ((c03 + h) / (dot(o, c03) + k))); i += kz / (dot(hz, hz) + kz); + hz = (cz - ((c05 + h) / (dot(o, c05) + k))); i += kz / (dot(hz, hz) + kz); + hz = (cz - ((c06 + h) / (dot(o, c06) + k))); i += kz / (dot(hz, hz) + kz); + hz = (cz - ((c07 + h) / (dot(o, c07) + k))); i += kz / (dot(hz, hz) + kz); + hz = (cz - ((c08 + h) / (dot(o, c08) + k))); i += kz / (dot(hz, hz) + kz); + hz = (cz - ((c09 + h) / (dot(o, c09) + k))); i += kz / (dot(hz, hz) + kz); + hz = (cz - ((c10 + h) / (dot(o, c10) + k))); i += kz / (dot(hz, hz) + kz); + hz = (cz - ((c11 + h) / (dot(o, c11) + k))); i += kz / (dot(hz, hz) + kz); + hz = (cz - ((c12 + h) / (dot(o, c12) + k))); i += kz / (dot(hz, hz) + kz); + + i /= 12.0; + i = pow(i, OutlineWeight); + + FragColor.rgb = vec3(i); +} \ No newline at end of file