mirror of
https://github.com/italicsjenga/slang-shaders.git
synced 2024-11-25 00:51:29 +11:00
193 lines
6.9 KiB
Plaintext
193 lines
6.9 KiB
Plaintext
#version 450
|
|
|
|
/*
|
|
simpletex_lcd - a simple, textured LCD shader intended for non-backlit systems
|
|
|
|
- Makes use of the 'line weighting' equation from zfast_lcd_standard
|
|
[original zfast_lcd_standard code copyright (C) 2017 Greg Hogan (SoltanGris42)]
|
|
|
|
Other code by jdgleaver
|
|
|
|
Usage notes:
|
|
|
|
- Background texture size is hard-coded (I can't find a way to get this
|
|
automatically...). User must ensure that 'BG_TEXTURE_SIZE' define is
|
|
set appropriately.
|
|
|
|
- Adjustable parameters:
|
|
|
|
> GRID_INTENSITY: Sets overall visibility of grid effect
|
|
- 1.0: Grid is shown
|
|
- 0.0: Grid is invisible (same colour as pixels)
|
|
> GRID_WIDTH: Sets effective with of grid lines
|
|
- 1.0: Normal full width
|
|
- 0.0: Minimum width
|
|
(Note - this does not mean zero width! Instead, this
|
|
is the minimum 'sane' width, below which the grid
|
|
becomes pointless...)
|
|
> GRID_BIAS: Dynamically adjusts the grid intensity based on pixel luminosity
|
|
- 0.0: Grid intensity is uniform
|
|
- 1.0: Grid intensity scales linearly with pixel luminosity
|
|
> i.e. the darker the pixel, the less the grid effect
|
|
is apparent - black pixels exhibit no grid effect at all
|
|
> DARKEN_GRID: Darkens grid (duh...)
|
|
- 0.0: Grid is white
|
|
- 1.0: Grid is black
|
|
> DARKEN_COLOUR: Simply darkens pixel colours (effectively lowers gamma level of pixels)
|
|
- 0.0: Colours are normal
|
|
- 2.0: Colours are too dark...
|
|
> BACKGROUND_INTENSITY: Adjusts how prominent the paper background texture is
|
|
- 0.0: No background texture
|
|
- 1.0: Background texture is clearly visible
|
|
|
|
This program is free software; you can redistribute it and/or modify it
|
|
under the terms of the GNU General Public License as published by the Free
|
|
Software Foundation; either version 2 of the License, or (at your option)
|
|
any later version.
|
|
*/
|
|
|
|
// Background texture size
|
|
// > 2048 x 2048 textures are suitable for screen resolutions up to
|
|
// 1200p (or 1440p if running 'square' aspect ratio systems)
|
|
#define BG_TEXTURE_SIZE 2048.0
|
|
// > 4096 x 4096 textures are suitable for screen resolutions up to 4k
|
|
//#define BG_TEXTURE_SIZE 4096.0
|
|
|
|
#pragma parameter GRID_INTENSITY "Grid Intensity" 1.0 0.0 1.0 0.05
|
|
#pragma parameter GRID_WIDTH "Grid Width" 1.0 0.0 1.0 0.05
|
|
#pragma parameter GRID_BIAS "Grid Bias" 0.0 0.0 1.0 0.05
|
|
#pragma parameter DARKEN_GRID "Darken Grid" 0.0 0.0 1.0 0.05
|
|
#pragma parameter DARKEN_COLOUR "Darken Colours" 0.0 0.0 2.0 0.05
|
|
#pragma parameter BACKGROUND_INTENSITY "Background Intensity" 1.0 0.0 1.0 0.05
|
|
|
|
layout(push_constant) uniform Push
|
|
{
|
|
float GRID_INTENSITY;
|
|
float GRID_WIDTH;
|
|
float GRID_BIAS;
|
|
float DARKEN_GRID;
|
|
float DARKEN_COLOUR;
|
|
float BACKGROUND_INTENSITY;
|
|
vec4 OutputSize;
|
|
vec4 OriginalSize;
|
|
vec4 SourceSize;
|
|
} registers;
|
|
|
|
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;
|
|
|
|
/*
|
|
VERTEX_SHADER
|
|
*/
|
|
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;
|
|
layout(set = 0, binding = 3) uniform sampler2D BACKGROUND;
|
|
|
|
// ### Magic Numbers...
|
|
|
|
// Grid pattern
|
|
// > Line weighting equation:
|
|
// y = a * (x^4 - b * x^6)
|
|
const float LINE_WEIGHT_A = 48.0;
|
|
const float LINE_WEIGHT_B = 8.0 / 3.0;
|
|
|
|
// RGB -> Luminosity conversion
|
|
// > Photometric/digital ITU BT.709
|
|
#define LUMA_R 0.2126
|
|
#define LUMA_G 0.7152
|
|
#define LUMA_B 0.0722
|
|
// > Digital ITU BT.601
|
|
//#define LUMA_R 0.299
|
|
//#define LUMA_G 0.587
|
|
//#define LUMA_B 0.114
|
|
|
|
// Background texture size
|
|
const float INV_BG_TEXTURE_SIZE = 1.0 / BG_TEXTURE_SIZE;
|
|
|
|
/*
|
|
FRAGMENT SHADER
|
|
*/
|
|
void main()
|
|
{
|
|
// Get current texture coordinate
|
|
vec2 imgPixelCoord = vTexCoord.xy * registers.SourceSize.xy;
|
|
vec2 imgCenterCoord = floor(imgPixelCoord.xy) + vec2(0.5, 0.5);
|
|
|
|
// Get colour of current pixel
|
|
vec3 colour = texture(Source, registers.SourceSize.zw * imgCenterCoord.xy).rgb;
|
|
|
|
// Darken colours (if required...)
|
|
colour.rgb = pow(colour.rgb, vec3(1.0 + registers.DARKEN_COLOUR));
|
|
|
|
// Generate grid pattern...
|
|
vec2 distFromCenter = abs(imgCenterCoord.xy - imgPixelCoord.xy);
|
|
|
|
float xSquared = max(distFromCenter.x, distFromCenter.y);
|
|
xSquared = xSquared * xSquared;
|
|
|
|
float xQuarted = xSquared * xSquared;
|
|
|
|
// > Line weighting equation:
|
|
// y = 48 * (x^4 - (8/3) * x^6)
|
|
float lineWeight = LINE_WEIGHT_A * (xQuarted - (LINE_WEIGHT_B * xQuarted * xSquared));
|
|
|
|
// > Apply grid adjustments (phase 1)
|
|
// - GRID_WIDTH:
|
|
// 1.0: Use raw lineWeight value
|
|
// 0.0: Use lineWeight ^ 2 (makes lines thinner - realistically, this is
|
|
// the thinnest we can go before the grid effect
|
|
// becomes pointless, particularly with 'high resolution'
|
|
// systems like the GBA)
|
|
// - GRID_INTENSITY:
|
|
// 1.0: Grid lines are white
|
|
// 0.0: Grid lines are invisible
|
|
lineWeight = lineWeight * (lineWeight + ((1.0 - lineWeight) * registers.GRID_WIDTH)) * registers.GRID_INTENSITY;
|
|
|
|
// > Apply grid adjustments (phase 2)
|
|
// - GRID_BIAS:
|
|
// 0.0: Use 'unbiased' lineWeight value calculated above
|
|
// 1.0: Scale lineWeight by current pixel luminosity
|
|
// > i.e. the darker the pixel, the lower the intensity of the grid
|
|
float luma = (LUMA_R * colour.r) + (LUMA_G * colour.g) + (LUMA_B * colour.b);
|
|
lineWeight = lineWeight * (luma + ((1.0 - luma) * (1.0 - registers.GRID_BIAS)));
|
|
|
|
// Apply grid pattern
|
|
// (lineWeight == 1 -> set colour to value specified by DARKEN_GRID)
|
|
colour.rgb = mix(colour.rgb, vec3(1.0 - registers.DARKEN_GRID), lineWeight);
|
|
|
|
// Get background sample point
|
|
// > NB: external texture coordinates are referenced in a completely different fashion
|
|
// here than they are in GLSL shaders...
|
|
vec2 bgPixelCoord = floor(vTexCoord.xy * registers.OutputSize.xy) + vec2(0.5, 0.5);
|
|
|
|
// Sample background texture and 'colourise' according to current pixel colour
|
|
// (NB: the 'colourisation' here is lame, but the proper method is slow...)
|
|
vec3 bgTexture = texture(BACKGROUND, bgPixelCoord.xy * INV_BG_TEXTURE_SIZE).rgb * colour.rgb;
|
|
|
|
// Blend current pixel with background according to luminosity
|
|
// (lighter colour == more transparent, more visible background)
|
|
// Note: Have to calculate luminosity a second time... tiresome, but
|
|
// it's not a particulary expensive operation...
|
|
luma = (LUMA_R * colour.r) + (LUMA_G * colour.g) + (LUMA_B * colour.b);
|
|
colour.rgb = mix(colour.rgb, bgTexture.rgb, luma * registers.BACKGROUND_INTENSITY);
|
|
|
|
FragColor = vec4(colour.rgb, 1.0);
|
|
}
|