20250120
resync with master ... hoping it works
This commit is contained in:
Justin Garza
@@ -0,0 +1,198 @@
|
||||
//////////////////////////////////////////////////////////////////////////////////////////
|
||||
// ) ( //
|
||||
// ( /( ( ( ) ( ( ( ( )\ ) ( ( //
|
||||
// )\()) ))\ )( ( ( )\ ) )\))( )\ ( (()/( ( )\))( ( //
|
||||
// ((_)\ /((_|()\ )\ ) )\ '(()/( ((_)()((_) )\ ) ((_)))\((_)()\ )\ //
|
||||
// | |(_|_))( ((_)_(_/( _((_)) )(_)) _(()((_|_)_(_/( _| |((_)(()((_|(_) //
|
||||
// | '_ \ || | '_| ' \)) | ' \()| || | \ V V / | ' \)) _` / _ \ V V (_-< //
|
||||
// |_.__/\_,_|_| |_||_| |_|_|_| \_, | \_/\_/|_|_||_|\__,_\___/\_/\_//__/ //
|
||||
// |__/ //
|
||||
//////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
// SPDX-FileCopyrightText: Justin Garza <JGarza9788@gmail.com>
|
||||
// SPDX-License-Identifier: GPL-3.0-or-later
|
||||
|
||||
// The content from common.glsl is automatically prepended to each shader effect. This
|
||||
// provides the standard input:
|
||||
|
||||
// vec2 iTexCoord: Texture coordinates for retrieving the window input color.
|
||||
// bool uIsFullscreen: True if the window is maximized or in fullscreen mode.
|
||||
// bool uForOpening: True if a window-open animation is ongoing, false otherwise.
|
||||
// float uProgress: A value which transitions from 0 to 1 during the animation.
|
||||
// float uDuration: The duration of the current animation in seconds.
|
||||
// vec2 uSize: The size of uTexture in pixels.
|
||||
// float uPadding: The empty area around the actual window (e.g. where the shadow
|
||||
// is drawn). For now, this will only be set on GNOME.
|
||||
|
||||
// Furthermore, there are two global methods for reading the window input color and
|
||||
// setting the shader output color. Both methods assume straight alpha:
|
||||
|
||||
// vec4 getInputColor(vec2 coords)
|
||||
// void setOutputColor(vec4 outColor)
|
||||
|
||||
// The width of the fading effect is loaded from the settings.
|
||||
uniform float uColorSpeed;
|
||||
uniform bool uRandomColorOffset;
|
||||
uniform float uColorOffset;
|
||||
uniform float uColorSaturation;
|
||||
uniform float uFadeOut;
|
||||
uniform float uBlur;
|
||||
uniform vec2 uSeed;
|
||||
|
||||
|
||||
/*
|
||||
this controls the end shape
|
||||
-5.0 large Star
|
||||
-3.0 Star
|
||||
1.0 Dimond
|
||||
2.0 Circle
|
||||
3.0 Squircle
|
||||
5.0 Square
|
||||
*/
|
||||
uniform float uEdgeShape;
|
||||
|
||||
//the size of the edge color
|
||||
uniform float uEdgeSize;
|
||||
|
||||
//soft <--> hard
|
||||
uniform float uEdgeHardness;
|
||||
|
||||
|
||||
// A simple blur function
|
||||
vec4 blur(vec2 uv, float radius, float samples) {
|
||||
vec4 color = vec4(0.0);
|
||||
|
||||
const float tau = 6.28318530718;
|
||||
const float directions = 15.0;
|
||||
|
||||
for (float d = 0.0; d < tau; d += tau / directions) {
|
||||
for (float s = 0.0; s < 1.0; s += 1.0 / samples) {
|
||||
vec2 offset = vec2(cos(d), sin(d)) * radius * (1.0 - s) / uSize;
|
||||
color += getInputColor(uv + offset);
|
||||
}
|
||||
}
|
||||
|
||||
return color / samples / directions;
|
||||
}
|
||||
|
||||
void main() {
|
||||
|
||||
// This gradually dissolves from [1..0] from the outside to the center. We
|
||||
// switch the direction for opening and closing.
|
||||
float progress = uForOpening ? uProgress : 1.0 - uProgress ;
|
||||
|
||||
//adjusting for Gnome
|
||||
if (uPadding > 0.0)
|
||||
{
|
||||
progress = remap(
|
||||
progress, 0.0, ((uSize.x + (uPadding*2.0)) / uSize.x)
|
||||
,0.0, 1.0
|
||||
);
|
||||
}
|
||||
|
||||
|
||||
// Get the color from the window texture.
|
||||
vec4 oColor = getInputColor(iTexCoord.st);
|
||||
|
||||
// Calculate the aspect ratio of the render area
|
||||
float aspect = uSize.x / uSize.y;
|
||||
|
||||
//standard uv
|
||||
vec2 uv = iTexCoord.st;
|
||||
|
||||
// tuv is for when progress is near 0
|
||||
vec2 tuv = uv;
|
||||
tuv -= 0.5; // Shift UV coordinates to center (from [-0.5 to 0.5])
|
||||
tuv.x *= aspect; // Scale x-coordinate to match aspect ratio
|
||||
tuv += 0.5; // Shift UV coordinates back (from [0 to 1])
|
||||
|
||||
//mixing the UVs
|
||||
uv = mix(tuv,uv,easeOutExpo(progress));
|
||||
|
||||
// this controls the shape
|
||||
// -1.0 would be a diamond-ish
|
||||
// 0.0 would be a rounded diamond
|
||||
// 1.0 would be a circle
|
||||
// 2.0 will be sqircle
|
||||
// 1000.0 will be very square
|
||||
float p = mix(uEdgeShape,1000.0,
|
||||
easeInExpo(progress)
|
||||
);
|
||||
|
||||
//this will be used later to make a mask
|
||||
float m = mix(
|
||||
0.0,
|
||||
1.0,
|
||||
clamp(
|
||||
pow(abs(uv.x-0.5)*2.0,p) + pow(abs(uv.y-0.5)*2.0,p),0.0,1.0
|
||||
)
|
||||
);
|
||||
|
||||
|
||||
//this calculates the edge of the effect
|
||||
float edge = abs(m-progress) ;
|
||||
float e = mix(0.0,uEdgeSize,1.0 - progress);
|
||||
edge = remap(edge,0.0,e,0.0,1.0);
|
||||
edge = clamp(edge,0.0,1.0);
|
||||
edge = 1.0 - edge;
|
||||
|
||||
//this is the mask
|
||||
float mask = (m > progress) ? 0.0 : 1.0 ;
|
||||
|
||||
//we need two of these
|
||||
float mask0 = mix(mask,mask+edge,1.0 - uEdgeHardness);
|
||||
float mask1 = mix(edge,edge*mask,uEdgeHardness);
|
||||
|
||||
//calculate color
|
||||
vec3 color = cos(progress*uColorSpeed+uv.xyx+vec3(0,2,4)).xyz;
|
||||
//coloroffset
|
||||
float colorOffset = (uRandomColorOffset) ? hash12(uSeed) : uColorOffset ;
|
||||
color = offsetHue(color, colorOffset + 0.10);
|
||||
//clamp and saturate
|
||||
color = clamp(color * uColorSaturation,vec3(0.0),vec3(1.0));
|
||||
|
||||
//save this for later
|
||||
float oColorAlpha = oColor.a;
|
||||
|
||||
//blur-ify
|
||||
if (uBlur > 0.0)
|
||||
{
|
||||
//used for blur later ...
|
||||
//calculate this before saturating it
|
||||
float b = (color.r + color.g + color.b)/3.0;
|
||||
|
||||
|
||||
oColor = blur( iTexCoord.st, b * uBlur * mask1, 7.0);
|
||||
}
|
||||
|
||||
//apply masks and colors
|
||||
oColor.a *= mask0;
|
||||
|
||||
//i was doing this to try to adjust for light mode
|
||||
// i don;t like the way these make the effect look
|
||||
// ...maybe a toggle for it later
|
||||
/*
|
||||
float oColorPercent = (oColor.r + oColor.g + oColor.b)/3.0;
|
||||
oColor.r = mix(oColor.r , 1.0 - oColor.r, mask1 * oColorPercent);
|
||||
oColor.g = mix(oColor.g , 1.0 - oColor.g, mask1 * oColorPercent);
|
||||
oColor.b = mix(oColor.b , 1.0 - oColor.b, mask1 * oColorPercent);
|
||||
// --or
|
||||
oColor.r = mix(oColor.r , 0.0, mask1 * oColorPercent);
|
||||
oColor.g = mix(oColor.g , 0.0, mask1 * oColorPercent);
|
||||
oColor.b = mix(oColor.b , 0.0, mask1 * oColorPercent);
|
||||
*/
|
||||
|
||||
oColor += mask1 * vec4(color.rgb,1.0);
|
||||
oColor.a *= oColorAlpha;
|
||||
|
||||
//i want to fade out the last ~10% of the animation
|
||||
float lastfade = remap(progress,0.0,uFadeOut,0.0,1.0);
|
||||
lastfade = clamp(lastfade,0.0,1.0);
|
||||
lastfade = easeInSine(lastfade);
|
||||
|
||||
//apply the lastfade
|
||||
oColor.a *= lastfade;
|
||||
|
||||
setOutputColor(oColor);
|
||||
|
||||
}
|
||||
@@ -185,6 +185,55 @@ vec3 darken(vec3 color, float fac) { return color * (1.0 - fac); }
|
||||
// color will be white.
|
||||
vec3 lighten(vec3 color, float fac) { return color + (vec3(1.0) - color) * fac; }
|
||||
|
||||
|
||||
//change the color based on an offset amount
|
||||
vec3 offsetHue(vec3 color, float hueOffset) {
|
||||
// Convert RGB to HSV
|
||||
float maxC = max(max(color.r, color.g), color.b);
|
||||
float minC = min(min(color.r, color.g), color.b);
|
||||
float delta = maxC - minC;
|
||||
|
||||
float hue = 0.0;
|
||||
if (delta > 0.0) {
|
||||
if (maxC == color.r) {
|
||||
hue = mod((color.g - color.b) / delta, 6.0);
|
||||
} else if (maxC == color.g) {
|
||||
hue = (color.b - color.r) / delta + 2.0;
|
||||
} else {
|
||||
hue = (color.r - color.g) / delta + 4.0;
|
||||
}
|
||||
}
|
||||
hue /= 6.0;
|
||||
|
||||
float saturation = (maxC > 0.0) ? (delta / maxC) : 0.0;
|
||||
float value = maxC;
|
||||
|
||||
// Offset the hue
|
||||
hue = mod(hue + hueOffset, 1.0);
|
||||
|
||||
// Convert HSV back to RGB
|
||||
float c = value * saturation;
|
||||
float x = c * (1.0 - abs(mod(hue * 6.0, 2.0) - 1.0));
|
||||
float m = value - c;
|
||||
|
||||
vec3 rgb;
|
||||
if (hue < 1.0 / 6.0) {
|
||||
rgb = vec3(c, x, 0.0);
|
||||
} else if (hue < 2.0 / 6.0) {
|
||||
rgb = vec3(x, c, 0.0);
|
||||
} else if (hue < 3.0 / 6.0) {
|
||||
rgb = vec3(0.0, c, x);
|
||||
} else if (hue < 4.0 / 6.0) {
|
||||
rgb = vec3(0.0, x, c);
|
||||
} else if (hue < 5.0 / 6.0) {
|
||||
rgb = vec3(x, 0.0, c);
|
||||
} else {
|
||||
rgb = vec3(c, 0.0, x);
|
||||
}
|
||||
|
||||
return rgb + m;
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------- easing functions
|
||||
|
||||
// Here are some basic easing function. More can be added if required!
|
||||
@@ -202,6 +251,119 @@ float easeOutBack(float x, float e) {
|
||||
return p * p * ((e + 1.0) * p + e) + 1.0;
|
||||
}
|
||||
|
||||
|
||||
// https://easings.net/
|
||||
/*
|
||||
Easing functions define the rate of change of a parameter over time, commonly used in animations, UI transitions, and game development. They provide a way to make movements more natural or visually appealing rather than linear and mechanical. Popular categories of easing functions include:
|
||||
|
||||
Linear: Constant speed from start to finish.
|
||||
Quadratic (Ease In, Ease Out, Ease In Out): Changes at varying rates, with smoother starts or stops.
|
||||
Cubic: Similar to quadratic but allows for even more nuanced transitions.
|
||||
Exponential: Drastic changes at the start or end, often used for dramatic effects.
|
||||
Bounce: Mimics a bouncing object with oscillations.
|
||||
Elastic: Simulates the behavior of a spring, with overshooting and oscillations.
|
||||
Below are text-based "graphs" of some easing functions, where the horizontal axis represents time and the vertical axis represents progress.
|
||||
*/
|
||||
|
||||
|
||||
// Quadratic Easing
|
||||
// Smooth acceleration and deceleration using quadratic (t^2) curves.
|
||||
|
||||
float easeInOutQuad(float t) {
|
||||
// Accelerates for the first half, decelerates for the second half.
|
||||
return t < 0.5 ? 2.0 * t * t : -1.0 + (4.0 - 2.0 * t) * t;
|
||||
}
|
||||
|
||||
// Cubic Easing
|
||||
// Smoother transitions compared to quadratic easing using cubic (t^3) curves.
|
||||
|
||||
float easeInCubic(float t) {
|
||||
// Starts slow and accelerates as t increases.
|
||||
return t * t * t;
|
||||
}
|
||||
|
||||
float easeOutCubic(float t) {
|
||||
// Starts fast and decelerates as t approaches 1.0.
|
||||
float f = t - 1.0;
|
||||
return f * f * f + 1.0;
|
||||
}
|
||||
|
||||
float easeInOutCubic(float t) {
|
||||
// Combines easeIn and easeOut cubic behavior for smooth transitions.
|
||||
return t < 0.5 ? 4.0 * t * t * t : (t - 1.0) * (2.0 * t - 2.0) * (2.0 * t - 2.0) + 1.0;
|
||||
}
|
||||
|
||||
// Quartic Easing
|
||||
// Even smoother transitions than cubic, using quartic (t^4) curves.
|
||||
|
||||
float easeInQuart(float t) {
|
||||
// Starts very slow and accelerates steeply.
|
||||
return t * t * t * t;
|
||||
}
|
||||
|
||||
float easeOutQuart(float t) {
|
||||
// Starts steeply and slows down dramatically.
|
||||
float f = t - 1.0;
|
||||
return 1.0 - f * f * f * f;
|
||||
}
|
||||
|
||||
float easeInOutQuart(float t) {
|
||||
// Combines easeIn and easeOut quartic behavior for very smooth transitions.
|
||||
return t < 0.5 ? 8.0 * t * t * t * t : 1.0 - 8.0 * (t - 1.0) * (t - 1.0) * (t - 1.0) * (t - 1.0);
|
||||
}
|
||||
|
||||
// Sine Easing
|
||||
// Smooth, wave-like acceleration and deceleration using sine curves.
|
||||
|
||||
float easeInSine(float t) {
|
||||
// Starts very slow, following a sine wave curve.
|
||||
return 1.0 - cos((t * 3.141592653589793) / 2.0);
|
||||
}
|
||||
|
||||
float easeOutSine(float t) {
|
||||
// Starts fast and slows down following a sine wave curve.
|
||||
return sin((t * 3.141592653589793) / 2.0);
|
||||
}
|
||||
|
||||
float easeInOutSine(float t) {
|
||||
// Smooth start and end, mimicking half a sine wave.
|
||||
return -0.5 * (cos(3.141592653589793 * t) - 1.0);
|
||||
}
|
||||
|
||||
// Exponential Easing
|
||||
// Sharp transitions with rapid acceleration and deceleration.
|
||||
|
||||
float easeInExpo(float t) {
|
||||
// Very slow start, accelerates exponentially.
|
||||
return t == 0.0 ? 0.0 : pow(2.0, 10.0 * (t - 1.0));
|
||||
}
|
||||
|
||||
float easeOutExpo(float t) {
|
||||
// Starts fast and slows down exponentially.
|
||||
return t == 1.0 ? 1.0 : 1.0 - pow(2.0, -10.0 * t);
|
||||
}
|
||||
|
||||
float easeInOutExpo(float t) {
|
||||
// Combines easeIn and easeOut exponential for sharp transitions.
|
||||
if (t == 0.0) return 0.0;
|
||||
if (t == 1.0) return 1.0;
|
||||
return t < 0.5 ? 0.5 * pow(2.0, 20.0 * t - 10.0) : 1.0 - 0.5 * pow(2.0, -20.0 * t + 10.0);
|
||||
}
|
||||
|
||||
// Back Easing
|
||||
// Creates an overshooting effect for more dynamic animations.
|
||||
|
||||
float easeInOutBack(float t) {
|
||||
// Uses constants to define the overshooting magnitude.
|
||||
const float c1 = 1.70158;
|
||||
const float c2 = c1 * 1.525;
|
||||
return t < 0.5
|
||||
? (pow(2.0 * t, 2.0) * ((c2 + 1.0) * 2.0 * t - c2)) / 2.0
|
||||
: (pow(2.0 * t - 2.0, 2.0) * ((c2 + 1.0) * (t * 2.0 - 2.0) + c2) + 2.0) / 2.0;
|
||||
}
|
||||
|
||||
|
||||
|
||||
// --------------------------------------------------------------------- edge mask helpers
|
||||
|
||||
// This method returns a mask which smoothly transitions towards zero when approaching
|
||||
@@ -266,7 +428,19 @@ float getWinding(vec2 a, vec2 b) { return cross(vec3(a, 0.0), vec3(b, 0.0)).z; }
|
||||
|
||||
// Rotates the given 2D vector a clockwise by the angle alpha (given in radians).
|
||||
vec2 rotate(vec2 a, float angle) {
|
||||
return vec2(a.x * cos(angle) - a.y * sin(angle), a.x * sin(angle) + a.y * cos(angle));
|
||||
return vec2(
|
||||
a.x * cos(angle) - a.y * sin(angle),
|
||||
a.x * sin(angle) + a.y * cos(angle)
|
||||
);
|
||||
}
|
||||
|
||||
//rotates a given 2d vector, around a given center (angle is in radians)
|
||||
vec2 rotate(vec2 a, float angle, vec2 center)
|
||||
{
|
||||
return vec2(
|
||||
cos(angle) * (a.x - center.x) + sin(angle) * (a.y - center.y) + center.x,
|
||||
cos(angle) * (a.y - center.y) - sin(angle) * (a.x - center.x) + center.y
|
||||
);
|
||||
}
|
||||
|
||||
// --------------------------------------------------------------------------------- noise
|
||||
@@ -470,3 +644,69 @@ float simplex3DFractal(vec3 m) {
|
||||
return 0.5333333 * simplex3D(m * rot1) + 0.2666667 * simplex3D(2.0 * m * rot2) +
|
||||
0.1333333 * simplex3D(4.0 * m * rot3) + 0.0666667 * simplex3D(8.0 * m);
|
||||
}
|
||||
|
||||
|
||||
// --------------------------------------------------------------------------------- remap
|
||||
|
||||
|
||||
/*
|
||||
These functions remap a given value from one range to another.
|
||||
The remap operation is particularly useful in shader programming
|
||||
to scale or normalize data, ensuring compatibility across various
|
||||
input ranges. Each version of the remap function supports a
|
||||
different data type:
|
||||
|
||||
1. float: Remap a single scalar value.
|
||||
2. vec2: Remap a 2D vector.
|
||||
3. vec3: Remap a 3D vector.
|
||||
4. vec4: Remap a 4D vector.
|
||||
|
||||
The general formula used is:
|
||||
newMin + (value - oldMin) * (newMax - newMin) / (oldMax - oldMin)
|
||||
|
||||
This ensures a linear transformation from the old range to the new range.
|
||||
*/
|
||||
|
||||
// Remap for float
|
||||
// Maps a float value from one range [oldMin, oldMax] to another range [newMin, newMax].
|
||||
// This is useful for normalizing or scaling scalar values to fit within a desired range.
|
||||
float remap(float value, float oldMin, float oldMax, float newMin, float newMax) {
|
||||
return clamp(
|
||||
newMin + (value - oldMin) * (newMax - newMin) / (oldMax - oldMin),
|
||||
newMin,
|
||||
newMax
|
||||
);
|
||||
}
|
||||
|
||||
// Remap for vec2
|
||||
// Maps a 2D vector (vec2) from one range [oldMin, oldMax] to another range [newMin, newMax].
|
||||
// Each component of the vec2 is individually scaled and transformed.
|
||||
vec2 remap(vec2 value, vec2 oldMin, vec2 oldMax, vec2 newMin, vec2 newMax) {
|
||||
return clamp(
|
||||
newMin + (value - oldMin) * (newMax - newMin) / (oldMax - oldMin),
|
||||
newMin,
|
||||
newMax
|
||||
);
|
||||
}
|
||||
|
||||
// Remap for vec3
|
||||
// Maps a 3D vector (vec3) from one range [oldMin, oldMax] to another range [newMin, newMax].
|
||||
// Each component of the vec3 is individually scaled and transformed.
|
||||
vec3 remap(vec3 value, vec3 oldMin, vec3 oldMax, vec3 newMin, vec3 newMax) {
|
||||
return clamp(
|
||||
newMin + (value - oldMin) * (newMax - newMin) / (oldMax - oldMin),
|
||||
newMin,
|
||||
newMax
|
||||
);
|
||||
}
|
||||
|
||||
// Remap for vec4
|
||||
// Maps a 4D vector (vec4) from one range [oldMin, oldMax] to another range [newMin, newMax].
|
||||
// Each component of the vec4 is individually scaled and transformed.
|
||||
vec4 remap(vec4 value, vec4 oldMin, vec4 oldMax, vec4 newMin, vec4 newMax) {
|
||||
return clamp(
|
||||
newMin + (value - oldMin) * (newMax - newMin) / (oldMax - oldMin),
|
||||
newMin,
|
||||
newMax
|
||||
);
|
||||
}
|
||||
|
||||
@@ -30,57 +30,69 @@
|
||||
// vec4 getInputColor(vec2 coords)
|
||||
// void setOutputColor(vec4 outColor)
|
||||
|
||||
|
||||
// Ease-in-out cubic for alpha
|
||||
float easeInOutCubic(float x) {
|
||||
return x < 0.5 ? 4.0 * x * x * x : 1.0 - pow(-2.0 * x + 2.0, 3.0) / 2.0;
|
||||
}
|
||||
|
||||
// Ease-in-out sine for blur
|
||||
float easeInOutSine(float x) {
|
||||
return -(cos(3.14159265 * x) - 1.0) / 2.0;
|
||||
}
|
||||
|
||||
// A simple blur function
|
||||
vec4 blur(vec2 uv, float radius, float samples) {
|
||||
// Initialize the color accumulator to zero.
|
||||
vec4 color = vec4(0.0);
|
||||
|
||||
const float tau = 6.28318530718;
|
||||
// Define a constant for 2 * PI (tau), which represents a full circle in radians.
|
||||
const float tau = 6.28318530718;
|
||||
|
||||
// Number of directions for sampling around the circle.
|
||||
const float directions = 15.0;
|
||||
|
||||
// Outer loop iterates over multiple directions evenly spaced around a circle.
|
||||
for (float d = 0.0; d < tau; d += tau / directions) {
|
||||
// Inner loop samples along each direction, with decreasing intensity.
|
||||
for (float s = 0.0; s < 1.0; s += 1.0 / samples) {
|
||||
// Calculate the offset for this sample based on direction, radius, and step.
|
||||
// The (1.0 - s) term ensures more sampling occurs closer to the center.
|
||||
vec2 offset = vec2(cos(d), sin(d)) * radius * (1.0 - s) / uSize;
|
||||
|
||||
// Add the sampled color at the offset position to the accumulator.
|
||||
color += getInputColor(uv + offset);
|
||||
}
|
||||
}
|
||||
|
||||
// Normalize the accumulated color by dividing by the total number of samples
|
||||
// and directions to ensure the result is averaged.
|
||||
return color / samples / directions;
|
||||
}
|
||||
|
||||
|
||||
|
||||
// The width of the fading effect is loaded from the settings.
|
||||
uniform float uBlurAmount;
|
||||
uniform float uBlurQuality;
|
||||
|
||||
void main() {
|
||||
|
||||
// Calculate the progression value based on the animation direction.
|
||||
// If opening, use uProgress as-is; if closing, invert the progression.
|
||||
float progl = uForOpening ? uProgress : 1.0 - uProgress;
|
||||
|
||||
float easedProgressBlur = easeInOutSine(progl); // Blur easing
|
||||
float easedProgressAlpha = easeInOutCubic(progl); // Alpha easing
|
||||
// Apply easing functions to the progression value:
|
||||
// - easedProgressBlur: Used for controlling the blur effect smoothly.
|
||||
// - easedProgressAlpha: Used for controlling the alpha (opacity) transition.
|
||||
float easedProgressBlur = easeInOutSine(progl); // Sine-based smooth easing for blur.
|
||||
float easedProgressAlpha = easeInOutCubic(progl); // Cubic-based smooth easing for alpha.
|
||||
|
||||
// Control blur amount using easedProgressBlur
|
||||
// Calculate the blur amount by interpolating (mixing) between the maximum blur (uBlurAmount)
|
||||
// and zero blur based on the eased progression value.
|
||||
float blurAmount = mix(uBlurAmount, 0.0, easedProgressBlur);
|
||||
|
||||
// Apply blur
|
||||
vec4 texColor = blur( iTexCoord.st, blurAmount, uBlurQuality);
|
||||
// Apply the calculated blur effect to the texture at the current texture coordinates.
|
||||
// The blur function uses the blur amount and quality (uBlurQuality) for sampling.
|
||||
vec4 texColor = blur(iTexCoord.st, blurAmount, uBlurQuality);
|
||||
|
||||
// Control alpha using easedProgressAlpha
|
||||
// Calculate the alpha value for the transition using eased progress.
|
||||
// This determines how transparent the final color will appear.
|
||||
float alpha = easedProgressAlpha;
|
||||
|
||||
// Set final color with alpha transition
|
||||
// Apply the alpha transition to the final texture color.
|
||||
// Multiply the texture's alpha channel by the computed alpha value.
|
||||
texColor.a *= alpha;
|
||||
|
||||
// Output the final color with the applied blur and alpha transition.
|
||||
setOutputColor(texColor);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,457 @@
|
||||
//////////////////////////////////////////////////////////////////////////////////////////
|
||||
// ) ( //
|
||||
// ( /( ( ( ) ( ( ( ( )\ ) ( ( //
|
||||
// )\()) ))\ )( ( ( )\ ) )\))( )\ ( (()/( ( )\))( ( //
|
||||
// ((_)\ /((_|()\ )\ ) )\ '(()/( ((_)()((_) )\ ) ((_)))\((_)()\ )\ //
|
||||
// | |(_|_))( ((_)_(_/( _((_)) )(_)) _(()((_|_)_(_/( _| |((_)(()((_|(_) //
|
||||
// | '_ \ || | '_| ' \)) | ' \()| || | \ V V / | ' \)) _` / _ \ V V (_-< //
|
||||
// |_.__/\_,_|_| |_||_| |_|_|_| \_, | \_/\_/|_|_||_|\__,_\___/\_/\_//__/ //
|
||||
// |__/ //
|
||||
//////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
// SPDX-FileCopyrightText: Justin Garza JGarza9788@gmail.com
|
||||
// SPDX-License-Identifier: GPL-3.0-or-later
|
||||
|
||||
// The content from common.glsl is automatically prepended to each shader effect. This
|
||||
// provides the standard input:
|
||||
|
||||
// vec2 iTexCoord: Texture coordinates for retrieving the window input color.
|
||||
// bool uIsFullscreen: True if the window is maximized or in fullscreen mode.
|
||||
// bool uForOpening: True if a window-open animation is ongoing, false otherwise.
|
||||
// float uProgress: A value which transitions from 0 to 1 during the animation.
|
||||
// float uDuration: The duration of the current animation in seconds.
|
||||
// vec2 uSize: The size of uTexture in pixels.
|
||||
// float uPadding: The empty area around the actual window (e.g. where the shadow
|
||||
// is drawn). For now, this will only be set on GNOME.
|
||||
|
||||
// Furthermore, there are two global methods for reading the window input color and
|
||||
// setting the shader output color. Both methods assume straight alpha:
|
||||
|
||||
// vec4 getInputColor(vec2 coords)
|
||||
// void setOutputColor(vec4 outColor)
|
||||
|
||||
// The width of the fading effect is loaded from the settings.
|
||||
|
||||
// use 8BitStyle or not (sliding scale)
|
||||
uniform float uScaleStyle;
|
||||
|
||||
//these are for the sparks
|
||||
uniform float uSparkCount;
|
||||
uniform vec4 uSparkColor;
|
||||
uniform float uSparkRotation;
|
||||
|
||||
//these are for the Rays
|
||||
uniform vec4 uRaysColor;
|
||||
|
||||
//these are for the stars
|
||||
uniform float uRingCount;
|
||||
uniform float uRingRotation;
|
||||
uniform float uStarCount;
|
||||
|
||||
// and the colors they change over time
|
||||
uniform vec4 uStarColor0;
|
||||
uniform vec4 uStarColor1;
|
||||
uniform vec4 uStarColor2;
|
||||
uniform vec4 uStarColor3;
|
||||
uniform vec4 uStarColor4;
|
||||
uniform vec4 uStarColor5;
|
||||
|
||||
//seed
|
||||
uniform vec2 uSeed;
|
||||
|
||||
//helps to find the angle
|
||||
vec3 getPosByAngle(float angle)
|
||||
{
|
||||
return vec3(cos(angle), sin(angle), 0);
|
||||
}
|
||||
|
||||
|
||||
//gets the mask of a Star
|
||||
float getStar(vec2 uv, vec2 center, float npoints, float radiusRatio, float size, float rotation)
|
||||
{
|
||||
|
||||
float radiusMax = 1.0;
|
||||
float radiusMin = radiusMax * radiusRatio;
|
||||
|
||||
float PI = 3.1415926;
|
||||
float starangle = 2.0 * PI / npoints; // Angle between points on the star
|
||||
|
||||
// Offset rotation to ensure one point is always up when rotation = 0
|
||||
rotation += PI / 2.0 - starangle / 1.0;
|
||||
|
||||
// Define the positions for the outer and inner points of the star's initial angle, rotated by `rotation`
|
||||
vec3 p0 = (radiusMax * size) * getPosByAngle(rotation); // Outer point, rotated by `rotation`
|
||||
vec3 p1 = (radiusMin * size) * getPosByAngle(starangle + rotation); // Inner point, also rotated
|
||||
|
||||
// Calculate the position of the current fragment relative to the star's center
|
||||
vec2 curPosuv = (uv - center); // Center UV coordinates, then scale to fit the star size
|
||||
float curRadius = length(curPosuv); // Radius from center, no need to scale further
|
||||
float curPosAngle = atan(curPosuv.y, curPosuv.x) - rotation; // Calculate angle and adjust by `rotation`
|
||||
|
||||
// Determine the fractional position within the current star segment
|
||||
float a = fract(curPosAngle / starangle); // Fractional angle position within one segment
|
||||
if (a >= 0.5)
|
||||
a = 1.0 - a; // Ensure we are within the first half of the segment (symmetry)
|
||||
|
||||
// Calculate the current point on the star segment, applying rotation
|
||||
a = a * starangle; // Actual angle for this position on the segment
|
||||
vec3 curPos = curRadius * getPosByAngle(a + rotation); // Final position, rotated
|
||||
|
||||
// Calculate directions for edge detection using cross product
|
||||
vec3 dir0 = p1 - p0; // Vector from outer to inner point
|
||||
vec3 dir1 = curPos - p0; // Vector from outer point to current position
|
||||
|
||||
// Use cross product to determine if `curPos` is inside the star's edge
|
||||
return step(0.0, cross(dir0, dir1).z); // Returns 1.0 if inside, 0.0 if outside (solid edge)
|
||||
}
|
||||
|
||||
|
||||
//use to scale the window
|
||||
vec2 scaleUV(vec2 uv, vec2 scale)
|
||||
{
|
||||
// Put texture coordinate origin to center of window.
|
||||
uv = uv * 2.0 - 1.0;
|
||||
|
||||
//scale
|
||||
uv /= mix(vec2(1.0,1.0), vec2(0.0,0.0), scale);
|
||||
|
||||
// scale from center
|
||||
uv = uv * 0.5 + 0.5;
|
||||
|
||||
return uv;
|
||||
}
|
||||
|
||||
|
||||
//this returns the Spark
|
||||
float getSpark(vec2 uv, vec2 center, float brightness, float size, float rotation)
|
||||
{
|
||||
brightness = clamp(brightness,0.001,1.0);
|
||||
size = clamp(size,0.001,1.0);
|
||||
float bn = mix(0.0,0.07,brightness); //recalculate size
|
||||
|
||||
uv = (uv + vec2(0.5)) ;
|
||||
uv = (uv - center) ;//Center UV coordinates, then scale to fit the star size
|
||||
uv = scaleUV(uv, vec2(1.0 - size));
|
||||
uv = rotate(uv, rotation, vec2(0.5)); //rotate the UV
|
||||
|
||||
//this is basically the brightness
|
||||
float p = mix(-1.0,1000.0,easeInExpo(bn));
|
||||
|
||||
float m = mix(
|
||||
0.0,
|
||||
1.0,
|
||||
clamp(
|
||||
pow(abs(uv.x-0.5)*2.0,p) + pow(abs(uv.y-0.5)*2.0,p),0.0,1.0
|
||||
)
|
||||
);
|
||||
|
||||
|
||||
float mask = easeInSine(1.0 - (m - bn)) - 0.004 ;
|
||||
mask = clamp(mask,0.0,1.0);
|
||||
|
||||
return mask;
|
||||
|
||||
}
|
||||
|
||||
|
||||
//returns the star's color
|
||||
vec4 getStarColor(float v, float alpha) {
|
||||
// Clamp v to ensure it's in [0.0, 1.0]
|
||||
v = clamp(v, 0.0, 1.0);
|
||||
|
||||
// Define steps for color interpolation
|
||||
float steps[6];
|
||||
steps[0] = 0.0;
|
||||
steps[1] = 0.1666;
|
||||
steps[2] = 0.3332;
|
||||
steps[3] = 0.4998;
|
||||
steps[4] = 0.6664;
|
||||
steps[5] = 0.8330;
|
||||
|
||||
// Define color values
|
||||
vec4 colors[6];
|
||||
colors[0] = uStarColor0;
|
||||
colors[1] = uStarColor1;
|
||||
colors[2] = uStarColor2;
|
||||
colors[3] = uStarColor3;
|
||||
colors[4] = uStarColor4;
|
||||
colors[5] = uStarColor5;
|
||||
|
||||
// Assign alpha values
|
||||
for (int i = 0; i < 6; ++i) {
|
||||
colors[i].a = alpha * colors[i].a;
|
||||
}
|
||||
|
||||
// Handle edge cases
|
||||
if (v <= steps[0]) {
|
||||
return colors[0];
|
||||
}
|
||||
if (v >= steps[5]) {
|
||||
return colors[5];
|
||||
}
|
||||
|
||||
// Find the correct interpolation segment
|
||||
for (int i = 0; i < 5; ++i) {
|
||||
if (v <= steps[i + 1]) {
|
||||
float t = (v - steps[i]) / (steps[i + 1] - steps[i]);
|
||||
return mix(colors[i], colors[i + 1], t);
|
||||
}
|
||||
}
|
||||
|
||||
// Fallback (should never be reached)
|
||||
return vec4(0.0, 0.0, 0.0, 1.0);
|
||||
}
|
||||
|
||||
|
||||
|
||||
// 1| __________
|
||||
// | / \
|
||||
// | / \
|
||||
// | / \
|
||||
// |/ \
|
||||
// 0|0.................1
|
||||
/*
|
||||
graph above ... where t is close to 0, or 1 the result will fade to zero
|
||||
i.e. this is just the function of power(x,p) shifted
|
||||
where x is time, and p is 2.0,4.0,8.0,10.0 ... or any positive even number
|
||||
*/
|
||||
float zeroStartEnd(float t, float max_size, float power)
|
||||
{
|
||||
float s = -1.0 * pow((t-0.5)/(0.5),power)+1.0;
|
||||
s = clamp(s,0.0,1.0) * max_size;
|
||||
return s;
|
||||
}
|
||||
|
||||
//this gives us the jerky 8bit growth effect.
|
||||
float eightBitScale(float progress)
|
||||
{
|
||||
float scale = 1.0;
|
||||
if (progress <= 0.1)
|
||||
{
|
||||
scale = 0.25;
|
||||
}
|
||||
else if (progress <= 0.2)
|
||||
{
|
||||
scale = 0.5;
|
||||
}
|
||||
else if (progress <= 0.3)
|
||||
{
|
||||
scale = 0.25;
|
||||
}
|
||||
else if (progress <= 0.4)
|
||||
{
|
||||
scale = 0.5;
|
||||
}
|
||||
else if (progress <= 0.5)
|
||||
{
|
||||
scale = 0.25;
|
||||
}
|
||||
else if (progress <= 0.6)
|
||||
{
|
||||
scale = 0.5;
|
||||
}
|
||||
else if (progress <= 0.7)
|
||||
{
|
||||
scale = 1.0;
|
||||
}
|
||||
else if (progress <= 0.8)
|
||||
{
|
||||
scale = 0.25;
|
||||
}
|
||||
else if (progress <= 0.9)
|
||||
{
|
||||
scale = 0.5;
|
||||
}
|
||||
return scale;
|
||||
}
|
||||
|
||||
|
||||
//gets all the sparks
|
||||
vec4 getSparks(float progress)
|
||||
{
|
||||
//the UV for this function
|
||||
float aspect = uSize.x / uSize.y;
|
||||
vec2 uv = iTexCoord.st * vec2(aspect,1.0);
|
||||
|
||||
//this will be the result to return
|
||||
vec4 result = vec4(0.0);
|
||||
|
||||
// 0 at the edges
|
||||
float xEdge = -1.0 * pow((uv.x-(aspect*0.5))/(aspect*0.5),8.0)+1.0;
|
||||
xEdge = clamp(xEdge,0.0,1.0);
|
||||
|
||||
//declare some variables before the loop
|
||||
vec2 h = vec2(0.0);
|
||||
float y = 0.0;
|
||||
float x = 0.0;
|
||||
|
||||
//loop for each spart
|
||||
for (float xusp = 0.0; xusp < uSparkCount; ++xusp)
|
||||
{
|
||||
//calculate some variables
|
||||
h = hash21(xusp + uSeed.x);
|
||||
y = mix( 0.0 - h.y , 1.0+(1.0-h.y) , progress);
|
||||
y = clamp(y,0.0,1.0);
|
||||
|
||||
x = 0.66 * sin(h.x * 6.28) ;
|
||||
x += 0.5 * aspect;
|
||||
|
||||
//here we get the mask for the spark
|
||||
float a4ps = getSpark(
|
||||
uv,
|
||||
vec2( x , y), //position (x, y)
|
||||
zeroStartEnd(y,1.0 ,4.0) * xEdge ,//Brightness
|
||||
zeroStartEnd(y,0.5 ,4.0) * xEdge,//Size
|
||||
progress * 6.28 * float(uSparkRotation) //rotation
|
||||
);
|
||||
|
||||
//set it to the results
|
||||
result = alphaOver(
|
||||
result,
|
||||
vec4(uSparkColor.r,uSparkColor.g,uSparkColor.b,uSparkColor.a * a4ps)
|
||||
);
|
||||
}
|
||||
|
||||
// and we are returning the result
|
||||
return result;
|
||||
}
|
||||
|
||||
//gets the Rays
|
||||
vec4 getRays(float progress)
|
||||
{
|
||||
//create the UV for it
|
||||
vec2 rayUV = iTexCoord.st;
|
||||
rayUV *= vec2(10.0,0.5);
|
||||
rayUV.y += progress * -1.0;
|
||||
rayUV.x += uSeed.y;
|
||||
|
||||
//gets the ray
|
||||
float ray = simplex2D(rayUV);
|
||||
//0 around the edges
|
||||
ray *= zeroStartEnd(iTexCoord.t,1.0,8.0);
|
||||
ray *= zeroStartEnd(iTexCoord.s,1.0,8.0);
|
||||
// 0 at the begining and end of the animation
|
||||
ray *= zeroStartEnd(progress,1.0,8.0);
|
||||
|
||||
//adjust the numbers and clamp
|
||||
ray = remap(
|
||||
ray * 1.10,
|
||||
0.0,1.0,
|
||||
-5.0,1.0
|
||||
);
|
||||
|
||||
float alpha = clamp(uRaysColor.a * ray,0.0,1.0);
|
||||
|
||||
//return
|
||||
return vec4(uRaysColor.r,uRaysColor.g,uRaysColor.b,alpha);
|
||||
|
||||
}
|
||||
|
||||
//returns the stars
|
||||
vec4 getStars(vec2 starUV, float aspect, float progress, float oColorAlpha)
|
||||
{
|
||||
//this will be the result to return
|
||||
vec4 result = vec4(0.0);
|
||||
|
||||
vec2 h = vec2(0.0);
|
||||
float y = 0.0;
|
||||
|
||||
//for each ring
|
||||
for (float r = 0.0; r < uRingCount; ++r)
|
||||
{
|
||||
|
||||
float spread = r*(1.0/uRingCount);
|
||||
y = mix( 0.0 - spread , 1.0+(1.0-spread) , 1.0 - progress);
|
||||
y = clamp(y,0.00001,0.99999);
|
||||
|
||||
//each star in each ring
|
||||
for (float s = 0.0; s < uStarCount; ++s)
|
||||
{
|
||||
float a5ps = getStar(
|
||||
starUV,
|
||||
vec2( sin(progress * uRingRotation * 6.28 + (s*(6.28/uStarCount))) * aspect * 0.33 , y), //position (x, y)
|
||||
5.0, //nPoints
|
||||
0.5, //radiusRatio
|
||||
zeroStartEnd(y,0.1,2.0), //Size
|
||||
0.0 //rotation
|
||||
);
|
||||
a5ps = clamp(a5ps,0.0,1.0);
|
||||
|
||||
// //put the star in back or the front of the window
|
||||
float depth = cos(progress * uRingRotation * 6.28 + (s*(6.28/uStarCount)) );
|
||||
if (depth < 0.0)
|
||||
{
|
||||
result = alphaOver(result,getStarColor(y,a5ps));
|
||||
}
|
||||
else
|
||||
{
|
||||
result = alphaOver(getStarColor(y,a5ps) * (1.0 - oColorAlpha),result);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
// and we are returning the result
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
void main() {
|
||||
|
||||
// Calculate the animation progress, flipping direction if opening
|
||||
// 'uProgress' varies from 0 to 1, depending on the animation phase
|
||||
float progress = uForOpening ? 1.0 - uProgress : uProgress;
|
||||
|
||||
// Initialize the output color to fully transparent black
|
||||
vec4 oColor = vec4(0.0, 0.0, 0.0, 0.0);
|
||||
|
||||
|
||||
//get scales
|
||||
float scale8bit = eightBitScale(progress);
|
||||
vec2 scaleV2 = vec2(easeInOutSine(progress), easeInQuad(progress));
|
||||
|
||||
vec2 fscale = mix(vec2(scale8bit),scaleV2,uScaleStyle);
|
||||
|
||||
// Fetch the color based on the scaled texture coordinates
|
||||
oColor = getInputColor(
|
||||
scaleUV(iTexCoord.st, fscale)
|
||||
);
|
||||
|
||||
// Store the alpha value of the fetched color for later use
|
||||
float oColorAlpha = oColor.a;
|
||||
|
||||
// Calculate the aspect ratio of the render area
|
||||
float aspect = uSize.x / uSize.y;
|
||||
|
||||
// Transform UV coordinates for star effects
|
||||
// starUV.x [-0.5 , 0.5]
|
||||
// starUV.y [1.0 , 0.0]
|
||||
vec2 starUV = vec2(iTexCoord.s - 0.5, 1.0 - iTexCoord.t) * vec2(aspect, 1.0);
|
||||
|
||||
// If four-point stars are enabled, overlay them on the current color
|
||||
if (uSparkCount > 0.0)
|
||||
{
|
||||
oColor = alphaOver(oColor, getSparks(progress));
|
||||
}
|
||||
|
||||
// If rays are enabled, overlay them on the current color
|
||||
if (uRaysColor.a > 0.0)
|
||||
{
|
||||
oColor = alphaOver(oColor, getRays(progress));
|
||||
}
|
||||
|
||||
|
||||
// If five-point stars are enabled, overlay them using stored alpha
|
||||
if (uRingCount > 0.0 && uStarCount > 0.0)
|
||||
{
|
||||
oColor = alphaOver(oColor, getStars(starUV, aspect, progress, oColorAlpha));
|
||||
}
|
||||
|
||||
|
||||
// Set the final output color to the computed value
|
||||
setOutputColor(oColor);
|
||||
|
||||
}
|
||||
@@ -0,0 +1,91 @@
|
||||
//////////////////////////////////////////////////////////////////////////////////////////
|
||||
// ) ( //
|
||||
// ( /( ( ( ) ( ( ( ( )\ ) ( ( //
|
||||
// )\()) ))\ )( ( ( )\ ) )\))( )\ ( (()/( ( )\))( ( //
|
||||
// ((_)\ /((_|()\ )\ ) )\ '(()/( ((_)()((_) )\ ) ((_)))\((_)()\ )\ //
|
||||
// | |(_|_))( ((_)_(_/( _((_)) )(_)) _(()((_|_)_(_/( _| |((_)(()((_|(_) //
|
||||
// | '_ \ || | '_| ' \)) | ' \()| || | \ V V / | ' \)) _` / _ \ V V (_-< //
|
||||
// |_.__/\_,_|_| |_||_| |_|_|_| \_, | \_/\_/|_|_||_|\__,_\___/\_/\_//__/ //
|
||||
// |__/ //
|
||||
//////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
// SPDX-FileCopyrightText: Justin Garza JGarza9788@gmail.com
|
||||
// SPDX-License-Identifier: GPL-3.0-or-later
|
||||
|
||||
// The content from common.glsl is automatically prepended to each shader effect. This
|
||||
// provides the standard input:
|
||||
|
||||
// vec2 iTexCoord: Texture coordinates for retrieving the window input color.
|
||||
// bool uIsFullscreen: True if the window is maximized or in fullscreen mode.
|
||||
// bool uForOpening: True if a window-open animation is ongoing, false otherwise.
|
||||
// float uProgress: A value which transitions from 0 to 1 during the animation.
|
||||
// float uDuration: The duration of the current animation in seconds.
|
||||
// vec2 uSize: The size of uTexture in pixels.
|
||||
// float uPadding: The empty area around the actual window (e.g. where the shadow
|
||||
// is drawn). For now, this will only be set on GNOME.
|
||||
|
||||
// Furthermore, there are two global methods for reading the window input color and
|
||||
// setting the shader output color. Both methods assume straight alpha:
|
||||
|
||||
// vec4 getInputColor(vec2 coords)
|
||||
// void setOutputColor(vec4 outColor)
|
||||
|
||||
uniform float uWavesize;
|
||||
uniform float uBrightness;
|
||||
uniform float uStretchR;
|
||||
uniform float uStretchG;
|
||||
uniform float uStretchB;
|
||||
|
||||
|
||||
float FadeInOut(float t, float power)
|
||||
{
|
||||
float s = -1.0 * pow((t-0.5)/(0.5),power)+1.0;
|
||||
s = clamp(s,0.0,1.0);
|
||||
return s;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
void main() {
|
||||
|
||||
// Calculate the progression value based on the animation direction.
|
||||
// If opening, use uProgress as-is; if closing, invert the progression.
|
||||
float progress = uForOpening ? uProgress : 1.0 - uProgress;
|
||||
|
||||
//progress will now go from 0.5 to 1.0
|
||||
progress = mix(0.5,1.0,progress);
|
||||
|
||||
// the UV
|
||||
vec2 uv = iTexCoord.st;
|
||||
//flipped the uv
|
||||
vec2 f = vec2(uv.x,1.0 - uv.y);
|
||||
|
||||
// w is the wave
|
||||
float w = 0.0;
|
||||
|
||||
float p = mix(0.0, 1.0 + uWavesize, progress);
|
||||
w = 1.0 - abs(p - f.y);
|
||||
w = clamp(w,0.0,1.0);
|
||||
|
||||
w = pow(w, mix(100.0,1.0,uWavesize) );
|
||||
|
||||
float mask = 1.0;
|
||||
if (p - f.y < 0.0)
|
||||
{
|
||||
mask = 0.0;
|
||||
w = 0.0;
|
||||
}
|
||||
|
||||
vec4 oColor = vec4(0.0);
|
||||
|
||||
oColor.r = getInputColor(uv + vec2(0.0,w * uStretchR ) ).r * mix(1.0, uBrightness, FadeInOut(progress,4));
|
||||
oColor.g = getInputColor(uv + vec2(0.0,w * uStretchG ) ).g * mix(1.0, uBrightness, FadeInOut(progress,4));
|
||||
oColor.b = getInputColor(uv + vec2(0.0,w * uStretchB ) ).b * mix(1.0, uBrightness, FadeInOut(progress,4));
|
||||
|
||||
//if you can think of a better way to handle the alpha ... try that
|
||||
oColor.a = getInputColor(uv).a * easeInOutSine(progress) * mask;
|
||||
|
||||
|
||||
setOutputColor(oColor);
|
||||
}
|
||||
@@ -0,0 +1,213 @@
|
||||
//////////////////////////////////////////////////////////////////////////////////////////
|
||||
// ) ( //
|
||||
// ( /( ( ( ) ( ( ( ( )\ ) ( ( //
|
||||
// )\()) ))\ )( ( ( )\ ) )\))( )\ ( (()/( ( )\))( ( //
|
||||
// ((_)\ /((_|()\ )\ ) )\ '(()/( ((_)()((_) )\ ) ((_)))\((_)()\ )\ //
|
||||
// | |(_|_))( ((_)_(_/( _((_)) )(_)) _(()((_|_)_(_/( _| |((_)(()((_|(_) //
|
||||
// | '_ \ || | '_| ' \)) | ' \()| || | \ V V / | ' \)) _` / _ \ V V (_-< //
|
||||
// |_.__/\_,_|_| |_||_| |_|_|_| \_, | \_/\_/|_|_||_|\__,_\___/\_/\_//__/ //
|
||||
// |__/ //
|
||||
//////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
// SPDX-FileCopyrightText: Justin Garza JGarza9788@gmail.com
|
||||
// SPDX-License-Identifier: GPL-3.0-or-later
|
||||
|
||||
// The content from common.glsl is automatically prepended to each shader effect. This
|
||||
// provides the standard input:
|
||||
|
||||
// vec2 iTexCoord: Texture coordinates for retrieving the window input color.
|
||||
// bool uIsFullscreen: True if the window is maximized or in fullscreen mode.
|
||||
// bool uForOpening: True if a window-open animation is ongoing, false otherwise.
|
||||
// float uProgress: A value which transitions from 0 to 1 during the animation.
|
||||
// float uDuration: The duration of the current animation in seconds.
|
||||
// vec2 uSize: The size of uTexture in pixels.
|
||||
// float uPadding: The empty area around the actual window (e.g. where the shadow
|
||||
// is drawn). For now, this will only be set on GNOME.
|
||||
|
||||
// Furthermore, there are two global methods for reading the window input color and
|
||||
// setting the shader output color. Both methods assume straight alpha:
|
||||
|
||||
// vec4 getInputColor(vec2 coords)
|
||||
// void setOutputColor(vec4 outColor)
|
||||
|
||||
// The width of the fading effect is loaded from the settings.
|
||||
// uniform float uFadeWidth;
|
||||
|
||||
uniform float uWT;
|
||||
uniform float uXpos;
|
||||
uniform float uYpos;
|
||||
uniform float uSparkleRot;
|
||||
uniform float uSparkleSize;
|
||||
uniform bool uWinRot;
|
||||
uniform vec2 uSeed;
|
||||
|
||||
//use to scale the window
|
||||
vec2 scaleUV(vec2 uv, vec2 scale, vec2 centerOffset)
|
||||
{
|
||||
// Put texture coordinate origin to center of window.
|
||||
uv -= centerOffset;
|
||||
uv = uv * 2.0 - 1.0;
|
||||
|
||||
//scale
|
||||
uv /= mix(vec2(1.0,1.0), vec2(0.0,0.0), scale);
|
||||
|
||||
// scale from center
|
||||
uv = uv * 0.5 + 0.5;
|
||||
|
||||
|
||||
return uv;
|
||||
}
|
||||
|
||||
|
||||
//this returns the Spark
|
||||
float getSpark(vec2 uv, vec2 center, float brightness, float size, float rotation)
|
||||
{
|
||||
//the brightness of the spark
|
||||
brightness = clamp(brightness,0.001,1.0);
|
||||
//the size
|
||||
size = clamp(size,0.001,1.0);
|
||||
|
||||
float bn = mix(0.0,0.07,brightness); //recalculate size
|
||||
|
||||
uv = (uv + vec2(0.5)) ; //set center
|
||||
uv = (uv - center) ;//Center UV coordinates, then scale to fit the star size
|
||||
uv = scaleUV(uv, vec2(1.0 - size), vec2(0.0));
|
||||
uv = rotate(uv, rotation, vec2(0.5)); //rotate the UV
|
||||
|
||||
//this is basically the brightness
|
||||
float p = mix(-1.0,1000.0,easeInExpo(bn));
|
||||
|
||||
float m = mix(
|
||||
0.0,
|
||||
1.0,
|
||||
clamp(
|
||||
pow(abs(uv.x-0.5)*2.0,p) + pow(abs(uv.y-0.5)*2.0,p),0.0,1.0
|
||||
)
|
||||
);
|
||||
|
||||
//calcuate and return this mask
|
||||
float mask = easeInSine(1.0 - (m - bn)) - 0.004 ;
|
||||
mask = clamp(mask,0.0,1.0);
|
||||
return mask;
|
||||
|
||||
}
|
||||
|
||||
|
||||
//fades out at 0 and 1 ...based on the power
|
||||
// 1| __________
|
||||
// | / \
|
||||
// | / \
|
||||
// | / \
|
||||
// |/ \
|
||||
// 0|0.................1
|
||||
/*
|
||||
graph above ... where t is close to 0, or 1 the result will fade to zero
|
||||
i.e. this is just the function of power(x,p) shifted
|
||||
where x is time, and p is 2.0,4.0,8.0,10.0 ... or any positive even number
|
||||
*/
|
||||
float FadeInOut(float t, float power)
|
||||
{
|
||||
float s = -1.0 * pow((t-0.5)/(0.5),power)+1.0;
|
||||
s = clamp(s,0.0,1.0);
|
||||
return s;
|
||||
}
|
||||
|
||||
//2x pi ... don't think too much about it
|
||||
float TAU = 6.28;
|
||||
|
||||
void main() {
|
||||
// Calculate the progression value based on the animation direction.
|
||||
// If opening, use uProgress as-is; if closing, invert the progression.
|
||||
float progress = uForOpening ? 1.0 - uProgress : uProgress ;
|
||||
|
||||
// scale progress ... the first half of the animation
|
||||
float scalep = remap(
|
||||
progress,
|
||||
0.0,uWT+0.1,
|
||||
0.0,1.0
|
||||
);
|
||||
|
||||
// scalep = easeInOutSine(scalep);
|
||||
scalep = easeOutQuad(scalep);
|
||||
|
||||
// sparkle progress ... the second half of the animation
|
||||
float sparkp = remap(
|
||||
progress,
|
||||
uWT-0.1,1.0,
|
||||
0.0,1.0
|
||||
);
|
||||
sparkp = easeInOutSine(sparkp);
|
||||
|
||||
/*
|
||||
the window will scale between 0.0 and 0.6 (of the progress)
|
||||
the sparkle will bet between 0.4 and 1.0 (of the progress)
|
||||
... so there is a tab bit of over lap
|
||||
*/
|
||||
|
||||
// // this is the offset of the window... don't let them go too far each way
|
||||
vec2 offset = vec2(uXpos,uYpos*-1.0) * 0.20;
|
||||
vec2 scaleOffset = mix(
|
||||
vec2(0.0),
|
||||
vec2(uXpos,uYpos*-1.0) * 0.50,
|
||||
scalep
|
||||
);
|
||||
|
||||
//the UV for this function
|
||||
float aspect = uSize.x / uSize.y;
|
||||
vec2 uv = iTexCoord.st * vec2(aspect,1.0);
|
||||
|
||||
//get and adjust
|
||||
vec2 uv2 = iTexCoord.st;
|
||||
uv2 = uv2 * 2.0 - 1.0;
|
||||
|
||||
//offset
|
||||
uv2 -= ( scaleOffset/ vec2(aspect,1.0) ) *scalep;
|
||||
|
||||
//scale
|
||||
uv2 /= mix(1.0, 0.0, scalep);
|
||||
|
||||
//rotation and if we are gonna rotate or not
|
||||
vec3 rot = vec3(0.0);
|
||||
if (uWinRot)
|
||||
{
|
||||
rot = hash32(uSeed);
|
||||
rot *= 2.0;
|
||||
rot -= 1.0;
|
||||
rot *= 0.1;
|
||||
}
|
||||
|
||||
//rotate around x, y , and z
|
||||
uv2.x /= mix(1.0, rot.x * TAU * uv2.y, scalep);
|
||||
uv2.y /= mix(1.0, rot.y * TAU * uv2.x, scalep);
|
||||
uv2 = rotate(uv2,rot.z*TAU*scalep);
|
||||
|
||||
//re-center
|
||||
uv2 = uv2 * 0.5 + 0.5;
|
||||
|
||||
//gets the window
|
||||
vec4 oColor = getInputColor( uv2) ;
|
||||
|
||||
//the sparksize will bet between 25.0 and 50.0
|
||||
float size = mix(25.0,50.0,uSparkleSize);
|
||||
|
||||
//get the sparkle
|
||||
float sparkle = getSpark(
|
||||
uv,
|
||||
offset + vec2(0.5 * aspect,0.5),
|
||||
FadeInOut(sparkp,2) * uSparkleSize,
|
||||
FadeInOut(sparkp,2) * size,
|
||||
sparkp * TAU * float(uSparkleRot)
|
||||
);
|
||||
//fade out at the edges
|
||||
sparkle *= FadeInOut(iTexCoord.t,8);
|
||||
sparkle *= FadeInOut(iTexCoord.s,8);
|
||||
|
||||
//set it to the results
|
||||
oColor = alphaOver(
|
||||
oColor,
|
||||
vec4(1.0,1.0,1.0,sparkle)
|
||||
);
|
||||
|
||||
//output the color
|
||||
setOutputColor(oColor);
|
||||
}
|
||||
@@ -0,0 +1,521 @@
|
||||
//////////////////////////////////////////////////////////////////////////////////////////
|
||||
// ) ( //
|
||||
// ( /( ( ( ) ( ( ( ( )\ ) ( ( //
|
||||
// )\()) ))\ )( ( ( )\ ) )\))( )\ ( (()/( ( )\))( ( //
|
||||
// ((_)\ /((_|()\ )\ ) )\ '(()/( ((_)()((_) )\ ) ((_)))\((_)()\ )\ //
|
||||
// | |(_|_))( ((_)_(_/( _((_)) )(_)) _(()((_|_)_(_/( _| |((_)(()((_|(_) //
|
||||
// | '_ \ || | '_| ' \)) | ' \()| || | \ V V / | ' \)) _` / _ \ V V (_-< //
|
||||
// |_.__/\_,_|_| |_||_| |_|_|_| \_, | \_/\_/|_|_||_|\__,_\___/\_/\_//__/ //
|
||||
// |__/ //
|
||||
//////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
// SPDX-FileCopyrightText: Justin Garza JGarza9788@gmail.com
|
||||
// SPDX-License-Identifier: GPL-3.0-or-later
|
||||
|
||||
// The content from common.glsl is automatically prepended to each shader effect. This
|
||||
// provides the standard input:
|
||||
|
||||
// vec2 iTexCoord: Texture coordinates for retrieving the window input color.
|
||||
// bool uIsFullscreen: True if the window is maximized or in fullscreen mode.
|
||||
// bool uForOpening: True if a window-open animation is ongoing, false otherwise.
|
||||
// float uProgress: A value which transitions from 0 to 1 during the animation.
|
||||
// float uDuration: The duration of the current animation in seconds.
|
||||
// vec2 uSize: The size of uTexture in pixels.
|
||||
// float uPadding: The empty area around the actual window (e.g. where the shadow
|
||||
// is drawn). For now, this will only be set on GNOME.
|
||||
|
||||
// Furthermore, there are two global methods for reading the window input color and
|
||||
// setting the shader output color. Both methods assume straight alpha:
|
||||
|
||||
// vec4 getInputColor(vec2 coords)
|
||||
// void setOutputColor(vec4 outColor)
|
||||
|
||||
// The width of the fading effect is loaded from the settings.
|
||||
|
||||
uniform float uSparkCount;
|
||||
uniform vec2 uSparkStartEnd;
|
||||
uniform float uSparkOffset;
|
||||
uniform float uStarCount;
|
||||
uniform float uStarRot;
|
||||
uniform float uStarSize;
|
||||
uniform vec2 uStarStartEnd;
|
||||
uniform float uBlurQuality;
|
||||
uniform float uSeed;
|
||||
|
||||
|
||||
//particle colors
|
||||
uniform vec4 uSparkColor0;
|
||||
uniform vec4 uSparkColor1;
|
||||
uniform vec4 uSparkColor2;
|
||||
uniform vec4 uSparkColor3;
|
||||
uniform vec4 uSparkColor4;
|
||||
uniform vec4 uSparkColor5;
|
||||
|
||||
//star colors
|
||||
uniform vec4 uStarColor0;
|
||||
uniform vec4 uStarColor1;
|
||||
uniform vec4 uStarColor2;
|
||||
uniform vec4 uStarColor3;
|
||||
uniform vec4 uStarColor4;
|
||||
uniform vec4 uStarColor5;
|
||||
|
||||
|
||||
// Define a constant for 2 * PI (tau), which represents a full circle in radians.
|
||||
const float PI = 3.14159265359;
|
||||
const float tau = 6.28318530718;
|
||||
|
||||
//helps to find the angle
|
||||
vec3 getPosByAngle(float angle)
|
||||
{
|
||||
return vec3(cos(angle), sin(angle), 0);
|
||||
}
|
||||
|
||||
//this returns the Spark
|
||||
float getSpark(vec2 uv,vec2 center, float brightness, float size, float rotation)
|
||||
{
|
||||
|
||||
//the size
|
||||
size = clamp(size,0.001,1.0);
|
||||
|
||||
uv = (uv + vec2(0.5)) ; //set center
|
||||
uv = (uv - center) ;//Center UV coordinates, then scale to fit the star size
|
||||
|
||||
//scale
|
||||
uv = uv * 2.0 -1.0;
|
||||
uv /= mix(vec2(1.0,1.0), vec2(0.0,0.0), vec2(1.0 - size));
|
||||
uv = uv * 0.5 + 0.5;
|
||||
|
||||
uv = rotate(uv, rotation, vec2(0.5));
|
||||
|
||||
|
||||
//the brightness of the spark
|
||||
brightness = clamp(brightness,0.001,1.0);
|
||||
float bn = mix(0.0,0.07,brightness); //recalculate size
|
||||
|
||||
|
||||
//this is basically the brightness
|
||||
float p = mix(-1.0,1000.0,easeInExpo(bn));
|
||||
|
||||
float m = mix(
|
||||
0.0,
|
||||
1.0,
|
||||
clamp(
|
||||
pow(abs(uv.x-0.5)*2.0,p) + pow(abs(uv.y-0.5)*2.0,p),0.0,1.0
|
||||
)
|
||||
);
|
||||
|
||||
//calcuate and return this mask
|
||||
float mask = easeInSine(1.0 - (m - bn)) - 0.004 ;
|
||||
mask = clamp(mask,0.0,1.0);
|
||||
return mask;
|
||||
|
||||
}
|
||||
|
||||
|
||||
//this was lifted from aura-glow
|
||||
float getMask(float t)
|
||||
{
|
||||
|
||||
// Calculate the aspect ratio of the render area
|
||||
float aspect = uSize.x / uSize.y;
|
||||
|
||||
//standard uv
|
||||
vec2 uv = iTexCoord.st;
|
||||
|
||||
// tuv is for when progress is near 0
|
||||
vec2 tuv = uv;
|
||||
tuv -= 0.5; // Shift UV coordinates to center (from [-0.5 to 0.5])
|
||||
tuv.x *= aspect; // Scale x-coordinate to match aspect ratio
|
||||
tuv += 0.5; // Shift UV coordinates back (from [0 to 1])
|
||||
|
||||
//mixing the UVs
|
||||
uv = mix(tuv,uv,t);
|
||||
|
||||
// this controls the shape
|
||||
// -1.0 would be a diamond-ish
|
||||
// 0.0 would be a rounded diamond
|
||||
// 1.0 would be a circle
|
||||
// 2.0 will be sqircle
|
||||
// 1000.0 will be very square
|
||||
float p = mix(1.0,1000.0,
|
||||
easeInExpo(t)
|
||||
);
|
||||
|
||||
//this will be used later to make a mask
|
||||
float m = mix(
|
||||
0.0,
|
||||
1.0,
|
||||
clamp(
|
||||
pow(abs(uv.x-0.5)*2.0,p) + pow(abs(uv.y-0.5)*2.0,p),0.0,1.0
|
||||
)
|
||||
);
|
||||
|
||||
//this is the mask
|
||||
//float mask = (m > t) ? 0.0 : 1.0 ;
|
||||
float mask = (m > t) ? (1.0 - (m - t)) : 1.0 ;
|
||||
mask = clamp(mask,0.0,1.0);
|
||||
|
||||
return mask;
|
||||
}
|
||||
|
||||
|
||||
// A simple blur function
|
||||
vec4 blur(vec2 uv, float radius, float samples) {
|
||||
// Initialize the color accumulator to zero.
|
||||
vec4 color = vec4(0.0);
|
||||
|
||||
|
||||
|
||||
// Number of directions for sampling around the circle.
|
||||
const float directions = 15.0;
|
||||
|
||||
// Outer loop iterates over multiple directions evenly spaced around a circle.
|
||||
for (float d = 0.0; d < tau; d += tau / directions) {
|
||||
// Inner loop samples along each direction, with decreasing intensity.
|
||||
for (float s = 0.0; s < 1.0; s += 1.0 / samples) {
|
||||
// Calculate the offset for this sample based on direction, radius, and step.
|
||||
// The (1.0 - s) term ensures more sampling occurs closer to the center.
|
||||
vec2 offset = vec2(cos(d), sin(d)) * radius * (1.0 - s) / uSize;
|
||||
|
||||
// Add the sampled color at the offset position to the accumulator.
|
||||
color += getInputColor(uv + offset);
|
||||
}
|
||||
}
|
||||
|
||||
// Normalize the accumulated color by dividing by the total number of samples
|
||||
// and directions to ensure the result is averaged.
|
||||
return color / samples / directions;
|
||||
}
|
||||
|
||||
|
||||
//fades out at 0 and 1 ...based on the power
|
||||
// 1| __________
|
||||
// | / \
|
||||
// | / \
|
||||
// | / \
|
||||
// |/ \
|
||||
// 0|0.................1
|
||||
/*
|
||||
graph above ... where t is close to 0, or 1 the result will fade to zero
|
||||
i.e. this is just the function of power(x,p) shifted
|
||||
where x is time, and p is 2.0,4.0,8.0,10.0 ... or any positive even number
|
||||
*/
|
||||
float FadeInOut(float t, float power)
|
||||
{
|
||||
float s = -1.0 * pow((t-0.5)/(0.5),power)+1.0;
|
||||
s = clamp(s,0.0,1.0);
|
||||
return s;
|
||||
}
|
||||
|
||||
|
||||
//returns the Spark's color
|
||||
vec4 getSparkColors(float v, float alpha) {
|
||||
// Clamp v to ensure it's in [0.0, 1.0]
|
||||
v = clamp(v, 0.0, 1.0);
|
||||
|
||||
// Define steps for color interpolation
|
||||
float steps[6];
|
||||
steps[0] = 0.0;
|
||||
steps[1] = 0.1666;
|
||||
steps[2] = 0.3332;
|
||||
steps[3] = 0.4998;
|
||||
steps[4] = 0.6664;
|
||||
steps[5] = 0.8330;
|
||||
|
||||
// Define color values
|
||||
vec4 colors[6];
|
||||
colors[0] = uSparkColor0 ;
|
||||
colors[1] = uSparkColor1 ;
|
||||
colors[2] = uSparkColor2 ;
|
||||
colors[3] = uSparkColor3 ;
|
||||
colors[4] = uSparkColor4 ;
|
||||
colors[5] = uSparkColor5 ;
|
||||
|
||||
// Assign alpha values
|
||||
for (int i = 0; i < 6; ++i) {
|
||||
colors[i].a = alpha * colors[i].a;
|
||||
}
|
||||
|
||||
// Handle edge cases
|
||||
if (v <= steps[0]) {
|
||||
return colors[0];
|
||||
}
|
||||
if (v >= steps[5]) {
|
||||
return colors[5];
|
||||
}
|
||||
|
||||
// Find the correct interpolation segment
|
||||
for (int i = 0; i < 5; ++i) {
|
||||
if (v <= steps[i + 1]) {
|
||||
float t = (v - steps[i]) / (steps[i + 1] - steps[i]);
|
||||
return mix(colors[i], colors[i + 1], t);
|
||||
}
|
||||
}
|
||||
|
||||
// Fallback (should never be reached)
|
||||
return vec4(0.0, 0.0, 0.0, 1.0);
|
||||
}
|
||||
|
||||
|
||||
|
||||
vec4 getSparks(float t)
|
||||
{
|
||||
|
||||
|
||||
//the UV for this function
|
||||
float aspect = uSize.x / uSize.y;
|
||||
vec2 uv = iTexCoord.st * vec2(aspect,1.0);
|
||||
|
||||
vec4 result = vec4(0.0);
|
||||
|
||||
//for each spark
|
||||
for (float i = 0.0; i < uSparkCount ; ++i)
|
||||
{
|
||||
//random values
|
||||
vec4 v4 = hash41( i * uSeed);
|
||||
|
||||
//the X and Y position ... at the end
|
||||
vec3 pos = getPosByAngle( (i/uSparkCount) * tau + (v4.x * 0.3) );
|
||||
|
||||
//the distance the spark will travel
|
||||
float d = mix(0.33,0.34,v4.z) ;
|
||||
d = mix(
|
||||
uSparkStartEnd.x + (v4.z * uSparkOffset),
|
||||
uSparkStartEnd.y - (v4.y * uSparkOffset),
|
||||
(1.0 - t)
|
||||
);
|
||||
|
||||
float s = getSpark(
|
||||
uv,
|
||||
vec2(0.5 * aspect,0.5) + ( pos.xy * d ), //position (x, y)
|
||||
FadeInOut(t,8.0) * 0.9 ,//Brightness
|
||||
FadeInOut(t,8.0) * (v4.w * 0.5) ,//Size
|
||||
0.0 //rotation
|
||||
);
|
||||
|
||||
|
||||
//set the color
|
||||
vec4 c = getSparkColors( hash11(v4.w) ,1.0);
|
||||
s = clamp(s*2.0,0.0,1.0);
|
||||
c.rgb *= s;
|
||||
c.a *= s;
|
||||
|
||||
result += c ;
|
||||
|
||||
}
|
||||
|
||||
//make it bright
|
||||
result.a = pow(result.a,2.0);
|
||||
|
||||
//fade at endges
|
||||
result.a *= FadeInOut(iTexCoord.s,4.0);
|
||||
result.a *= FadeInOut(iTexCoord.t,4.0);
|
||||
|
||||
return clamp(result,vec4(0.0),vec4(1.0));
|
||||
// return result;
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
vec4 getStarColors(float v, float alpha) {
|
||||
// Clamp v to ensure it's in [0.0, 1.0]
|
||||
v = clamp(v, 0.0, 1.0);
|
||||
|
||||
// Define steps for color interpolation
|
||||
float steps[6];
|
||||
steps[0] = 0.0;
|
||||
steps[1] = 0.1666;
|
||||
steps[2] = 0.3332;
|
||||
steps[3] = 0.4998;
|
||||
steps[4] = 0.6664;
|
||||
steps[5] = 0.8330;
|
||||
|
||||
// Define color values
|
||||
vec4 colors[6];
|
||||
colors[0] = uStarColor0 ;
|
||||
colors[1] = uStarColor1 ;
|
||||
colors[2] = uStarColor2 ;
|
||||
colors[3] = uStarColor3 ;
|
||||
colors[4] = uStarColor4 ;
|
||||
colors[5] = uStarColor5 ;
|
||||
|
||||
// Assign alpha values
|
||||
for (int i = 0; i < 6; ++i) {
|
||||
colors[i].a = alpha * colors[i].a;
|
||||
}
|
||||
|
||||
// Handle edge cases
|
||||
if (v <= steps[0]) {
|
||||
return colors[0];
|
||||
}
|
||||
if (v >= steps[5]) {
|
||||
return colors[5];
|
||||
}
|
||||
|
||||
// Find the correct interpolation segment
|
||||
for (int i = 0; i < 5; ++i) {
|
||||
if (v <= steps[i + 1]) {
|
||||
float t = (v - steps[i]) / (steps[i + 1] - steps[i]);
|
||||
return mix(colors[i], colors[i + 1], t);
|
||||
}
|
||||
}
|
||||
|
||||
// Fallback (should never be reached)
|
||||
return vec4(0.0, 0.0, 0.0, 1.0);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
//gets the mask of a Star
|
||||
float getStar(vec2 uv, vec2 center, float npoints, float radiusRatio, float size, float rotation)
|
||||
{
|
||||
|
||||
float radiusMax = 1.0;
|
||||
float radiusMin = radiusMax * radiusRatio;
|
||||
|
||||
float starangle = 2.0 * PI / npoints; // Angle between points on the star
|
||||
|
||||
// Offset rotation to ensure one point is always up when rotation = 0
|
||||
rotation += PI / 2.0 - starangle / 1.0;
|
||||
|
||||
// Define the positions for the outer and inner points of the star's initial angle, rotated by `rotation`
|
||||
vec3 p0 = (radiusMax * size) * getPosByAngle(rotation); // Outer point, rotated by `rotation`
|
||||
vec3 p1 = (radiusMin * size) * getPosByAngle(starangle + rotation); // Inner point, also rotated
|
||||
|
||||
// Calculate the position of the current fragment relative to the star's center
|
||||
vec2 curPosuv = (uv - center); // Center UV coordinates, then scale to fit the star size
|
||||
float curRadius = length(curPosuv); // Radius from center, no need to scale further
|
||||
float curPosAngle = atan(curPosuv.y, curPosuv.x) - rotation; // Calculate angle and adjust by `rotation`
|
||||
|
||||
// Determine the fractional position within the current star segment
|
||||
float a = fract(curPosAngle / starangle); // Fractional angle position within one segment
|
||||
if (a >= 0.5)
|
||||
a = 1.0 - a; // Ensure we are within the first half of the segment (symmetry)
|
||||
|
||||
// Calculate the current point on the star segment, applying rotation
|
||||
a = a * starangle; // Actual angle for this position on the segment
|
||||
vec3 curPos = curRadius * getPosByAngle(a + rotation); // Final position, rotated
|
||||
|
||||
// Calculate directions for edge detection using cross product
|
||||
vec3 dir0 = p1 - p0; // Vector from outer to inner point
|
||||
vec3 dir1 = curPos - p0; // Vector from outer point to current position
|
||||
|
||||
// Use cross product to determine if `curPos` is inside the star's edge
|
||||
return step(0.0, cross(dir0, dir1).z); // Returns 1.0 if inside, 0.0 if outside (solid edge)
|
||||
}
|
||||
|
||||
|
||||
//convert the XY to angle
|
||||
float XYtoAngle(vec2 XY)
|
||||
{
|
||||
return atan(XY.y, XY.x);
|
||||
}
|
||||
|
||||
|
||||
vec4 getStars(float t)
|
||||
{
|
||||
|
||||
//the UV for this function
|
||||
float aspect = uSize.x / uSize.y;
|
||||
vec2 uv = iTexCoord.st * vec2(aspect,1.0);
|
||||
|
||||
// float result = 0.0;
|
||||
vec4 result = vec4(0.0);
|
||||
|
||||
//loop for each star
|
||||
for (float i = 0.0; i < uStarCount ; ++i)
|
||||
{
|
||||
//random values for this star
|
||||
vec4 v4 = hash41( i * uSeed);
|
||||
|
||||
//the X and Y position ... at the end
|
||||
vec3 pos = getPosByAngle( (i/uStarCount) * tau + (uStarRot * tau * t) );
|
||||
|
||||
//the distance the spark will travel
|
||||
float d = mix(0.33,0.34,v4.z) ;
|
||||
d = mix(
|
||||
uStarStartEnd.x ,
|
||||
uStarStartEnd.y ,
|
||||
(1.0 - t)
|
||||
);
|
||||
|
||||
|
||||
float s = getStar(
|
||||
uv,
|
||||
vec2(0.5 * aspect,0.5) + ( pos.xy * d ), //position (x, y)
|
||||
5.0, //npoints
|
||||
0.5, //Ratio
|
||||
FadeInOut(t,4.0) * uStarSize,//Size
|
||||
PI //rotation
|
||||
);
|
||||
|
||||
|
||||
s *= FadeInOut(iTexCoord.s,4.0);
|
||||
s *= FadeInOut(iTexCoord.t,4.0);
|
||||
s = clamp(s,0.0,1.0);
|
||||
|
||||
//the color is based on it's starting location
|
||||
vec4 color = getStarColors( i/uStarCount ,1.0);
|
||||
result += vec4(color.rgb * s,s * color.a);
|
||||
|
||||
}
|
||||
|
||||
|
||||
return result;
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
void main() {
|
||||
// Calculate the progression value based on the animation direction.
|
||||
// If opening, use uProgress as-is; if closing, invert the progression.
|
||||
float progress = uForOpening ? 1.0 - uProgress : uProgress ;
|
||||
|
||||
//zero to one... mostly one
|
||||
float ztomo = remap(
|
||||
progress,
|
||||
0.0,0.1,
|
||||
0.0,1.0
|
||||
);
|
||||
ztomo = easeInOutSine(ztomo);
|
||||
|
||||
//progress variants
|
||||
// float oExpo = easeOutExpo(progress);
|
||||
// float iExpo = easeInExpo(progress);
|
||||
// float oQuad = easeOutQuad(progress);
|
||||
float ioCubic = easeInOutCubic(progress);
|
||||
float ioSine = easeInOutSine(progress);
|
||||
|
||||
vec2 uv = iTexCoord.st;
|
||||
//center
|
||||
uv = uv * 2.0 - 1.0;
|
||||
//scale
|
||||
uv /= mix(vec2(0.5,0.5), vec2(0.0,0.0), ioCubic);
|
||||
// scale from center
|
||||
uv = uv * 0.5 + 0.5;
|
||||
|
||||
//get blured version of the window
|
||||
vec4 oColor = blur(uv, ioCubic * 200.0,uBlurQuality);
|
||||
|
||||
oColor.a *= (1.0 - ioSine);
|
||||
|
||||
//get and apply sparks
|
||||
if (uSparkCount > 0)
|
||||
{
|
||||
vec4 sparks = getSparks(ioSine);
|
||||
oColor = alphaOver(oColor, sparks);
|
||||
}
|
||||
|
||||
//get and apply stars
|
||||
if (uStarCount > 0 )
|
||||
{
|
||||
oColor = alphaOver(oColor, getStars(mix(0.0001,0.999,ioSine)));
|
||||
}
|
||||
|
||||
setOutputColor(oColor);
|
||||
}
|
||||
Reference in New Issue
Block a user