5e18111121
* shader: begin the shader refactor
make SShader a class and rename it to CShader, move createprogram,
compileshader, logshadererror to CShader.
* shader: move uniform creation to CShader
move uniform creation to CShader, reduces tons of duplicated effort,
however forcing uniform names to be same in all shaders.
* shader: move to array based frag handling
use an array with an enum so it gets easier dealing with multiple
shaders, move creating program to a for loop and array, reduces line of
code a lot.
* shader: use shared ptr for frags
with smart pointers we can now rename useProgram to useShader and return
the shader directly, means only place we have to decide the shader frag
is when calling useShader. easier for future shader splitting to reduce
branching.
* shader: move unneded public members to private
move structs and uniforms to private add a get/set for initialtime
and add a getUniformLocation to make the code tell what its doing,
instead of direct array getting when all we wanted to get was its value,
also limits the setting of uniformLocations to the createProgram as it should
be.
* shader: fix style nits
set first enum member to 0 , remove extra {}
* shader: dont show a failed notif on success
the logic got inverted in the refactor here.
* shader: split CM shader to rgba/rgbx variants
split shader to rgba/rgbx variants, use bool, and reduce branching.
* shader: split up blurprepare CM and non CM
split up blurprepare, remove skipcm, move gain to gain.glsl.
remove ternary operator and reduce branching by using step() and mix()
use vec3 for gain, make brightness a cheap mulitplication with max.
* shader: split up border to CM/noncm variants
splitup border shader to CM/noncm variant, move common used things to
border.glsl , there is room for optimisations here but its a complex
shader im putting it for future PR.
* shader: touchup blurfinish
make brightness a cheap multiplication instead of branching.
mod is redundant, fract in hash already returns a value in [0.0, 1.0]
92 lines
2.8 KiB
GLSL
92 lines
2.8 KiB
GLSL
#version 300 es
|
|
#extension GL_ARB_shading_language_include : enable
|
|
|
|
precision highp float;
|
|
in vec2 v_texcoord;
|
|
|
|
uniform vec2 fullSizeUntransformed;
|
|
uniform float radiusOuter;
|
|
uniform float thick;
|
|
|
|
// Gradients are in OkLabA!!!! {l, a, b, alpha}
|
|
uniform vec4 gradient[10];
|
|
uniform vec4 gradient2[10];
|
|
uniform int gradientLength;
|
|
uniform int gradient2Length;
|
|
uniform float angle;
|
|
uniform float angle2;
|
|
uniform float gradientLerp;
|
|
uniform float alpha;
|
|
|
|
#include "rounding.glsl"
|
|
#include "CM.glsl"
|
|
#include "border.glsl"
|
|
|
|
layout(location = 0) out vec4 fragColor;
|
|
void main() {
|
|
highp vec2 pixCoord = vec2(gl_FragCoord);
|
|
highp vec2 pixCoordOuter = pixCoord;
|
|
highp vec2 originalPixCoord = v_texcoord;
|
|
originalPixCoord *= fullSizeUntransformed;
|
|
float additionalAlpha = 1.0;
|
|
|
|
vec4 pixColor = vec4(1.0, 1.0, 1.0, 1.0);
|
|
|
|
bool done = false;
|
|
|
|
pixCoord -= topLeft + fullSize * 0.5;
|
|
pixCoord *= vec2(lessThan(pixCoord, vec2(0.0))) * -2.0 + 1.0;
|
|
pixCoordOuter = pixCoord;
|
|
pixCoord -= fullSize * 0.5 - radius;
|
|
pixCoordOuter -= fullSize * 0.5 - radiusOuter;
|
|
|
|
// center the pixes don't make it top-left
|
|
pixCoord += vec2(1.0, 1.0) / fullSize;
|
|
pixCoordOuter += vec2(1.0, 1.0) / fullSize;
|
|
|
|
if (min(pixCoord.x, pixCoord.y) > 0.0 && radius > 0.0) {
|
|
float dist = pow(pow(pixCoord.x,roundingPower)+pow(pixCoord.y,roundingPower),1.0/roundingPower);
|
|
float distOuter = pow(pow(pixCoordOuter.x,roundingPower)+pow(pixCoordOuter.y,roundingPower),1.0/roundingPower);
|
|
float h = (thick / 2.0);
|
|
|
|
if (dist < radius - h) {
|
|
// lower
|
|
float normalized = smoothstep(0.0, 1.0, (dist - radius + thick + SMOOTHING_CONSTANT) / (SMOOTHING_CONSTANT * 2.0));
|
|
additionalAlpha *= normalized;
|
|
done = true;
|
|
} else if (min(pixCoordOuter.x, pixCoordOuter.y) > 0.0) {
|
|
// higher
|
|
float normalized = 1.0 - smoothstep(0.0, 1.0, (distOuter - radiusOuter + SMOOTHING_CONSTANT) / (SMOOTHING_CONSTANT * 2.0));
|
|
additionalAlpha *= normalized;
|
|
done = true;
|
|
} else if (distOuter < radiusOuter - h) {
|
|
additionalAlpha = 1.0;
|
|
done = true;
|
|
}
|
|
}
|
|
|
|
// now check for other shit
|
|
if (!done) {
|
|
// distance to all straight bb borders
|
|
float distanceT = originalPixCoord[1];
|
|
float distanceB = fullSizeUntransformed[1] - originalPixCoord[1];
|
|
float distanceL = originalPixCoord[0];
|
|
float distanceR = fullSizeUntransformed[0] - originalPixCoord[0];
|
|
|
|
// get the smallest
|
|
float smallest = min(min(distanceT, distanceB), min(distanceL, distanceR));
|
|
|
|
if (smallest > thick)
|
|
discard;
|
|
}
|
|
|
|
if (additionalAlpha == 0.0)
|
|
discard;
|
|
|
|
pixColor = getColorForCoord(v_texcoord);
|
|
pixColor.rgb *= pixColor[3];
|
|
|
|
pixColor *= alpha * additionalAlpha;
|
|
|
|
fragColor = pixColor;
|
|
}
|