🎉 🎉 Mushroom and AuraGlow ... in my main
placed both the Mushroom and AuraGlow in my main
This commit is contained in:
Justin Garza
@@ -0,0 +1,247 @@
|
||||
//////////////////////////////////////////////////////////////////////////////////////////
|
||||
// ) ( //
|
||||
// ( /( ( ( ) ( ( ( ( )\ ) ( ( //
|
||||
// )\()) ))\ )( ( ( )\ ) )\))( )\ ( (()/( ( )\))( ( //
|
||||
// ((_)\ /((_|()\ )\ ) )\ '(()/( ((_)()((_) )\ ) ((_)))\((_)()\ )\ //
|
||||
// | |(_|_))( ((_)_(_/( _((_)) )(_)) _(()((_|_)_(_/( _| |((_)(()((_|(_) //
|
||||
// | '_ \ || | '_| ' \)) | ' \()| || | \ 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;
|
||||
|
||||
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
// 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
|
||||
);
|
||||
progress = clamp(progress,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);
|
||||
//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);
|
||||
|
||||
}
|
||||
@@ -202,6 +202,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
|
||||
@@ -470,3 +583,53 @@ 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 newMin + (value - oldMin) * (newMax - newMin) / (oldMax - oldMin);
|
||||
}
|
||||
|
||||
// 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 newMin + (value - oldMin) * (newMax - newMin) / (oldMax - oldMin);
|
||||
}
|
||||
|
||||
// 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 newMin + (value - oldMin) * (newMax - newMin) / (oldMax - oldMin);
|
||||
}
|
||||
|
||||
// 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 newMin + (value - oldMin) * (newMax - newMin) / (oldMax - oldMin);
|
||||
}
|
||||
|
||||
@@ -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,450 @@
|
||||
//////////////////////////////////////////////////////////////////////////////////////////
|
||||
// ) ( //
|
||||
// ( /( ( ( ) ( ( ( ( )\ ) ( ( //
|
||||
// )\()) ))\ )( ( ( )\ ) )\))( )\ ( (()/( ( )\))( ( //
|
||||
// ((_)\ /((_|()\ )\ ) )\ '(()/( ((_)()((_) )\ ) ((_)))\((_)()\ )\ //
|
||||
// | |(_|_))( ((_)_(_/( _((_)) )(_)) _(()((_|_)_(_/( _| |((_)(()((_|(_) //
|
||||
// | '_ \ || | '_| ' \)) | ' \()| || | \ 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
|
||||
uniform bool u8BitStyle;
|
||||
|
||||
//these are for the 4 point stars (or sparks)
|
||||
uniform bool uEnable4PStars;
|
||||
uniform float u4PStars;
|
||||
uniform vec4 u4PSColor;
|
||||
uniform float u4PSRotation;
|
||||
|
||||
//these are for the Rays
|
||||
uniform bool uEnableRays;
|
||||
uniform vec4 uRaysColor;
|
||||
|
||||
//these are for the 5 pointed stars
|
||||
uniform bool uEnable5pStars;
|
||||
uniform float uRings;
|
||||
uniform float uRingRotation;
|
||||
uniform float uStarPerRing;
|
||||
// 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;
|
||||
|
||||
//helps to find the angle
|
||||
vec3 getPosByAngle(float angle)
|
||||
{
|
||||
return vec3(cos(angle), sin(angle), 0);
|
||||
}
|
||||
|
||||
|
||||
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)
|
||||
}
|
||||
|
||||
|
||||
float getStarWithFade(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
|
||||
|
||||
float crossZ = dir0.x * dir1.y - dir0.y * dir1.x;
|
||||
|
||||
float result = remap(
|
||||
crossZ,
|
||||
0.0,0.03,//0.0275,
|
||||
0.0,1.0 //hardness [1.0,100]
|
||||
);
|
||||
|
||||
//brightness
|
||||
result = result * 7.0;
|
||||
result = clamp(result,0.0,1.0);
|
||||
result = easeInSine(result);
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
float zeroStartEnd(float t, float max_size, float 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 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;
|
||||
}
|
||||
|
||||
//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;
|
||||
}
|
||||
|
||||
|
||||
|
||||
vec4 get4pStars(vec2 starUV, float progress)
|
||||
{
|
||||
//this will be the result to return
|
||||
vec4 result = vec4(0.0);
|
||||
|
||||
vec2 h = vec2(0.0);
|
||||
float y = 0.0;
|
||||
|
||||
for (float x = 0.0; x < u4PStars; ++x)
|
||||
{
|
||||
h = hash21(x);
|
||||
y = mix( 0.0 - h.y , 1.0+(1.0-h.y) , (1.0 - progress));
|
||||
|
||||
float a4ps = getStarWithFade(
|
||||
starUV,
|
||||
vec2( sin(h.x * 6.28 ) * 0.66, y), //position (x, y)
|
||||
4.0, //nPoints
|
||||
0.33, //radiusRatio
|
||||
zeroStartEnd(y,0.1 ,4.0), //Size
|
||||
progress * 6.28 * float(u4PSRotation) //rotation
|
||||
);
|
||||
|
||||
result = alphaOver(
|
||||
result,
|
||||
vec4(u4PSColor.r,u4PSColor.g,u4PSColor.b,u4PSColor.a * a4ps)
|
||||
);
|
||||
}
|
||||
|
||||
// and we are returning the result
|
||||
return result;
|
||||
}
|
||||
|
||||
vec4 getRays(float progress)
|
||||
{
|
||||
vec2 rayUV = iTexCoord.st;
|
||||
rayUV *= vec2(10.0,0.5);
|
||||
rayUV.y += progress * -1.0;
|
||||
|
||||
float ray = simplex2D(rayUV);
|
||||
ray *= zeroStartEnd(iTexCoord.t,1.0,8.0);
|
||||
ray *= zeroStartEnd(progress,1.0,8.0);
|
||||
|
||||
|
||||
ray = remap(
|
||||
ray * 1.10,
|
||||
0.0,1.0,
|
||||
-5.0,1.0
|
||||
);
|
||||
ray = clamp(ray,0.0,1.0);
|
||||
|
||||
return vec4(uRaysColor.r,uRaysColor.g,uRaysColor.b,uRaysColor.a * ray);
|
||||
|
||||
}
|
||||
|
||||
vec4 get5PStars(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 < uRings; ++r)
|
||||
{
|
||||
|
||||
float spread = r*(1.0/uRings);
|
||||
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 < uStarPerRing; ++s)
|
||||
{
|
||||
float a5ps = getStar(
|
||||
starUV,
|
||||
vec2( sin(progress * uRingRotation * 6.28 + (s*(6.28/uStarPerRing))) * 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/uStarPerRing)) );
|
||||
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);
|
||||
|
||||
// Check if the 8-bit style is enabled
|
||||
if (u8BitStyle)
|
||||
{
|
||||
// Scale UV coordinates using a custom 8-bit scaling function
|
||||
float scale8bit = eightBitScale(progress);
|
||||
|
||||
// Fetch the color based on the scaled texture coordinates
|
||||
oColor = getInputColor(
|
||||
scaleUV(iTexCoord.st, vec2(scale8bit, scale8bit))
|
||||
);
|
||||
}
|
||||
else
|
||||
{
|
||||
// Non-8-bit style: Calculate scaling factors using easing functions
|
||||
vec2 scaleV2 = vec2(easeInOutSine(progress), easeInQuad(progress));
|
||||
|
||||
// Fetch the color based on the scaled texture coordinates
|
||||
oColor = getInputColor(
|
||||
scaleUV(iTexCoord.st, scaleV2)
|
||||
);
|
||||
|
||||
// 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
|
||||
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 (uEnable4PStars)
|
||||
{
|
||||
oColor = alphaOver(oColor, get4pStars(starUV, progress));
|
||||
}
|
||||
|
||||
// If rays are enabled, overlay them on the current color
|
||||
if (uEnableRays)
|
||||
{
|
||||
oColor = alphaOver(oColor, getRays(progress));
|
||||
}
|
||||
|
||||
// If five-point stars are enabled, overlay them using stored alpha
|
||||
if (uEnable5pStars)
|
||||
{
|
||||
oColor = alphaOver(oColor, get5PStars(starUV, aspect, progress, oColorAlpha));
|
||||
}
|
||||
}
|
||||
|
||||
// Set the final output color to the computed value
|
||||
setOutputColor(oColor);
|
||||
|
||||
}
|
||||
Reference in New Issue
Block a user