Pixel-Composer/shaders/sh_displace/sh_displace.fsh

166 lines
4.2 KiB
Plaintext
Raw Normal View History

2022-01-13 05:24:03 +01:00
varying vec2 v_vTexcoord;
varying vec4 v_vColour;
uniform sampler2D map;
2024-02-10 07:03:50 +01:00
uniform sampler2D map2;
2022-01-13 05:24:03 +01:00
uniform vec2 dimension;
uniform vec2 map_dimension;
uniform vec2 displace;
uniform float middle;
uniform int iterate;
2024-02-10 07:03:50 +01:00
uniform int mode;
uniform int sampleMode;
uniform int blendMode;
2024-02-10 07:03:50 +01:00
uniform int sepAxis;
2023-12-22 14:46:54 +01:00
uniform vec2 strength;
uniform int strengthUseSurf;
uniform sampler2D strengthSurf;
2022-01-13 05:24:03 +01:00
float bright(in vec4 col) { return dot(col.rgb, vec3(0.2126, 0.7152, 0.0722)) * col.a; }
2022-01-13 05:24:03 +01:00
#region /////////////// SAMPLING ///////////////
2023-03-21 03:01:53 +01:00
const float PI = 3.14159265358979323846;
uniform int interpolation;
uniform vec2 sampleDimension;
2023-03-21 03:01:53 +01:00
const int RSIN_RADIUS = 1;
2023-03-21 03:01:53 +01:00
float sinc ( float x ) { return x == 0.? 1. : sin(x * PI) / (x * PI); }
2023-03-21 03:01:53 +01:00
vec4 texture2D_rsin( sampler2D texture, vec2 uv ) {
vec2 tx = 1.0 / sampleDimension;
vec2 p = uv * sampleDimension - vec2(0.5);
2023-03-21 03:01:53 +01:00
vec4 sum = vec4(0.0);
float weights = 0.;
2023-03-21 03:01:53 +01:00
for (int x = -RSIN_RADIUS; x <= RSIN_RADIUS; x++)
for (int y = -RSIN_RADIUS; y <= RSIN_RADIUS; y++) {
float a = length(vec2(float(x), float(y))) / float(RSIN_RADIUS);
if(a > 1.) continue;
float w = sinc(a * PI * tx.x) * sinc(a * PI * tx.y);
vec2 offset = vec2(float(x), float(y)) * tx;
vec4 sample = texture2D(texture, (p + offset + vec2(0.5)) / sampleDimension);
sum += w * sample;
weights += w;
}
2023-03-21 03:01:53 +01:00
return sum / weights;
}
2023-03-21 03:01:53 +01:00
vec4 texture2D_bicubic( sampler2D texture, vec2 uv ) {
uv = uv * sampleDimension + 0.5;
vec2 iuv = floor( uv );
vec2 fuv = fract( uv );
uv = iuv + fuv * fuv * (3.0 - 2.0 * fuv);
uv = (uv - 0.5) / sampleDimension;
return texture2D( texture, uv );
}
2023-03-21 03:01:53 +01:00
vec4 texture2Dintp( sampler2D texture, vec2 uv ) {
if(interpolation == 2) return texture2D_bicubic( texture, uv );
else if(interpolation == 3) return texture2D_rsin( texture, uv );
return texture2D( texture, uv );
}
2023-03-21 03:01:53 +01:00
vec4 sampleTexture(vec2 pos) {
if(pos.x >= 0. && pos.y >= 0. && pos.x <= 1. && pos.y <= 1.)
return texture2Dintp(gm_BaseTexture, pos);
2022-12-27 04:00:50 +01:00
if(sampleMode == 0)
return vec4(0.);
if(sampleMode == 1)
return texture2Dintp(gm_BaseTexture, clamp(pos, 0., 1.));
if(sampleMode == 2)
return texture2Dintp(gm_BaseTexture, fract(pos));
2022-12-27 04:00:50 +01:00
return vec4(0.);
}
#endregion /////////////// SAMPLING ///////////////
2022-12-27 04:00:50 +01:00
vec2 shiftMap(in vec2 pos, in float str) { #region
vec4 disP = texture2Dintp( map, pos );
vec2 sam_pos;
vec2 raw_displace = displace / dimension;
2022-01-13 05:24:03 +01:00
float _str;
2024-02-10 07:03:50 +01:00
vec2 _disp;
2022-01-13 05:24:03 +01:00
2024-02-10 07:03:50 +01:00
if(mode == 1) {
if(sepAxis == 0)
_disp = vec2(disP.r - middle, disP.g - middle) * vec2((disP.r + disP.g + disP.b) / 3. - middle) * str;
else if(sepAxis == 1) {
vec4 disP2 = texture2Dintp( map2, pos );
_disp.x = (bright(disP) - middle) * str;
_disp.y = (bright(disP2) - middle) * str;
}
2022-01-13 05:24:03 +01:00
sam_pos = pos + _disp;
2024-02-10 07:03:50 +01:00
} else if(mode == 2) {
float _ang;
if(sepAxis == 0) {
_ang = disP.r * PI * 2.;
_str = (disP.g - middle) * str;
} else if(sepAxis == 1) {
vec4 disP2 = texture2Dintp( map2, pos );
_ang = bright(disP) * PI * 2.;
_str = (bright(disP2) - middle) * str;
}
2022-01-13 05:24:03 +01:00
sam_pos = pos + _str * vec2(cos(_ang), sin(_ang));
} else {
_str = (bright(disP) - middle) * str;
sam_pos = pos + _str * raw_displace;
}
2022-12-27 04:00:50 +01:00
return sam_pos;
} #endregion
2022-01-13 05:24:03 +01:00
vec4 blend(in vec4 c0, in vec4 c1) { #region
if(blendMode == 0) return c1;
else if(blendMode == 1) {
float b0 = bright(c0);
float b1 = bright(c1);
return b0 < b1? c0 : c1;
} else if(blendMode == 2) {
float b0 = bright(c0);
float b1 = bright(c1);
return b0 > b1? c0 : c1;
}
return c1;
} #endregion
void main() { #region
2022-01-13 05:24:03 +01:00
vec2 samPos = v_vTexcoord;
vec4 ccol = sampleTexture( v_vTexcoord ), ncol;
2022-01-13 05:24:03 +01:00
2023-12-22 14:46:54 +01:00
float stren = strength.x;
float stMax = strength.x;
if(strengthUseSurf == 1) {
vec4 strMap = texture2Dintp( strengthSurf, v_vTexcoord );
stren = mix(strength.x, strength.y, (strMap.r + strMap.g + strMap.b) / 3.);
stMax = strength.y;
}
2022-01-13 05:24:03 +01:00
if(iterate == 1) {
2023-12-22 14:46:54 +01:00
for(float i = 0.; i < stMax; i++) {
if(i >= stren) break;
2022-01-13 05:24:03 +01:00
samPos = shiftMap(samPos, 1.);
ncol = blend(ccol, sampleTexture( samPos ));
}
} else {
2023-12-22 14:46:54 +01:00
samPos = shiftMap(samPos, stren);
ncol = sampleTexture( samPos );
}
2022-01-13 05:24:03 +01:00
gl_FragColor = blend(ccol, ncol);
} #endregion