Add FPS counter, VSync toggle, shader metadata system, and multi-pass infrastructure
- FPS counter in window title (updates every 500ms) - F4 key toggles VSync on/off - Shader metadata: Name and Author from comments - iChannel metadata parsing for multi-pass support - Base structures: ShaderBuffer, ShaderPass - FBO/texture management functions - Updated all 11 shaders with Name/Author metadata 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
82
shaders/cineshader_lava.frag.glsl
Normal file
82
shaders/cineshader_lava.frag.glsl
Normal file
@@ -0,0 +1,82 @@
|
||||
// Name: Cineshader Lava
|
||||
// Author: [TO_BE_COMPLETED]
|
||||
#version 330 core
|
||||
precision highp float;
|
||||
|
||||
out vec4 FragColor;
|
||||
in vec2 vUV;
|
||||
uniform vec2 iResolution;
|
||||
uniform float iTime;
|
||||
|
||||
float opSmoothUnion( float d1, float d2, float k )
|
||||
{
|
||||
float h = clamp( 0.5 + 0.5*(d2-d1)/k, 0.0, 1.0 );
|
||||
return mix( d2, d1, h ) - k*h*(1.0-h);
|
||||
}
|
||||
|
||||
float sdSphere( vec3 p, float s )
|
||||
{
|
||||
return length(p)-s;
|
||||
}
|
||||
|
||||
float map(vec3 p)
|
||||
{
|
||||
float d = 2.0;
|
||||
for (int i = 0; i < 16; i++) {
|
||||
float fi = float(i);
|
||||
float time = iTime * (fract(fi * 412.531 + 0.513) - 0.5) * 2.0;
|
||||
d = opSmoothUnion(
|
||||
sdSphere(p + sin(time + fi * vec3(52.5126, 64.62744, 632.25)) * vec3(2.0, 2.0, 0.8), mix(0.5, 1.0, fract(fi * 412.531 + 0.5124))),
|
||||
d,
|
||||
0.4
|
||||
);
|
||||
}
|
||||
return d;
|
||||
}
|
||||
|
||||
vec3 calcNormal( in vec3 p )
|
||||
{
|
||||
const float h = 1e-5; // or some other value
|
||||
const vec2 k = vec2(1,-1);
|
||||
return normalize( k.xyy*map( p + k.xyy*h ) +
|
||||
k.yyx*map( p + k.yyx*h ) +
|
||||
k.yxy*map( p + k.yxy*h ) +
|
||||
k.xxx*map( p + k.xxx*h ) );
|
||||
}
|
||||
|
||||
void mainImage( out vec4 fragColor, in vec2 fragCoord )
|
||||
{
|
||||
vec2 uv = fragCoord/iResolution.xy;
|
||||
|
||||
// screen size is 6m x 6m
|
||||
vec3 rayOri = vec3((uv - 0.5) * vec2(iResolution.x/iResolution.y, 1.0) * 6.0, 3.0);
|
||||
vec3 rayDir = vec3(0.0, 0.0, -1.0);
|
||||
|
||||
float depth = 0.0;
|
||||
vec3 p;
|
||||
|
||||
for(int i = 0; i < 64; i++) {
|
||||
p = rayOri + rayDir * depth;
|
||||
float dist = map(p);
|
||||
depth += dist;
|
||||
if (dist < 1e-6) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
depth = min(6.0, depth);
|
||||
vec3 n = calcNormal(p);
|
||||
float b = max(0.0, dot(n, vec3(0.577)));
|
||||
vec3 col = (0.5 + 0.5 * cos((b + iTime * 3.0) + uv.xyx * 2.0 + vec3(0,2,4))) * (0.85 + b * 0.35);
|
||||
col *= exp( -depth * 0.15 );
|
||||
|
||||
// maximum thickness is 2m in alpha channel
|
||||
fragColor = vec4(col, 1.0 - (depth - 0.5) / 2.0);
|
||||
}
|
||||
|
||||
void main() {
|
||||
vec2 fragCoordPixels = vUV * iResolution;
|
||||
vec4 outColor;
|
||||
mainImage(outColor, fragCoordPixels);
|
||||
FragColor = outColor;
|
||||
}
|
||||
@@ -1,3 +1,5 @@
|
||||
// Name: Creation
|
||||
// Author: [TO_BE_COMPLETED]
|
||||
#version 330 core
|
||||
precision highp float;
|
||||
|
||||
|
||||
189
shaders/dbz.frag.glsl
Normal file
189
shaders/dbz.frag.glsl
Normal file
@@ -0,0 +1,189 @@
|
||||
// Name: DBZ
|
||||
// Author: [TO_BE_COMPLETED]
|
||||
#version 330 core
|
||||
precision highp float;
|
||||
|
||||
out vec4 FragColor;
|
||||
in vec2 vUV;
|
||||
uniform vec2 iResolution;
|
||||
uniform float iTime;
|
||||
|
||||
// A small improv/fanart from yesterday.
|
||||
|
||||
#define s(a,b,c) smoothstep(a,b,c)
|
||||
#define PI 3.14159
|
||||
#define NBCaps 3.
|
||||
|
||||
mat2 r2d( float a ){ float c = cos(a), s = sin(a); return mat2( c, s, -s, c ); }
|
||||
float metaDiamond(vec2 p, vec2 pixel, float r){ vec2 d = abs(p-pixel); return r / (d.x + d.y); }
|
||||
|
||||
// Dave Hoskins's hash ! Noone can hash hashes like he hashes !
|
||||
float hash12(vec2 p)
|
||||
{
|
||||
vec3 p3 = fract(vec3(p.xyx) * .1031);
|
||||
p3 += dot(p3, p3.yzx + 33.33);
|
||||
return fract((p3.x + p3.y) * p3.z);
|
||||
}
|
||||
// Smoothed 1D-noise. Just like Zoltraak : stupid simple. Powerful.
|
||||
float fbm(in vec2 v_p)
|
||||
{
|
||||
float pvpx = v_p.x;
|
||||
vec2 V1 = vec2(floor(pvpx ));
|
||||
vec2 V2 = vec2(floor(pvpx + 1.0));
|
||||
return mix(hash12(V1),hash12(V2),smoothstep(0.0,1.0,fract(pvpx)));
|
||||
}
|
||||
|
||||
void mainImage( out vec4 fragColor, in vec2 fragCoord )
|
||||
{
|
||||
// Get Base Coordinates
|
||||
vec2 p = vec2( (1.0/iResolution.y)*(fragCoord.x - iResolution.x/2.0),fragCoord.y / iResolution.y - 0.5);
|
||||
|
||||
// reversed, for accurate Martian perspective... :)
|
||||
p.x=-p.x;
|
||||
|
||||
// Zoom out
|
||||
p*=150.0;
|
||||
|
||||
// Init the Accumulator
|
||||
vec4 col = vec4(0.05,0.05,0.15,1.0);
|
||||
|
||||
// Make up other boxes and save base in them.
|
||||
vec2 save1 = p;
|
||||
vec2 save2 = p;
|
||||
|
||||
// Faint Nebula Background
|
||||
|
||||
// Tilt the camera
|
||||
p*= r2d(-0.05);
|
||||
// Space Background Gradient
|
||||
col = mix(col,vec4(0.2,0.3,0.5,1.0),smoothstep(75.0,0.0,abs(p.y - 5.0*fbm(vec2(0.01*(p.x - 33.333*iTime))) + 3.5)));
|
||||
// Untilt the camera
|
||||
p*= r2d( 0.05);
|
||||
|
||||
// BG Starfield
|
||||
|
||||
// Rotate
|
||||
p*= r2d(-0.05);
|
||||
// Zoom In
|
||||
p*= 0.35;
|
||||
// Scroll Left
|
||||
p+= vec2(-5.0*iTime,0.0);
|
||||
|
||||
// Hack the coords...
|
||||
vec2 b = fract(5.0*p);
|
||||
p = floor(5.0*p);
|
||||
// Draw the stars
|
||||
if( fbm(vec2(p.x*p.y)) > 0.996)col += clamp(1.0-pow(3.0*length(b+vec2(-0.5)),0.5),0.0,1.0);
|
||||
|
||||
// Reload because the coords are all f.. up now !
|
||||
p = save1;
|
||||
// Another Box...
|
||||
vec2 save3;
|
||||
|
||||
// We're going to draw max 4 capsules max.
|
||||
// Yes we could draw more but Earth must survive, man. Have mercy !
|
||||
float Nb_Capsules = clamp(NBCaps,0.0,4.0);
|
||||
for( float i = 0.0;i<Nb_Capsules; i++ )
|
||||
{
|
||||
// Reloooooaaaaad !
|
||||
p = save1;
|
||||
// Tilt as much as we tilted the stars...
|
||||
p*= r2d(-0.05);
|
||||
// Zoom out a bit
|
||||
p*=2.5;
|
||||
// Then zoom in a bit closer every loop.
|
||||
p*=1.0-0.25*i;
|
||||
// Compute Random Coordinates For Each Capsule Position
|
||||
// Move To That Position.
|
||||
p += vec2(150.0*fbm(vec2(0.15*iTime + i*54.321)) - 75.0, // X varies randomly
|
||||
50.0*sin( 0.25*iTime + i*54.321) - 25.0); // Y varies periodically
|
||||
// Save Position
|
||||
save3 = p;
|
||||
|
||||
// Mega Zoom
|
||||
p*=0.04;
|
||||
// (Ox)-axis Symetry for jets
|
||||
p.y = abs(p.y);
|
||||
|
||||
if( p.x > 0.0 )
|
||||
{
|
||||
// Green Jet
|
||||
col += vec4(0.0,1.0,0.5,1.0)*smoothstep(0.2,0.0,abs(p.y - 0.05*fbm(vec2(1.5*p.x - 40.0*iTime)))-0.05)*smoothstep(29.0,0.0,abs(p.x));
|
||||
// White Jet
|
||||
col += vec4(1.0,1.0,1.0,1.0)*smoothstep(0.1,0.0,abs(p.y - 0.05*fbm(vec2(1.5*p.x - 40.0*iTime)))-0.05)*smoothstep(29.0,0.0,abs(p.x));
|
||||
};
|
||||
|
||||
// Reload !
|
||||
p = save3;
|
||||
// (Ox)-axis Symetry for the flames
|
||||
p.y = abs(p.y);
|
||||
// Fine-tuning Flames position
|
||||
p+= vec2(-10.0,0.0);
|
||||
// Fine-tuning Flames Shape
|
||||
p *= vec2(0.75,1.0);
|
||||
|
||||
// Green Flames
|
||||
col += 0.8*vec4(0.0,1.0,0.5,1.0)*s(20.0,0.0,length(p)-25.0+7.0*sin(0.30*length(p)*atan(p.y,p.x) + 55.0*iTime));
|
||||
// White flames
|
||||
col += 0.8*vec4(1.0,1.0,1.0,1.0)*s(20.0,0.0,length(p)-20.0+7.0*sin(0.30*length(p)*atan(p.y,p.x) + 55.0*iTime));
|
||||
|
||||
p = save3;
|
||||
|
||||
// Fat Aura
|
||||
col = mix(col,vec4(1.0),0.5*s(10.0,0.0,length(p + vec2(5.0,0.0))-20.0)*abs(sin(50.0*iTime)));
|
||||
// Less-Fat Aura
|
||||
col = mix(col,vec4(1.0),0.5*s(20.0,0.0,length(p + vec2(5.0,0.0))-20.0));
|
||||
// Frieren : "Aura ? Shader yourself !"
|
||||
|
||||
// The Pod
|
||||
|
||||
// White Disk
|
||||
col = mix(col,vec4(1.0),s(0.01,0.0,length(p)-20.0));
|
||||
|
||||
if( length(p) - 20.0 < 0.0 ) // Basic Masking
|
||||
{
|
||||
// 2D Shading : bluish large shadow
|
||||
col = mix(col,vec4(0.65,0.68,0.68 + 0.1*(3.0-i),1.0),s(0.5,0.0,length(p - vec2(2.0,0.0))-17.0));
|
||||
// 2D Shading : dark small shadow
|
||||
// If Outside Porthole Zone
|
||||
if(s(0.0,1.0,length(vec2(3.0,2.0)*p + vec2(33.5,0.0))-23.0)>0.0)
|
||||
col = mix(col,vec4(0.45,0.55,0.55 + 0.1*(3.0-i),1.0),0.75*s(0.5,0.0,length(p - vec2(2.0,0.0)+ 0.5*fbm(vec2(4.5*atan(p.y,p.x))))-9.0));
|
||||
|
||||
// Small 2D Indentation Details On The Spheres Using A Procedural Texture
|
||||
// NOTE: Original used texture(iChannel0, ...) which is not supported
|
||||
// Texture detail removed - not essential for the effect
|
||||
// vec4 colorCapsule = vec4(hash12(0.0003*p*dot(p,p) + 0.789*i));
|
||||
// if(colorCapsule.x>0.75)if(s(0.0,1.0,length(vec2(3.0,2.0)*p + vec2(33.5,0.0))-23.0)>0.0)col *= vec4(0.25,0.25,0.25,1.0);
|
||||
|
||||
// Bigger Dark Line All Around The Pod
|
||||
col = mix(col,vec4(0.0),s(0.2,0.0,abs(length(p)-19.9)-0.20));
|
||||
// Draw The Porthole :
|
||||
col = mix(col,vec4(0.5,0.2,0.3,1.0) // Base Color
|
||||
-s(5.0,0.0,length(p + vec2(-6.0,15.0))-20.0) // Main Shadow
|
||||
-s(0.25,0.0,abs(length(p + vec2(0.0,3.0))-15.0)-0.4)// Vertical Shadow
|
||||
-s(0.0,1.5,p.y-8.5) // top Shadow
|
||||
+0.25*vec4(1.0,0.5,0.0,1.0)*s(10.0,0.0,abs(p.y)) // Fake Glass Gradient
|
||||
,
|
||||
s(0.5,0.0,length(vec2(3.0,2.0)*p + vec2(35.0,0.0))-19.9));
|
||||
|
||||
// Porthole Black Rings
|
||||
// Internal
|
||||
col = mix(col,vec4(0.0,0.0,0.0,1.0),s(1.0,0.0,abs(length(vec2(3.0,2.0)*p + vec2(35.0,0.0))-19.9)-0.1));
|
||||
// External
|
||||
col = mix(col,vec4(0.0,0.0,0.0,1.0),s(1.0,0.0,abs(length(vec2(3.0,2.0)*p + vec2(33.5,0.0))-23.0)-0.1));
|
||||
|
||||
// Pod Tennis-Ball Door Line...
|
||||
if(p.y>0.0)col = mix(col,vec4(0.0,0.0,0.0,1.0),s(1.0,0.0,abs(length(vec2(3.0,2.0)*p + vec2( 29.0,0.0))-30.0)-0.1));
|
||||
if(p.y<0.0)col = mix(col,vec4(0.0,0.0,0.0,1.0),s(1.0,0.0,abs(length(vec2(3.0,2.0)*p + vec2(-31.0,0.0))-30.0)-0.1));
|
||||
};
|
||||
};
|
||||
// WAKE UP SHEEPLE !
|
||||
fragColor = clamp(col,0.0,1.0);
|
||||
}
|
||||
|
||||
void main() {
|
||||
vec2 fragCoordPixels = vUV * iResolution;
|
||||
vec4 outColor;
|
||||
mainImage(outColor, fragCoordPixels);
|
||||
FragColor = outColor;
|
||||
}
|
||||
@@ -1,3 +1,5 @@
|
||||
// Name: Fractal Pyramid
|
||||
// Author: [TO_BE_COMPLETED]
|
||||
#version 330 core
|
||||
precision highp float;
|
||||
|
||||
|
||||
158
shaders/just_another_cube.frag.glsl
Normal file
158
shaders/just_another_cube.frag.glsl
Normal file
@@ -0,0 +1,158 @@
|
||||
// Name: Just Another Cube
|
||||
// Author: [TO_BE_COMPLETED]
|
||||
#version 330 core
|
||||
precision highp float;
|
||||
|
||||
out vec4 FragColor;
|
||||
in vec2 vUV;
|
||||
uniform vec2 iResolution;
|
||||
uniform float iTime;
|
||||
|
||||
// CC0: Just another cube
|
||||
// Glowtracers are great for compact coding, but I wanted to see how much
|
||||
// I could squeeze a more normal raymarcher in terms of characters used.
|
||||
|
||||
// Twigl: https://twigl.app?ol=true&ss=-OW-y9xgRgWubwKcn0Nd
|
||||
|
||||
// == Globals ==
|
||||
// Single-letter variable names are used to save characters (code golfing).
|
||||
mat2 R; // A 2D rotation matrix, calculated once per frame in mainImage and used by D.
|
||||
float d=1. // Stores the most recent distance to the scene from the ray's position.
|
||||
, z=0. // Stores the total distance traveled along the ray (initialized to avoid undefined behavior)
|
||||
, G=9. // "Glow" variable. Tracks the closest the ray comes to the object (for volumetric glow effect).
|
||||
, M=1e-3
|
||||
;
|
||||
// == Distance Function (SDF - Signed Distance Field) ==
|
||||
// This function calculates the shortest distance from a given point 'p' to the scene geometry.
|
||||
// A positive result means the point is outside an object, negative is inside, and zero is on the surface.
|
||||
// This is the core of "raymarching", as it tells us the largest safe step we can take along a ray.
|
||||
float D(vec3 p) {
|
||||
// Apply two rotations to the point's coordinates. This twists the space the object
|
||||
// exists in, making the simple cube shape appear more complex and animated.
|
||||
p.xy *= R;
|
||||
p.xz *= R;
|
||||
|
||||
// Create a higher-frequency version of the coordinate for detailed surface patterns.
|
||||
vec3 S = sin(123.*p);
|
||||
|
||||
// This creates a volumetric glow effect by tracking the minimum distance
|
||||
// to either the existing glow value or a glowing shell around the object.
|
||||
G = min(
|
||||
G
|
||||
// The glowing shell
|
||||
, max(
|
||||
abs(length(p)-.6)
|
||||
// The main object distance calculation:
|
||||
// 1. A superquadric (rounded cube shape) is created using an L8-norm.
|
||||
// The expression `pow(dot(p=p*p*p*p,p),.125)` is a golfed version of
|
||||
// `pow(pow(p.x,8)+pow(p.y,8)+pow(p.z,8), 1./8.)`.
|
||||
// The `- .5` defines the object's size.
|
||||
, d = pow(dot(p*=p*p*p,p),.125) - .5
|
||||
// 2. Surface detail subtraction. This creates small surface variations
|
||||
// using high-frequency sine waves for more appealing reflections.
|
||||
- pow(1.+S.x*S.y*S.z,8.)/1e5
|
||||
)
|
||||
);
|
||||
|
||||
return d;
|
||||
}
|
||||
|
||||
// == Main Render Function ==
|
||||
// This function is called for every pixel on the screen to determine its color.
|
||||
// 'o' is the final output color (rgba). 'C' is the input pixel coordinate (xy).
|
||||
void mainImage(out vec4 o, vec2 C) {
|
||||
// Single-letter variable names are used to save characters (code golfing).
|
||||
vec3 p // The current point in 3D space along the ray.
|
||||
, O // Multi-purpose vector: color accumulator, then normal vector, then final color.
|
||||
, r=vec3(iResolution.xy, iResolution.y) // 'r' holds screen resolution, later re-used for the epsilon vector and reflection.
|
||||
// 'I' is the Ray Direction vector. It's calculated once per pixel.
|
||||
// This converts the 2D screen coordinate 'C' into a 3D direction, creating the camera perspective.
|
||||
, I=normalize(vec3(C-.5*r.xy, r.y))
|
||||
// Base glow color (dark bluish tint).
|
||||
, B=vec3(1,2,9)*M
|
||||
;
|
||||
|
||||
// == Raymarching Loop ==
|
||||
// This loop "marches" a ray from the camera out into the scene to find what it hits.
|
||||
// It uses a golfed structure where the body of the loop updates the ray position 'p',
|
||||
// and the "advancement" step moves the ray forward.
|
||||
for(
|
||||
// -- Initializer (runs once before the loop) --
|
||||
// Calculate the rotation matrix for this frame based on time.
|
||||
R = mat2(cos(.3*iTime+vec4(0,11,33,0)))
|
||||
// -- Condition --
|
||||
// Loop while total distance 'z' is less than 9 and we are not yet touching a surface (d > 1e-3).
|
||||
; z<9. && d > M
|
||||
// -- Advancement --
|
||||
// The ray advances by the safe distance 'd' returned by D(p).
|
||||
// The result of D(p) is also assigned to the global 'd' inside the function.
|
||||
; z += D(p)
|
||||
)
|
||||
// -- Loop Body --
|
||||
// Calculate the current position 'p' in world space.
|
||||
// The camera starts at (0,0,-2) and points forward.
|
||||
p = z*I
|
||||
, p.z -= 2.
|
||||
;
|
||||
|
||||
// -- Hit Condition --
|
||||
// If the loop finished because z exceeded the max distance, we hit nothing. Otherwise, we hit the surface.
|
||||
if (z < 9.) {
|
||||
// -- Calculate Surface Normal --
|
||||
// Estimate the gradient ∇D at the hit point 'p' via central differences on the SDF D.
|
||||
// We use ε = 1e-3 and loop over each axis (x, y, z):
|
||||
// • Zero r, then set r[i] = ε.
|
||||
// • Compute O[i] = D(p + r) – D(p – r).
|
||||
// After the loop, O holds the unnormalized normal vector.
|
||||
for (
|
||||
int i=0 // axis index: 0→x, 1→y, 2→z (initialized to avoid warnings)
|
||||
; i < 3
|
||||
; O[i++] = D(p+r) - D(p-r)
|
||||
)
|
||||
r -= r // clear r to vec3(0)
|
||||
, r[i] = M // set only the i-th component
|
||||
;
|
||||
|
||||
// -- Lighting and Shading --
|
||||
// 'z' is re-purposed to store a fresnel factor (1 - cos(angle)) for edge brightness.
|
||||
// `dot(O, I)` calculates how much the surface faces away from the camera.
|
||||
// O is also normalized here to become a proper normal vector.
|
||||
z = 1.+dot(O = normalize(O),I);
|
||||
|
||||
// 'r' is re-purposed to store the reflection vector.
|
||||
r = reflect(I,O);
|
||||
|
||||
// Calculate a point 'C' along the reflection vector 'r' to sample a background color.
|
||||
// For upward reflections (r.y > 0), this finds the intersection with the plane y=5.
|
||||
C = (p+r*(5.-p.y)/abs(r.y)).xz;
|
||||
|
||||
// Calculate the final color 'O' of the hit point.
|
||||
O =
|
||||
// Multiply by the fresnel factor squared for stronger edge reflections.
|
||||
z*z *
|
||||
// Use a ternary operator to decide the color based on where the reflection ray goes.
|
||||
(
|
||||
// If the reflection vector points upward...
|
||||
r.y>0.
|
||||
// ...sample a procedural "sky" with a radial gradient and blue tint.
|
||||
? 5e2*smoothstep(5., 4., d = sqrt(length(C*C))+1.)*d*B
|
||||
// ...otherwise, sample a "floor" with a deep blue exponential falloff.
|
||||
: exp(-2.*length(C))*(B/M-1.)
|
||||
)
|
||||
// Add rim lighting (brighter on upward-facing surfaces).
|
||||
+ pow(1.+O.y,5.)*B
|
||||
;
|
||||
}
|
||||
|
||||
// == Tonemapping & Output ==
|
||||
// Apply final effects and map the High Dynamic Range (HDR) color to a displayable range.
|
||||
// Add glow contribution: smaller G values (closer ray passes) create a brighter blue glow.
|
||||
o = sqrt(O+B/G).xyzx;
|
||||
}
|
||||
|
||||
void main() {
|
||||
vec2 fragCoordPixels = vUV * iResolution;
|
||||
vec4 outColor;
|
||||
mainImage(outColor, fragCoordPixels);
|
||||
FragColor = outColor;
|
||||
}
|
||||
@@ -1,3 +1,5 @@
|
||||
// Name: Kishimisu
|
||||
// Author: [TO_BE_COMPLETED]
|
||||
#version 330 core
|
||||
precision highp float;
|
||||
|
||||
|
||||
@@ -1,3 +1,5 @@
|
||||
// Name: Octograms
|
||||
// Author: [TO_BE_COMPLETED]
|
||||
#version 330 core
|
||||
precision highp float;
|
||||
|
||||
|
||||
73
shaders/remember.frag.glsl
Normal file
73
shaders/remember.frag.glsl
Normal file
@@ -0,0 +1,73 @@
|
||||
// Name: Remember
|
||||
// Author: diatribes
|
||||
// URL: https://www.shadertoy.com/view/tXSBDK
|
||||
#version 330 core
|
||||
precision highp float;
|
||||
|
||||
out vec4 FragColor;
|
||||
in vec2 vUV;
|
||||
uniform vec2 iResolution;
|
||||
uniform float iTime;
|
||||
|
||||
// fuzzy brain
|
||||
|
||||
// Hash function to replace iChannel0 texture noise
|
||||
float hash12(vec2 p) {
|
||||
vec3 p3 = fract(vec3(p.xyx) * .1031);
|
||||
p3 += dot(p3, p3.yzx + 33.33);
|
||||
return fract((p3.x + p3.y) * p3.z);
|
||||
}
|
||||
|
||||
void mainImage(out vec4 o, vec2 u) {
|
||||
|
||||
vec3 q,p = vec3(iResolution.xy, iResolution.x / iResolution.y);
|
||||
|
||||
float i = 0.0, s,
|
||||
// start the ray at a small random distance,
|
||||
// this will reduce banding
|
||||
// Replaced texelFetch(iChannel0, ...) with hash function
|
||||
d = .125 * hash12(u),
|
||||
t = iTime * .1;
|
||||
|
||||
// scale coords
|
||||
u = (u+u-p.xy)/p.y;
|
||||
if (abs(u.y) > .8) { o = vec4(0); return; }
|
||||
|
||||
// Initialize output color (out parameter must be initialized before use)
|
||||
o = vec4(0.0);
|
||||
|
||||
for(; i<64.; i++) {
|
||||
|
||||
// shorthand for standard raymarch sample, then move forward:
|
||||
// p = ro + rd * d, p.z + t
|
||||
q = p = vec3(u * d, d + t*5.);
|
||||
p.xy *= mat2(cos(.1*p.z+.1*t+vec4(0,33,11,0)));
|
||||
|
||||
q.xz = cos(q.xz);
|
||||
p.z = cos(p.z) ;
|
||||
// turbulence
|
||||
for (s = 1.; s++ <6.;
|
||||
q += sin(.6*t+p.zxy*.6),
|
||||
p += sin(t+t+p.yzx*s)*.6);
|
||||
|
||||
// distance to spheres
|
||||
d += s = .02 + abs(min(length(p+3.*sin(p.z*.5))-4., length(q-2.*sin(p.z*.4))-6.))*.2;
|
||||
|
||||
// color: 1.+cos so we don't go negative, cos(d+vec4(6,4,2,0)) samples from the palette
|
||||
// divide by s for form and distance
|
||||
// Clamp only the first term to prevent extreme overflow, leave second term free
|
||||
vec4 brightTerm = min(.01*vec4(6,2,1,0)/max(length(u*sin(t+t+t)), 0.001), vec4(50.0));
|
||||
o += brightTerm + 1. / s * length(u);
|
||||
|
||||
}
|
||||
|
||||
// tonemap and divide brightness
|
||||
o = tanh(max(o /6e2 + dot(u,u)*.35, 0.));
|
||||
}
|
||||
|
||||
void main() {
|
||||
vec2 fragCoordPixels = vUV * iResolution;
|
||||
vec4 outColor;
|
||||
mainImage(outColor, fragCoordPixels);
|
||||
FragColor = outColor;
|
||||
}
|
||||
222
shaders/seascape.frag.glsl
Normal file
222
shaders/seascape.frag.glsl
Normal file
@@ -0,0 +1,222 @@
|
||||
// Name: Seascape
|
||||
// Author: Alexander Alekseev (TDM)
|
||||
#version 330 core
|
||||
precision highp float;
|
||||
|
||||
out vec4 FragColor;
|
||||
in vec2 vUV;
|
||||
uniform vec2 iResolution;
|
||||
uniform float iTime;
|
||||
|
||||
/*
|
||||
* "Seascape" by Alexander Alekseev aka TDM - 2014
|
||||
* License Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License.
|
||||
* Contact: tdmaav@gmail.com
|
||||
*/
|
||||
|
||||
const int NUM_STEPS = 32;
|
||||
const float PI = 3.141592;
|
||||
const float EPSILON = 1e-3;
|
||||
#define EPSILON_NRM (0.1 / iResolution.x)
|
||||
//#define AA
|
||||
|
||||
// sea
|
||||
const int ITER_GEOMETRY = 3;
|
||||
const int ITER_FRAGMENT = 5;
|
||||
const float SEA_HEIGHT = 0.6;
|
||||
const float SEA_CHOPPY = 4.0;
|
||||
const float SEA_SPEED = 0.8;
|
||||
const float SEA_FREQ = 0.16;
|
||||
const vec3 SEA_BASE = vec3(0.0,0.09,0.18);
|
||||
const vec3 SEA_WATER_COLOR = vec3(0.8,0.9,0.6)*0.6;
|
||||
#define SEA_TIME (1.0 + iTime * SEA_SPEED)
|
||||
const mat2 octave_m = mat2(1.6,1.2,-1.2,1.6);
|
||||
|
||||
// math
|
||||
mat3 fromEuler(vec3 ang) {
|
||||
vec2 a1 = vec2(sin(ang.x),cos(ang.x));
|
||||
vec2 a2 = vec2(sin(ang.y),cos(ang.y));
|
||||
vec2 a3 = vec2(sin(ang.z),cos(ang.z));
|
||||
mat3 m;
|
||||
m[0] = vec3(a1.y*a3.y+a1.x*a2.x*a3.x,a1.y*a2.x*a3.x+a3.y*a1.x,-a2.y*a3.x);
|
||||
m[1] = vec3(-a2.y*a1.x,a1.y*a2.y,a2.x);
|
||||
m[2] = vec3(a3.y*a1.x*a2.x+a1.y*a3.x,a1.x*a3.x-a1.y*a3.y*a2.x,a2.y*a3.y);
|
||||
return m;
|
||||
}
|
||||
float hash( vec2 p ) {
|
||||
float h = dot(p,vec2(127.1,311.7));
|
||||
return fract(sin(h)*43758.5453123);
|
||||
}
|
||||
float noise( in vec2 p ) {
|
||||
vec2 i = floor( p );
|
||||
vec2 f = fract( p );
|
||||
vec2 u = f*f*(3.0-2.0*f);
|
||||
return -1.0+2.0*mix( mix( hash( i + vec2(0.0,0.0) ),
|
||||
hash( i + vec2(1.0,0.0) ), u.x),
|
||||
mix( hash( i + vec2(0.0,1.0) ),
|
||||
hash( i + vec2(1.0,1.0) ), u.x), u.y);
|
||||
}
|
||||
|
||||
// lighting
|
||||
float diffuse(vec3 n,vec3 l,float p) {
|
||||
return pow(dot(n,l) * 0.4 + 0.6,p);
|
||||
}
|
||||
float specular(vec3 n,vec3 l,vec3 e,float s) {
|
||||
float nrm = (s + 8.0) / (PI * 8.0);
|
||||
return pow(max(dot(reflect(e,n),l),0.0),s) * nrm;
|
||||
}
|
||||
|
||||
// sky
|
||||
vec3 getSkyColor(vec3 e) {
|
||||
e.y = (max(e.y,0.0)*0.8+0.2)*0.8;
|
||||
return vec3(pow(1.0-e.y,2.0), 1.0-e.y, 0.6+(1.0-e.y)*0.4) * 1.1;
|
||||
}
|
||||
|
||||
// sea
|
||||
float sea_octave(vec2 uv, float choppy) {
|
||||
uv += noise(uv);
|
||||
vec2 wv = 1.0-abs(sin(uv));
|
||||
vec2 swv = abs(cos(uv));
|
||||
wv = mix(wv,swv,wv);
|
||||
return pow(1.0-pow(wv.x * wv.y,0.65),choppy);
|
||||
}
|
||||
|
||||
float map(vec3 p) {
|
||||
float freq = SEA_FREQ;
|
||||
float amp = SEA_HEIGHT;
|
||||
float choppy = SEA_CHOPPY;
|
||||
vec2 uv = p.xz; uv.x *= 0.75;
|
||||
|
||||
float d, h = 0.0;
|
||||
for(int i = 0; i < ITER_GEOMETRY; i++) {
|
||||
d = sea_octave((uv+SEA_TIME)*freq,choppy);
|
||||
d += sea_octave((uv-SEA_TIME)*freq,choppy);
|
||||
h += d * amp;
|
||||
uv *= octave_m; freq *= 1.9; amp *= 0.22;
|
||||
choppy = mix(choppy,1.0,0.2);
|
||||
}
|
||||
return p.y - h;
|
||||
}
|
||||
|
||||
float map_detailed(vec3 p) {
|
||||
float freq = SEA_FREQ;
|
||||
float amp = SEA_HEIGHT;
|
||||
float choppy = SEA_CHOPPY;
|
||||
vec2 uv = p.xz; uv.x *= 0.75;
|
||||
|
||||
float d, h = 0.0;
|
||||
for(int i = 0; i < ITER_FRAGMENT; i++) {
|
||||
d = sea_octave((uv+SEA_TIME)*freq,choppy);
|
||||
d += sea_octave((uv-SEA_TIME)*freq,choppy);
|
||||
h += d * amp;
|
||||
uv *= octave_m; freq *= 1.9; amp *= 0.22;
|
||||
choppy = mix(choppy,1.0,0.2);
|
||||
}
|
||||
return p.y - h;
|
||||
}
|
||||
|
||||
vec3 getSeaColor(vec3 p, vec3 n, vec3 l, vec3 eye, vec3 dist) {
|
||||
float fresnel = clamp(1.0 - dot(n, -eye), 0.0, 1.0);
|
||||
fresnel = min(fresnel * fresnel * fresnel, 0.5);
|
||||
|
||||
vec3 reflected = getSkyColor(reflect(eye, n));
|
||||
vec3 refracted = SEA_BASE + diffuse(n, l, 80.0) * SEA_WATER_COLOR * 0.12;
|
||||
|
||||
vec3 color = mix(refracted, reflected, fresnel);
|
||||
|
||||
float atten = max(1.0 - dot(dist, dist) * 0.001, 0.0);
|
||||
color += SEA_WATER_COLOR * (p.y - SEA_HEIGHT) * 0.18 * atten;
|
||||
|
||||
color += specular(n, l, eye, 600.0 * inversesqrt(dot(dist,dist)));
|
||||
|
||||
return color;
|
||||
}
|
||||
|
||||
// tracing
|
||||
vec3 getNormal(vec3 p, float eps) {
|
||||
vec3 n;
|
||||
n.y = map_detailed(p);
|
||||
n.x = map_detailed(vec3(p.x+eps,p.y,p.z)) - n.y;
|
||||
n.z = map_detailed(vec3(p.x,p.y,p.z+eps)) - n.y;
|
||||
n.y = eps;
|
||||
return normalize(n);
|
||||
}
|
||||
|
||||
float heightMapTracing(vec3 ori, vec3 dir, out vec3 p) {
|
||||
float tm = 0.0;
|
||||
float tx = 1000.0;
|
||||
float hx = map(ori + dir * tx);
|
||||
if(hx > 0.0) {
|
||||
p = ori + dir * tx;
|
||||
return tx;
|
||||
}
|
||||
float hm = map(ori);
|
||||
for(int i = 0; i < NUM_STEPS; i++) {
|
||||
float tmid = mix(tm, tx, hm / (hm - hx));
|
||||
p = ori + dir * tmid;
|
||||
float hmid = map(p);
|
||||
if(hmid < 0.0) {
|
||||
tx = tmid;
|
||||
hx = hmid;
|
||||
} else {
|
||||
tm = tmid;
|
||||
hm = hmid;
|
||||
}
|
||||
if(abs(hmid) < EPSILON) break;
|
||||
}
|
||||
return mix(tm, tx, hm / (hm - hx));
|
||||
}
|
||||
|
||||
vec3 getPixel(in vec2 coord, float time) {
|
||||
vec2 uv = coord / iResolution.xy;
|
||||
uv = uv * 2.0 - 1.0;
|
||||
uv.x *= iResolution.x / iResolution.y;
|
||||
|
||||
// ray
|
||||
vec3 ang = vec3(sin(time*3.0)*0.1,sin(time)*0.2+0.3,time);
|
||||
vec3 ori = vec3(0.0,3.5,time*5.0);
|
||||
vec3 dir = normalize(vec3(uv.xy,-2.0)); dir.z += length(uv) * 0.14;
|
||||
dir = normalize(dir) * fromEuler(ang);
|
||||
|
||||
// tracing
|
||||
vec3 p;
|
||||
heightMapTracing(ori,dir,p);
|
||||
vec3 dist = p - ori;
|
||||
vec3 n = getNormal(p, dot(dist,dist) * EPSILON_NRM);
|
||||
vec3 light = normalize(vec3(0.0,1.0,0.8));
|
||||
|
||||
// color
|
||||
return mix(
|
||||
getSkyColor(dir),
|
||||
getSeaColor(p,n,light,dir,dist),
|
||||
pow(smoothstep(0.0,-0.02,dir.y),0.2));
|
||||
}
|
||||
|
||||
// main
|
||||
void mainImage( out vec4 fragColor, in vec2 fragCoord ) {
|
||||
// Removed mouse interaction (iMouse not available)
|
||||
float time = iTime * 0.3;
|
||||
|
||||
#ifdef AA
|
||||
vec3 color = vec3(0.0);
|
||||
for(int i = -1; i <= 1; i++) {
|
||||
for(int j = -1; j <= 1; j++) {
|
||||
vec2 uv = fragCoord+vec2(i,j)/3.0;
|
||||
color += getPixel(uv, time);
|
||||
}
|
||||
}
|
||||
color /= 9.0;
|
||||
#else
|
||||
vec3 color = getPixel(fragCoord, time);
|
||||
#endif
|
||||
|
||||
// post
|
||||
fragColor = vec4(pow(color,vec3(0.65)), 1.0);
|
||||
}
|
||||
|
||||
void main() {
|
||||
vec2 fragCoordPixels = vUV * iResolution;
|
||||
vec4 outColor;
|
||||
mainImage(outColor, fragCoordPixels);
|
||||
FragColor = outColor;
|
||||
}
|
||||
@@ -1,3 +1,5 @@
|
||||
// Name: Test
|
||||
// Author: [TO_BE_COMPLETED]
|
||||
#version 330 core
|
||||
out vec4 FragColor;
|
||||
in vec2 vUV;
|
||||
|
||||
52
shaders/voxel_descent.frag.glsl
Normal file
52
shaders/voxel_descent.frag.glsl
Normal file
@@ -0,0 +1,52 @@
|
||||
// Name: Voxel Descent
|
||||
// Author: Jaenman
|
||||
// URL: https://www.shadertoy.com/view/Wc3cRr
|
||||
#version 330 core
|
||||
precision highp float;
|
||||
|
||||
out vec4 FragColor;
|
||||
in vec2 vUV;
|
||||
uniform vec2 iResolution;
|
||||
uniform float iTime;
|
||||
|
||||
/*================================
|
||||
= Voxel Descent =
|
||||
= Author: Jaenam =
|
||||
================================*/
|
||||
// Date: 2025-11-14
|
||||
// License: Creative Commons (CC BY-NC-SA 4.0)
|
||||
|
||||
// Thanks to @diatribes for the plasma :D
|
||||
|
||||
void mainImage( out vec4 O, vec2 I )
|
||||
{
|
||||
float i=0.,d=0.,s=0.,t = iTime*.8;
|
||||
vec3 p,q,z,k;
|
||||
vec4 c = vec4(1,2,3,1);
|
||||
mat2 R = mat2(cos(t/3.+vec4(0,33,11,0)));
|
||||
|
||||
// Initialize O before loop (was O*=i where i=0, reading uninitialized out parameter)
|
||||
O = vec4(0.0);
|
||||
|
||||
for(; i++<1e2;O+=sin(.5*c+i*.2)/s)
|
||||
|
||||
z = normalize(vec3(I+I, 0) - vec3(iResolution.xy, iResolution.y)),
|
||||
z.xy*=R,
|
||||
p = d*z+sqrt(i)*i,
|
||||
k=z/=length(z.xy),
|
||||
z.z-=t, p.z+=t,
|
||||
|
||||
d+=s=.012+.07*abs(mix(cos(dot(sin(floor(p/8.)).yzx,cos(ceil(z/.1)))),length(k),.2)-i/1e2);
|
||||
|
||||
O*= exp(-.02*d*d);
|
||||
// Add epsilon protection to prevent division overflow
|
||||
O=tanh(O*O*mix(length(abs(c/max(dot(cos(t+p),vec3(6)), 0.001))),length(k),.5)/6e4);
|
||||
|
||||
}
|
||||
|
||||
void main() {
|
||||
vec2 fragCoordPixels = vUV * iResolution;
|
||||
vec4 outColor;
|
||||
mainImage(outColor, fragCoordPixels);
|
||||
FragColor = outColor;
|
||||
}
|
||||
37
shaders/water.frag.glsl
Normal file
37
shaders/water.frag.glsl
Normal file
@@ -0,0 +1,37 @@
|
||||
// Name: Water
|
||||
// Author: diatribes
|
||||
#version 330 core
|
||||
precision highp float;
|
||||
|
||||
out vec4 FragColor;
|
||||
in vec2 vUV;
|
||||
uniform vec2 iResolution;
|
||||
uniform float iTime;
|
||||
|
||||
/*
|
||||
-2 by @FabriceNeyret2
|
||||
|
||||
thanks!! :D
|
||||
|
||||
If it doesn't display correctly, change line 17 "r/r" to "vec3(1)"
|
||||
|
||||
*/
|
||||
|
||||
void mainImage( out vec4 o, vec2 u ) {
|
||||
float s=.002,i,n;
|
||||
vec3 r = vec3(iResolution.xy, iResolution.x/iResolution.y);
|
||||
vec3 p = vec3(0);
|
||||
u = (u-r.xy/2.)/r.y-.3;
|
||||
for(o *= i; i++ < 32. && s > .001;o += vec4(5,2,1,0)/max(length(u-.1), 0.001))
|
||||
for (p += vec3(u*s,s),s = 1. + p.y,
|
||||
n =.01; n < 1.;n+=n)
|
||||
s += abs(dot(sin(p.z+iTime+p / n), vec3(1))) * n*.1;
|
||||
o = tanh(o/5e2);
|
||||
}
|
||||
|
||||
void main() {
|
||||
vec2 fragCoordPixels = vUV * iResolution;
|
||||
vec4 outColor;
|
||||
mainImage(outColor, fragCoordPixels);
|
||||
FragColor = outColor;
|
||||
}
|
||||
Reference in New Issue
Block a user