fragments of fragment shaders
HSV
code:hsv.glsl
vec3 hsv(float h,float s,float v){return ((clamp(abs(fract(h+vec3(0.,.666,.333))*6.-3.)-1.,0.,1.)-1.)*s+1.)*v;}
code:hsv2rgb.glsl
vec3 hsv(float h, float s, float v){
return ((clamp(abs(fract(h+vec3(0,2,1)/3.)*6.-3.)-1.,0.,1.)-1.)*s+1.)*v;
}
code:hsv2rgb.glsl
vec3 hsv2rgb(vec3 c)
{
vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);
return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);
}
code:hsv.GLSL
vec3 hsv(float h,float s,float v){return ((clamp(abs(fract(h+vec3(0.,.666,.333))*6.-3.)-1.,0.,1.)-1.)*s+1.)*v;}
code:rgbtohsv.glsl
vec3 rgb2hsv(vec3 c)
{
vec4 K = vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
vec4 p = mix(vec4(c.bg, K.wz), vec4(c.gb, K.xy), step(c.b, c.g));
vec4 q = mix(vec4(p.xyw, c.r), vec4(c.r, p.yzx), step(p.x, c.r));
float d = q.x - min(q.w, q.y);
float e = 1.0e-10;
return vec3(abs(q.z + (q.w - q.y) / (6.0 * d + e)), d / (q.x + e), q.x);
}
vec3 hsv2rgb(vec3 c)
{
vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);
return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);
}
pmod / fold rotate
code:pmodrotate.GLSL
float map(vec3 p)
{
p.xy *= rotate(time*0.5);
p.yz *= rotate(time*0.3);
p.xy = pmod(p.xy, 16.0);
p.yz = pmod(p.yz, 20.0);
return dot(abs(p),vec3(0.5))-2.0;
return p.z - 2.0;
p.z = mod(p.z,2.0)-1.0;
return length(p)-0.2;
}
code:pmod.GLSL
mat2 rot(float a){
float c=cos(a),s=sin(a);
return mat2(c,s,-s,c);
}
vec2 pmod(vec2 p, float r){
float a=PI/r-atan(p.x,p.y);
float n=2.*PI/r;
a=floor(a/n)*n;
return p*rot(a);
}
code:moda.GLSL
vec2 moda(vec2 p,float per){
float a=atan(p.y,p.x);
float l=length(p);
a=mod(a-per/2.,per)-per/2.;
return vec2(cos(a),sin(a))*l;
}
code:moda3D.GLSL
vec3 moda(vec3 p, float rep, float off) {
vec2 rp = vec2(atan(p.z,p.x)/(2.0*PI), length(p.xz));
rp.x=(fract(rp.x*rep-0.5+off)-0.5)/rep;
rp.x *= 2.0*PI;
return vec3(cos(rp.x)*rp.y,p.y,sin(rp.x)*rp.y);
}
// to call
p=moda(p.xzy, 9., sin(p.z)*.9);
float d2 = cyl(p.xz-vec2(1.3, .0), .05);
code:signRot.GLSL
vec2 amod(vec2 p,float a){a=mod(atan(p.x,p.y),a)-a*.5;return vec2(cos(a),sin(a))*length(p);}
p.xy=amod(p.xy*r2d(time*sign(mod(p.z,4.)-2.)),3.+sin(time));
Rotate
code:rot3D.GLSL
vec3 rotX(vec3 p,float a){return vec3(p.x,p.y*cos(a)-p.z*sin(a),p.y*sin(a)+p.z*cos(a));}
vec3 rotY(vec3 p,float a){return vec3(p.x*cos(a)-p.z*sin(a),p.y,p.x*sin(a)+p.z*cos(a));}
vec3 rotZ(vec3 p,float a){return vec3(p.x*cos(a)-p.y*sin(a),p.x*sin(a)+p.y*cos(a),p.z);}
Remap
code:remap.GLSL
#define saturate(x) clamp(x, 0.0, 1.0) float remap(float val, float inMin, float inMax, float outMin, float outMax)
{
return saturate(outMin + (val - inMin) * (outMax - outMin) / (inMax - inMin));
}
vec2 remap(vec2 val, float inMin, float inMax, float outMin, float outMax)
{
return vec2(remap(val.x, inMin, inMax, outMin, outMax), remap(val.y, inMin, inMax, outMin, outMax));
}
vec3 remap(vec3 val, float inMin, float inMax, float outMin, float outMax)
{
return vec3(remap(val.x, inMin, inMax, outMin, outMax), remap(val.y, inMin, inMax, outMin, outMax), remap(val.z, inMin, inMax, outMin, outMax));
}
2D dot product / cross product
code:dotAndCross.GLSL
float dot(vec2 a, vec2 b)
{
return a.x * b.x + a.y * b.y;
}
float cross(vec2 a, vec2 b)
{
b = vec2(-b.y, b.x);
return dot(a,b);
}
Hash / Random
code:rnd.GLSL
float rnd(float t) {
return fract(sin(t*789.451)*7541.223);
}
float rnd(vec2 t) {
return fract(dot(sin(t*vec2(789.451)+t.yx*vec2(842.544)),vec2(7541.223)));
}
code:HashWithoutSine.GLSL
// Hash without Sine
// Creative Commons Attribution-ShareAlike 4.0 International Public License
// Created by David Hoskins.
/// 3 out, 2 in...
vec3 hash32(vec2 p)
{
vec3 p3 = fract(vec3(p.xyx) * vec3(.1031, .1030, .0973));
p3 += dot(p3, p3.yxz+33.33);
return fract((p3.xxy+p3.yzz)*p3.zyx);
}
Fractal
code:Sierpinski.GLSL
vec2 sierpinski(vec3 pos)
{
const int Iterations = 14;
const float Scale = 1.85;
const float Offset = 2.0;
vec3 a1 = vec3(1,1,1);
vec3 a2 = vec3(-1,-1,1);
vec3 a3 = vec3(1,-1,-1);
vec3 a4 = vec3(-1,1,-1);
vec3 c;
float dist, d;
for (int n = 0; n < Iterations; n++)
{
if(pos.x+pos.y<0.) pos.xy = -pos.yx; // fold 1
if(pos.x+pos.z<0.) pos.xz = -pos.zx; // fold 2
if(pos.y+pos.z<0.) pos.zy = -pos.yz; // fold 3
pos = pos*Scale - Offset*(Scale-1.0);
}
return vec2( length(pos) * pow(Scale, -float(Iterations)), 1. );
}
and / or
code:andOrWithStep.GLSL
// and
step(a, x) * step(x, b) // a <= x AND x <= b
// or
step(1., step(a, x) + step(b, x)) // a <= x OR b <= x
Normal
code:norm.GLSL
vec3 norm(vec3 p) {
vec2 off=vec2(0.01,0.0);
return normalize(map(p)-vec3(map(p-off.xyy), map(p-off.yxy), map(p-off.yyx))+0.000001);
}
// to use
float f = pow(1.-abs(dot(N,rd)), 3.);
code:normalInlining.GLSL
// inspired by klems - a way to prevent the compiler from inlining map() 4 times
vec3 n = vec3(0.0);
for( int i=ZERO; i<4; i++ )
{
vec3 e = 0.5773*(2.0*vec3((((i+3)>>1)&1),((i>>1)&1),(i&1))-1.0);
n += e*map(pos+0.0005*e,time).x;
}
return normalize(n);
Repeat
code:repeatingTime.GLSL
float t1 = fract(time);
float t4 = abs(fract(time*0.5)-0.5)/0.5;
Postprocess
code:ExpFog.HLSL
float4 res = castRay(ro, rd, time);
float t = res.x;
col = lerp(col, float3(0.5, 0.7, 0.9), 1.0 - exp(-0.0001*t*t*t));
code:fog.GLSL
float fog = pow(1.0-float(i)/float(MARCH_COUNT),2.0);
code:Fog.GLSL
vec3 ro = vec3(0.0, rot * 5.0);
for().. // marching loop
vec3 hit = ro + dir * t;
// fog
float fogFact = clamp(exp(-distance(ro, hit) * 0.3), 0.0, 1.0);
if (fogFact < 0.05)
{
color = vec4(0.0, 0.0, 0.0, 1.0);
return;
}
code:ao.GLSL
float getao(vec3 p, vec3 n, float dist) {
return clamp(map(p+n*dist)/dist,0.0,1.0);
}
// to call
float aodist = .7;
float ao = getao(p,n,aodist*0.2) * (getao(p,n,aodist*0.35)*0.5+0.5) * (getao(p,n,aodist*0.6)*0.25+0.75);
code:sss.GLSL
float getsss(vec3 p, vec3 r, float dist) {
return clamp(map(p+r*dist)*3.0,0.0,1.0);
}
// to call
float sss = (getsss(p,rd,0.2)+getsss(p,rd,0.5)*0.5)*0.9;
code:ChromaticAberrationOrPrismRefraction.GLSL
h.refrIndex = 1.;//r
h.refrIndex = .95;//g
h.refrIndex = .9;//b
misc(raymarching and so on)
code:dividedSphere.GLSL
vec3 d=abs(p)-s;
return length(d)-r;
code:GazFbm.GLSL
// - glslfan.com --------------------------------------------------------------
// Ctrl + s or Command + s: compile shader
// Ctrl + m or Command + m: toggle visibility for codepane
// ----------------------------------------------------------------------------
precision mediump float;
uniform vec2 resolution; // resolution (width, height)
uniform vec2 mouse; // mouse (0.0 ~ 1.0)
uniform float time; // time (1second == 1.0)
uniform sampler2D backbuffer; // previous scene
out vec4 fragColor;
#define hue(t) (cos((vec3(0,2,-2)/3.0+t)*TAU)*0.5+0.5) float noise(vec3 p)
{
vec3 r=vec3(1,99,999);
vec4 s=dot(floor(p),r)+vec4(0,r.y,r.z,r.y+r.z);
p=pow(abs(sin(fract(p)*5.0)),vec3(50));
s=mix(fract(sin(s)*7777.0),fract(sin(s+1.0)*7777.0),p.x);
s.xy=mix(s.xz,s.yw,p.y);
return mix(s.x,s.y,p.z);
}
float fbm(vec3 p, float scale)
{
float n=0.0;
p=mod(p,scale);
float amp=0.6;
for (int i=0; i<5; i++)
{
n+=noise(p*scale)*amp;
amp*=0.5;
scale*=2.0;
}
return min(n,1.0);
}
void main(){
vec2 p=(gl_FragCoord.xy*2.0-resolution)/resolution.y;
p*=20.0;
p = vec2(atan(p.x, p.y)/PI*0.05 ,inversesqrt(length(p))*0.5);
float n= fbm(vec3(p,time*0.05), 30.0);
vec3 col = vec3(0);
col+=hue(n*3.0+time*0.5)*step(0.75,n);
col*=exp(-p.y*p.y*10.0);
fragColor=vec4(col,1.0);
}
https://gyazo.com/2ebcb81d176e6380facc29aafa215b33
0.5773 == normalize(vec3(1.)).x;
code:rout3.GLSL
normalize(vec3(1.))
1.=sqrt(3.*a*a)
1./3.=a^2.
sqrt(1./3.)
tunnel
dot(tex, vec3(0.2126, 0.7152, 0.0722))
wax
https://gyazo.com/2528830b7707a62d85c90123a260aa27
code:y2xz.GLSL
p.xz *= rot(sin(p.y * .4));
code:dots.GLSL
float dots(vec3 p, float j) {
p*=4.+sin(j);
p.x += rnd(floor(p.y));
p*=PI;
return clamp(0.1-length(vec2(sin(p.x),cos(p.y))),0.0,1.0)*10.3;
}
// to call
vec3 col2 = vec3(0);
for(int j=1; j<PART_COUNT; ++j) {
float dist = float(j) * 0.2/r.z;
if(dist>len) break;
vec3 vp = vec3(ro.x,ro.y,0) + rd*dist;
vp.xy *=rot(sin(vp.z*10.0+time*0.2));
col2 += dots(vp, float(j)) * clamp(1.0-dist/float(PART_COUNT), 0.0,1.0);
}
col += col2 * back;
col *= pow(clamp(1.2-length(uv),0.0,1.0)*1.3,1.7);
code:tglad_formula.GLSL
float tglad(vec3 p)
{
vec3 z=vec3(mod(p,2.));
vec3 q=vec3(.0,1.59,-1.);
vec3 scale=vec3(-acos(-1.));
for(int i=0;i<3;++i){
z=clamp(z, -.94, .94)*2.-z;
z*=scale/clamp(dot(z,z),.25,1.);
z+=q;
}
return (length(max(abs(z)-vec3(1.2,49.,1.4),.0))-.06)/pow(PI,3.+EPS);
}
code:SSSLook.GLSL
// by yunta-robo
// - glslfan.com --------------------------------------------------------------
// Ctrl + s or Command + s: compile shader
// Ctrl + m or Command + m: toggle visibility for codepane
// ----------------------------------------------------------------------------
precision mediump float;
uniform vec2 resolution; // resolution (width, height)
uniform vec2 mouse; // mouse (0.0 ~ 1.0)
uniform float time; // time (1second == 1.0)
uniform sampler2D backbuffer; // previous scene
const float PI = 3.1415926;
const float E = 0.01;
vec3 hsv(float h, float s, float v)
{
vec4 t = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
vec3 p = abs(fract(vec3(h) + t.xyz) * 6.0 - vec3(t.w));
return v * mix(vec3(t.x), clamp(p - vec3(t.x), 0.0, 1.0), s);
}
float smin(float a, float b, float k)
{
float h = clamp(0.5 + 0.5 * (b - a) / k, 0.0, 1.0);
return mix(b, a, h) - k * h * (1.0 - h);
}
vec2 smin(vec2 a, vec2 b, float k)
{
vec2 h = clamp(0.5 + 0.5 * (b - a) / k, 0.0, 1.0);
return mix(b, a, h) - k * h * (1.0 - h);
}
vec3 smin(vec3 a, vec3 b, float k)
{
vec3 h = clamp(0.5 + 0.5 * (b - a) / k, 0.0, 1.0);
return mix(b, a, h) - k * h * (1.0 - h);
}
float sdVerticalCapsule(vec3 p, float h, float r)
{
p.y -= clamp(p.y, 0.0, h);
return length(p) - r;
}
float de(vec3 p)
{
vec3 p_ = p;
float r = time + p.y * 1.5;
p *= 1.0;
p.xz *= mat2(cos(r), -sin(r), sin(r), cos(r));
p.y += 5.0;
p.xz = p.xz - 2.0 * smin(vec2(0.0), p.xz, 0.225) - 0.5;
p.xz = p.xz - 2.0 * smin(vec2(0.0), p.xz, 0.225) - 0.25;
float d = sdVerticalCapsule(p, 10.0, (0.05 + 0.125 * (sin(p.y * 7.5) * 0.5 + 0.5)));
p = p_;
p.y += 5.0;
for (int i = -1; i < 2; i++)
{
float r_ = float(i) * 0.6 - 2.3;
float x_ = cos(r_) * 8.0;
float y_ = sin(r_) * 8.0;
float d_ = abs(sdVerticalCapsule(p - vec3(x_, 0.0, y_), 10.0, 0.75)) - 0.075;
d_ = max(d_, length(p - vec3(x_, 0.0, y_)) - 6.0);
d = min(d, d_);
}
p = p_;
d = smin(d, dot(p, vec3(0.0, 1.0, 0.0)) + 1.0, 0.75);
return d;
}
// iquilezles.org/www/articles/normalsSDF/normalsSDF.htm
vec3 normal(vec3 p)
{
float h = E;
vec2 k = vec2(1.0, -1.0);
return normalize(
k.xyy * de(p + k.xyy * h) +
k.yyx * de(p + k.yyx * h) +
k.yxy * de(p + k.yxy * h) +
k.xxx * de(p + k.xxx * h)
);
}
// 雰囲気SSS(subsurface scattering)
// 衝突点から任意の方向に固定長で複数回サンプリングして、厚みと通過後の遮蔽具合を同時に推定するイメージです
// o .. レイの開始位置
// dir .. レイの方向
// ed .. 推定する距離
// la .. 光の減衰率
// li .. 光の強さ
float sss(vec3 o, vec3 dir, float ed, float la, float li)
{
// サンプリング回数
// 回数を増やすことで推定精度が上がります
// AOのアプローチに近いかも
const int ei = 5;
float accum = 0.0;
float st = ed / float(ei);
float d = st;
for (int i = 0; i < ei; i++)
{
accum += max(de(o + dir * d) / d, 0.0);
d += st;
}
accum = clamp(accum / float(ei), 0.0, 1.0);
return exp(-(1.0 - accum) * la) * li;
}
void trace(vec3 ro, vec3 rd, inout vec3 color)
{
float ad = 0.0;
for (int i = 0; i < 128; i++)
{
float d = de(ro) * 0.75;
ro += rd * d;
ad += d;
if (d < E)
{
// normal
vec3 n = normal(ro);
for (int j = 0; j < 5; j++)
{
float st = step(0.0, float(j) - 1.9);
// point lights
float r = float(j) * PI * 2.0 / 2.0 + time * 0.5;
vec3 lp = vec3(0.0, cos(r), 0.0) * 1.5;
{
float r_ = float(j - 3) * 0.6 + -2.3;
float x_ = cos(r_) * 8.0;
float y_ = sin(r_) * 8.0;
vec3 lp2 = vec3(x_, 0.0, y_);
lp = mix(lp, lp2, st);
}
vec3 li = hsv(float(j) * 1.618, 0.9, 1.0) * 40.0;
{
vec3 li2 = vec3(1.0, 0.6, 0.25) * (30.0 + sin(sin((time + float(j)) * 5.0) * 6.0) * 2.0);
li = mix(li, li2, st);
}
float ll = length(lp - ro);
float atte = exp(-ll * 2.5);
// diffuse
color += pow(dot(normalize(lp - ro), n) * 0.5 + 0.5, 2.0) * li * atte * 0.2;
// sss
color += sss(ro, normalize(lp - ro), 1.0, 3.0, 1.0) * li * atte;
// color = n * 0.5 + 0.5;
}
return;
}
else if(ad > 20.0)
{
// background
color += vec3(max(rd.y + 0.2, 0.0) * 0.1);
break;
}
}
}
void main()
{
vec2 p = (gl_FragCoord.xy * 2.0 - resolution) / resolution.y;
vec3 color = vec3(0.0);
{
// ray
vec3 ro = vec3(-1.8, 3.0, 5.0);
vec3 rd = normalize(vec3(p, -2.0));
float r = -0.5;
rd.yz *= mat2(cos(r), -sin(r), sin(r), cos(r));
// ray marching
trace(ro, rd, color);
// composition
/*
p.x *= resolution.y / resolution.x;
p.xy = abs(p.xy) - 0.33333;
color.x += smoothstep(0.005, 0.0025, abs(dot(p, vec2(1.0, 0.0))));
color.x += smoothstep(0.005, 0.0025, abs(dot(p, vec2(0.0, 1.0))));
*/
}
color = pow(color, vec3(0.454545));
gl_FragColor = vec4(color, 1.0);
}
determine camera z, parse or ortho
code:CameraZ.GLSL
// parse
vec3 rd = normalize(vec3(p, 1.));
// Ortho
vec3 rd = vec3(0., .0, 1.);
code:fragment.GLSL
precision mediump float;
uniform vec2 resolution;
uniform float time;
const float EPS = .001;
const float FAR = 128.;
const float PI = 3.1415926;
const float FOV = 1.;
const int IT = 12;
vec3 hsv(float h,float s,float v){return ((clamp(abs(fract(h+vec3(0.,.666,.333))*6.-3.)-1.,0.,1.)-1.)*s+1.)*v;}
vec2 rot(vec2 p, float a){
return vec2(p.x*cos(a)-p.y*sin(a), p.x*sin(a)+p.y*cos(a));
}
vec4 mod289(vec4 x) { return x - floor(x * (1.0 / 289.0)) * 289.0; }
vec3 mod289(vec3 x) { return x - floor(x * (1.0 / 289.0)) * 289.0; }
vec2 mod289(vec2 x) { return x - floor(x * (1.0 / 289.0)) * 289.0; }
vec3 permute(vec3 x) { return mod289(((x*34.0) + 1.0)*x); }
float snoise(vec2 v) {
const vec4 C = vec4(0.211324865405187,
0.366025403784439,
-0.577350269189626,
0.024390243902439);
vec2 i = floor(v + dot(v, C.yy));
vec2 x0 = v - i + dot(i, C.xx);
// Other two corners (x1, x2)
vec2 i1 = vec2(0.0,0.0);
i1 = (x0.x > x0.y) ? vec2(1.0, 0.0) : vec2(0.0, 1.0);
vec2 x1 = x0.xy + C.xx - i1;
vec2 x2 = x0.xy + C.zz;
i = mod289(i);
vec3 p = permute(
permute(i.y + vec3(0.0, i1.y, 1.0))
+ i.x + vec3(0.0, i1.x, 1.0));
vec3 m = max(0.5 - vec3(
dot(x0, x0),
dot(x1, x1),
dot(x2, x2)
), 0.0);
m = m * m;
m = m * m;
vec3 x = 2.0 * fract(p * C.www) - 1.0;
vec3 h = abs(x) - 0.5;
vec3 ox = floor(x + 0.5);
vec3 a0 = x - ox;
m *= 1.79284291400159 - 0.85373472095314 * (a0*a0 + h * h);
vec3 g = vec3(.0);
g.x = a0.x * x0.x + h.x * x0.y;
g.yz = a0.yz * vec2(x1.x, x2.x) + h.yz * vec2(x1.y, x2.y);
return 130.0 * dot(m, g);
}
vec4 permute(vec4 x)
{
return mod289(((x*34.0)+1.0)*x);
}
vec4 taylorInvSqrt(vec4 r)
{
return vec4(1.79284291400159 - r * 0.85373472095314);
}
float snoise(vec3 v){
const vec2 C = vec2(1.0/6.0, 1.0/3.0) ;
const vec4 D = vec4(0.0, 0.5, 1.0, 2.0);
// First corner
vec3 i = floor(v + dot(v, C.yyy) );
vec3 x0 = v - i + dot(i, C.xxx) ;
// Other corners
vec3 g = step(x0.yzx, x0.xyz);
vec3 l = 1.0 - g;
vec3 i1 = min( g.xyz, l.zxy );
vec3 i2 = max( g.xyz, l.zxy );
// x0 = x0 - 0. + 0.0 * C
vec3 x1 = x0 - i1 + 1.0 * C.xxx;
vec3 x2 = x0 - i2 + 2.0 * C.xxx;
vec3 x3 = x0 - 1. + 3.0 * C.xxx;
// Permutations
// i = mod(i, 289.0 );
i = mod289(i);
vec4 p = permute( permute( permute(
i.z + vec4(0.0, i1.z, i2.z, 1.0 ))
+ i.y + vec4(0.0, i1.y, i2.y, 1.0 ))
+ i.x + vec4(0.0, i1.x, i2.x, 1.0 ));
// Gradients
// ( N*N points uniformly over a square, mapped onto an octahedron.)
float n_ = 1.0/7.0; // N=7
vec3 ns = n_ * D.wyz - D.xzx;
vec4 j = p - 49.0 * floor(p * ns.z *ns.z); // mod(p,N*N)
vec4 x_ = floor(j * ns.z);
vec4 y_ = floor(j - 7.0 * x_ ); // mod(j,N)
vec4 x = x_ *ns.x + ns.yyyy;
vec4 y = y_ *ns.x + ns.yyyy;
vec4 h = 1.0 - abs(x) - abs(y);
vec4 b0 = vec4( x.xy, y.xy );
vec4 b1 = vec4( x.zw, y.zw );
vec4 s0 = floor(b0)*2.0 + 1.0;
vec4 s1 = floor(b1)*2.0 + 1.0;
vec4 sh = -step(h, vec4(0.0));
vec4 a0 = b0.xzyw + s0.xzyw*sh.xxyy ;
vec4 a1 = b1.xzyw + s1.xzyw*sh.zzww ;
vec3 p0 = vec3(a0.xy,h.x);
vec3 p1 = vec3(a0.zw,h.y);
vec3 p2 = vec3(a1.xy,h.z);
vec3 p3 = vec3(a1.zw,h.w);
//Normalise gradients
vec4 norm = taylorInvSqrt(vec4(dot(p0,p0), dot(p1,p1), dot(p2, p2), dot(p3,p3)));
p0 *= norm.x;
p1 *= norm.y;
p2 *= norm.z;
p3 *= norm.w;
// Mix final noise value
vec4 m = max(0.6 - vec4(dot(x0,x0), dot(x1,x1), dot(x2,x2), dot(x3,x3)), 0.0);
m = m * m;
return 42.0 * dot( m*m, vec4( dot(p0,x0), dot(p1,x1),
dot(p2,x2), dot(p3,x3) ) );
}
float dBox(vec3 p, vec3 q, float r){
return length(max(abs(p) - q, vec3(.0))) - r;
}
vec2 fr(vec2 p, float s) {
float a = PI/s - atan(p.x, p.y);
float n = 2.*PI/s;
a=floor(a/n)*n;
p=rot(p,a);
return p;
}
vec3 folds(vec3 p){
vec3 q=p;
for(int j=0;j<IT;++j){
q=abs(q);
q-=.8;
q.yx=fr(q.yz, .5*PI);
q.yz=fr(q.yz, -PI);
q.z-=.3;
q.y-=.1;
q.x-=.3;
}
return q*q;
}
float map(vec3 p, inout vec3 col){
float width=24.*PI;
float d, a=.5*PI;
vec3 q = p;
q=folds(q);
q.y+=width;
q.y=mod(abs(q.y),1.);
float b1 = dBox(q, vec3(3.*width, .1, .0), .1);
return b1;
}
vec3 normal(vec3 p){
vec3 dum;
vec2 xy = vec2(EPS,0.);
return normalize(vec3(
map(p,dum)-map(p-xy.xyy,dum),
map(p,dum)-map(p-xy.yxy,dum),
map(p,dum)-map(p-xy.yyx,dum)
));
}
struct RAY {
vec3 ray, rd, N, col, L;
float d, la, ph;
};
RAY initRay(vec3 ray, vec3 rd, vec3 N, vec3 col, vec3 L, float d){
RAY newRay;
newRay.ray=ray;newRay.rd=rd;newRay.N=N;newRay.col=col;newRay.L=L;newRay.d=d;newRay.la=0.;newRay.ph=0.;
return newRay;
}
void lighting(inout RAY ray){
ray.N = normal(ray.ray);
ray.ph = pow(dot(ray.rd, ray.L), 4.);
ray.la = .5+.5*dot(ray.N, ray.L);
}
RAY march(RAY ray){
RAY ret=initRay(ray.ray, ray.rd, ray.N, ray.col, ray.L, ray.d);
float d;
for(int j=0;j<IT;++j){
d = map(ret.ray, ret.col);
ret.d+=d;
if(abs(d)<EPS){
lighting(ret);
break;
}
if(d>FAR){
break;
}
ret.ray+=d*ret.rd;
}
return ret;
}
void main(){
vec2 p = (gl_FragCoord.xy * 2.0 - resolution) / min(resolution.x,resolution.y);
float t = time;
vec3 L = normalize(vec3(-.1,-.1,-mod(t,1.)));
vec3 col = vec3(.01, .04, .02);
vec3 ro = vec3(-0.1, -18.1, -16.);
ro+=20.+.01*sin(time);
ro.y-=mod(time,6.);
vec3 rd = normalize(vec3(-p, FOV*dot(p,p)));
RAY ray=initRay(ro, rd,vec3(.0),col,L,0.);
ray=march(ray);
float fog = FAR/ray.d;
RAY rayR=initRay(ray.ray, reflect(rd,ray.N),vec3(.0),col,L,0.);
rayR=march(rayR);
col +=
ray.col
+ rayR.col
+ ray.la
+ ray.ph
;
col*=fog;
col=1.3-col;
gl_FragColor = vec4(col, 1.);
}
code:gaz20190510.GLSL
precision mediump float;
uniform vec2 resolution;
uniform float time;
out vec4 fragColor;
#define rot(a) mat2(cos(a),sin(a),-sin(a),cos(a)) #define hash(a) fract(sin(a)*5555.) float noise(vec3 p)
{
vec3 r=vec3(1,99,999);
vec4 s=dot(floor(p),r)+vec4(0,r.y,r.z,r.y+r.z);
p=smoothstep(0.,1.,fract(p));
vec4 a=mix(hash(s),hash(s+1.),p.x);
vec2 b=mix(a.xz,a.yw,p.y);
return mix(b.x,b.y,p.z);
}
float deTetra(vec3 p, float r)
{
vec2 g=vec2(-1,1)*0.577;
return max(max(max(
dot(p, g.xxx),
dot(p, g.xyy)),
dot(p, g.yxy)),
dot(p, g.yyx))-r;
}
float deStellate(vec3 p)
{
float t=fract(time*0.2);
t=ease_in_out_bounce(t);
t*=acos(-1.)*2.0;
p+=vec3(cos(t)*2.0,sin(t*2.0)*3.0,cos(t*0.3));
//++++++++++++
p.xy*=rot(time*2.0);
p.yz*=rot(time*2.5);
return min(deTetra(p,0.6),deTetra(-p,0.6));
}
float deRing(vec3 p)
{
float t=abs(fract(time)*2.-1.);
p.z-=ease_in_elastic(t)*3.0;
//++++++++++++++++++++++++++
p.x -=-3.;
p.yz*=rot(time);
float h=abs(length(p.xy)-1.)-0.2;
return length(max(vec2(h,abs(p.z)-0.1),vec2(0)))-0.1;
}
float deBox(vec3 p)
{
float t=abs(fract(time)*2.-1.);
p.y-=ease_in_out_back(t)*3.0;
//++++++++++++++++++++++
p.x -=3.;
p.xy*=rot(time);
p.yz*=rot(time);
return length(max(abs(p)-vec3(0.8),vec3(0)))-0.2;
}
float deDisk(vec3 p)
{
p.y -=-2.;
float h=length(p.xz)-7.;
return length(max(vec2(h,abs(p.y)-0.2),0.))-0.1;
}
float map(vec3 p)
{
return min(min(min(deBox(p),deRing(p)),deStellate(p)),deDisk(p));
}
#define hue(v) (vec3(1),(abs(mod(v*6.+vec3(0,4,2),6.)-3.)-1.)*0.5+0.3) vec3 doColor(vec3 p)
{
if(deRing(p)<0.001) return hue(fract(0.1+time*0.1));
if(deBox(p)<0.001) return hue(fract(0.3+time*0.1));
if(deStellate(p)<0.001) return hue(fract(0.9+time*0.1));
float c=2.;
p=mod(p,c)-c*0.5;
return vec3(sign(p.x*p.z));
}
float softshadow(vec3 ro,vec3 rd)
{
float res = 1.0;
float t = 0.05;
for(int i = 0; i < 32; i++)
{
float h = map(ro + rd * t);
res = min(res, 8.0 * h / t);
t += clamp(h, 0.02, 0.1);
if(h < 0.001 || t > 1.5) break;
}
return clamp(res, 0.0, 1.0);
}
void main()
{
vec2 uv=(gl_FragCoord.xy*2.-resolution)/resolution.y;
vec3 ro=vec3(0,5,-10);
//ro.xz*=rot(time*0.1);
ro= vec3(cos(time*0.5+0.5*cos(time*.3))*8.0-6.,sin(time*0.8+0.5*sin(time*0.3))+4.0,sin(time*0.3+1.2*sin(time*0.3))*10.+5.);
vec3 ta=vec3(2,0,0);
vec3 w=normalize(ta-ro),u=normalize(cross(w,vec3(0,1,0)));
vec3 rd=mat3(u,cross(u,w),w)*normalize(vec3(uv,2));
float d,i,t=0.;
vec3 p=ro;
for(i=1.;i>0.;i-=1./90.)
{
t+=d=map(p);
if(d<0.001)break;
p+=rd*d;
}
vec3 col=vec3(noise(rd*(18.+3.*sin(time*0.3+0.5*sin(time*0.2)))));
col*=abs(rd.xzy);
if(d<0.001)
{
col=doColor(p);
vec3 l=normalize(vec3(1,3,2));
vec2 e=vec2(-1,1)*0.002;
vec3 n=normalize(
e.xyy*map(p+e.xyy)+
e.yxy*map(p+e.yxy)+
e.yyx*map(p+e.yyx)+
e.xxx*map(p+e.xxx)
);
col*=max(0.3,dot(l,n));
col*=i*i*i;
col+=pow(max(0.,dot(reflect(normalize(p-ro),n),l)),100.);
col=min(vec3(1),col);
col*=softshadow(p, l);
col=min(vec3(1),col);
}
col=pow(col,vec3(1.2));
fragColor=vec4(col,1);
}
code:PhongShading.GLSL
float phong(vec3 R, vec3 V){
float specAngle = max(dot(R, V), 0.);
return pow(specAngle, 4.);
}
ifをstepで書き換える
code:usingSignForIf.GLSL
// x != a
abs(sign(x - a))
code:GLSL
return length(cross(p-ro, rd)) / length(rd);
code:frags.GLSL
// - glslfan.com --------------------------------------------------------------
// Ctrl + s or Command + s: compile shader
// Ctrl + m or Command + m: toggle visibility for codepane
// ----------------------------------------------------------------------------
precision highp float;
uniform vec2 resolution; // resolution (width, height)
uniform vec2 mouse; // mouse (0.0 ~ 1.0)
uniform float time; // time (1second == 1.0)
uniform sampler2D backbuffer; // previous scene
out vec4 fragColor;
vec3 rotate(vec3 p, vec3 n, float a)
{
n=normalize(n);
vec3 v = cross(p, n), u = cross(v, n);
return u * cos(a) + v * sin(a) + n * dot(p, n);
}
mat2 rotate(float a)
{
return mat2(cos(a), sin(a), -sin(a), cos(a));
}
float sdBox( vec3 p, vec3 b )
{
vec3 d = abs(p) - b;
return length(max(d,0.0))
+ min(max(d.x,max(d.y,d.z)),0.0); // remove this line for an only partially signed sdf
}
float map(vec3 p)
{
vec3 u = floor(p/6.0);
u = sin(11.0*(2.5*u+3.0*u.yzx+1.345)); // random 適当に関数を書いてます
p=mod(p,6.0)-3.0;
p = rotate(p,u,time);
if (dot(u,u.yxz)>0.0){return 1.0;} // 折り畳みの間引き
return sdBox(p,vec3(01.5));
}
void main()
{
vec3 d = normalize(vec3((gl_FragCoord.xy * 2.0 - resolution) / resolution.y,2)),
col = vec3(0),
p = vec3(0,5,8),
ta =vec3(rotate(time*0.1)*vec2(1,0),2.*sin(time*0.3)),
w,u;
p.xz *= rotate(time*0.1);
w = normalize(ta-p);u = cross(w,vec3(0,1,0));
d = mat3(u,cross(u,w),w)*d;
for (float i=1.0; i>0.0; i-=0.01)
{
float x =map(p);
if(x < 0.001){
col= i*i*i*(1.0+vec3(1,0,0));
break;
}
p+=d*x;
}
col = vec3(0.8,0.3,0.1)*min(1.0,fwidth(col.x*5.0)*2.0);
fragColor = vec4(col, 1);
}
code:RainDrops glslfan .glsl
precision mediump float;
uniform vec2 resolution; // resolution (width, height)
uniform float time; // time (1second == 1.0)
const float PI = 3.1415926;
const float EPS = .0001;
#define S(a, b, t) smoothstep(a, b, t) vec3 N13(float p) {
// from DAVE HOSKINS
vec3 p3 = fract(vec3(p, p, p) * vec3(.1031, .11369, .13787));
p3 += dot(p3, p3.yzx + 19.19);
return fract(vec3((p3.x + p3.y)*p3.z, (p3.x + p3.z)*p3.y, (p3.y + p3.z)*p3.x));
}
float N(float t) {
return fract(sin(t*12345.564)*7658.76);
}
float Saw(float b, float t) {
return S(0., b, t)*S(1., b, t);
}
vec2 DropLayer2(vec2 uv, float t) {
vec2 UV = uv;
uv.y += t * 0.75;
vec2 a = vec2(6., 1.);
vec2 grid = a * 2.;
vec2 id = floor(uv*grid);
float colShift = N(id.x);
uv.y += colShift;
id = floor(uv*grid);
vec3 n = N13(id.x*35.2 + id.y*2376.1);
vec2 st = fract(uv*grid) - vec2(.5, 0);
float x = n.x - .5;
float y = UV.y*20.;
float wiggle = sin(y + sin(y));
x += wiggle * (.5 - abs(x))*(n.z - .5);
x *= .7;
float ti = fract(t + n.z);
y = (Saw(.85, ti) - .5)*.9 + .5;
vec2 p = vec2(x, y);
float d = length((st - p)*a.yx);
float mainDrop = S(.4, .0, d);
float r = sqrt(S(1., y, st.y));
float cd = abs(st.x - x);
float trail = S(.23*r, .15*r*r, cd);
float trailFront = S(-.02, .02, st.y - y);
trail *= trailFront * r*r;
y = UV.y;
float trail2 = S(.2*r, .0, cd);
float droplets = max(0., (sin(y*(1. - y)*120.) - st.y))*trail2*trailFront*n.z;
y = fract(y*10.) + (st.y - .5);
float dd = length(st - vec2(x, y));
droplets = S(.3, 0., dd);
float m = mainDrop + droplets * r*trailFront;
return vec2(m, trail);
}
float StaticDrops(vec2 uv, float t) {
uv *= 40.;
vec2 id = floor(uv);
uv = fract(uv) - .5;
vec3 n = N13(id.x*107.45 + id.y*3543.654);
vec2 p = (n.xy - .5)*.7;
float d = length(uv - p);
float fade = Saw(.025, fract(t + n.z));
float c = S(.3, 0., d)*fract(n.z*10.)*fade;
return c;
}
vec2 Drops(vec2 uv, float t, float l0, float l1, float l2) {
float s = StaticDrops(uv, t)*l0;
vec2 m1 = DropLayer2(uv, t)*l1;
vec2 m2 = DropLayer2(uv*1.85, t)*l2;
float c = s + m1.x + m2.x;
c = S(.3, 1., c);
return vec2(c, max(m1.y*l0, m2.y*l1));
}
float random(vec2 st){
return fract(sin(dot(st.xy, vec2(12.9898,78.233))) * 43758.5453123);
}
float noise(vec2 co){
vec2 xy = vec2(1., .0);
vec2 i = floor(co);
vec2 f = fract(co);
vec4 x = vec4(
random(i)
,random(i + xy.xy)
,random(i + xy.yx)
,random(i + xy.xx));
vec2 u = f * f * (3. - 2. * f);
return mix(x.x, x.y, u.x)
+ (x.z - x.x) * u.y * (1. - u.x)
+ (x.w - x.y) * u.x * u.y;
}
float fbm(vec2 co, float t){
vec2 p = co;
float v = .0;
float a = .5 + t*.1;
float f = 0.;
for (int i = 0; i < 12; i++) {
v += a * abs(noise(p));
p *= 2.;
a *= a + .3;
}
return v;
}
float map(vec3 p){
vec3 t = vec3(-.6, .8, 0.);
return length(p - t) - 1.;
}
vec3 normal(vec3 p){
vec2 xy = vec2(1., .0);
return normalize(vec3(
map(p + EPS * xy.xyy) - map(p)
,map(p + EPS * xy.yxy) - map(p)
,map(p + EPS * xy.yyx) - map(p)
));
}
vec3 bg(vec3 col) {
float t = time / 16.;
vec2 p = (gl_FragCoord.xy * 2. - resolution) / min(resolution.x, resolution.y);
vec2 q = p;
vec3 newcol = col;
// cloud
newcol *= fbm(p, 0.);
q = p + t;
newcol *= fbm(-q, 0.);
q = q + t/2.;
newcol *= fbm(q, 0.);
newcol *= vec3(.7, .8, .9) + 2.2;
return newcol;
}
vec3 rain(vec3 bcol) {
vec2 uv = (gl_FragCoord.xy*resolution.xy - .5*resolution.xy) / resolution.y;
vec2 UV = gl_FragCoord.xy/resolution.xy;
vec3 M = vec3(0.0, 0.0, 0.0);
float T = time + M.x*2.;
T = mod(time, 102.);
T = mix(T, M.x*102., M.z > 0. ? 1. : 0.);
float t = T * .2;
float rainAmount = M.y;
float maxBlur = mix(3., 6., rainAmount);
float minBlur = 2.;
float story = 0.;
float heart = 0.;
story = S(0., 70., T);
t = min(1., T / 70.); // remap drop time so it goes slower when it freezes
t = 1. - t;
t = (1. - t * t)*70.;
float zoom = .3;// mix(.3, 1.2, story); // slowly zoom out
uv *= zoom;
minBlur = 4. + S(.5, 1., story)*3.; // more opaque glass towards the end
maxBlur = 6. + S(.5, 1., story)*1.5;
vec2 hv = uv - vec2(.0, -.1); // build heart
hv.x *= .5;
float s = S(110., 70., T); // heart gets smaller and fades towards the end
hv.y -= sqrt(abs(hv.x))*.5*s;
heart = length(hv);
heart = S(.4*s, .2*s, heart)*s;
rainAmount = heart; // the rain is where the heart is
maxBlur -= heart; // inside the heart slighly less foggy
uv *= 1.5; // zoom out a bit more
t *= .25;
UV = (UV - .5)*(.9 + zoom * .1) + .5;
float staticDrops = S(-.5, 1., rainAmount)*2.;
float layer1 = S(.25, .75, rainAmount);
float layer2 = S(.0, .5, rainAmount);
vec2 c = Drops(uv, t, staticDrops, layer1, layer2);
vec2 e = vec2(.001, 0.);
float cx = Drops(uv + e, t, staticDrops, layer1, layer2).x;
float cy = Drops(uv + e.yx, t, staticDrops, layer1, layer2).x;
vec2 n = vec2(cx - c.x, cy - c.x);
n *= 1. - S(60., 85., T);
c.y *= 1. - S(80., 100., T)*.8;
float focus = mix(maxBlur - c.y, minBlur, S(.1, .2, c.x));
vec4 texCoord = vec4(UV.x + n.x, UV.y + n.y, 0, focus);
vec3 col = bg(bcol);
t = (T + 3.)*.5; // make time sync with first lightnoing
float colFade = sin(t*.2)*.5 + .5 + story;
col *= mix(vec3(1., 1., 1.), vec3(.8, .9, 1.3), colFade); // subtle color shift
float fade = S(0., 10., T); // fade in at the start
float lightning = sin(t*sin(t*10.)); // lighting flicker
lightning *= pow(max(0., sin(t + sin(t))), 10.); // lightning flash
col *= 1. + lightning * fade*mix(1., .1, story*story); // composite lightning
col *= 1. - dot(UV -= .5, UV); // vignette
col = mix(pow(col, vec3(1.2, 1.2, 1.2)), col, heart);
fade *= S(102., 97., T);
col *= fade; // composite start and end fade
return col;
}
void main(){
vec3 col = vec3(.3, .2, .1);
float t = time / 16.;
vec2 p = (gl_FragCoord.xy * 2. - resolution) / min(resolution.x, resolution.y);
vec2 q = p;
vec3 N;
vec3 up = vec3(.0, 1., 0.);
vec3 fwd = vec3(0., .0, 1.);
vec3 side = cross(up, fwd);
vec3 rayPos = vec3(.0, 0., -3);
vec3 dir = normalize(p.x * side + p.y * up + fwd);
float d = .0, dTotal = 0.;
for(float j=.0; j<32.; j++){
d = map(rayPos);
if(d < EPS){
N = normal(rayPos);
break;
}
dTotal += d;
rayPos += d * dir;
}
if(d < EPS){
vec3 luna = vec3(1.6, 1.6, .9) * (.5 / dTotal);
col += luna * pow(dot(N, normalize(vec3(-.1, -1., .9))), 2.);
}
// 雨を降らせたい
vec3 raindrops = rain(col);
gl_FragColor = vec4(raindrops, 1.);
}
code:snowFall.GLSL
float snowFall(vec2 uv, float seed)
{
float speed = map(random2d(vec2(floor(uv.x*S))), 0.3, 1.0);
vec2 suv = vec2(uv.x, uv.y+time*speed)*S;
float rndVal = random2d(floor(suv)*0.0001+seed*100.0);
vec2 fuv = fract(suv)*2.0-1.0;
fuv.x -= sin(fract(time)*TWO_PI+rndVal*1000.0)*rndVal*0.9;
float probability = step(rndVal, 0.5);
float snow = 0.08/dot(fuv, fuv)*(1.0-length(fuv));
float fout = smoothstep(-1.0+rndVal, 1.0, uv.y);
float melt = max(0.0, sin(fract(time*0.1)*TWO_PI+rndVal*100.0));
return snow*melt*fout*probability;
}
code:frags_.GLSL
precision mediump float;
uniform vec2 resolution; // resolution (width, height)
uniform float time; // time (1second == 1.0)
const float PI = 3.1415926;
const float EPS = .00001;
// Golden Ratio
const float PHI = 1.618033988749894848;
vec3 HUE2RGB(float h)
{
float r = abs(h * 6. - 3.) - 1.;
float g = 2. - abs(h * 6. - 2.);
float b = 2. - abs(h * 6. - 4.);
return clamp(vec3(r, g, b), .0, 1.);
}
vec2 rot(vec2 p, float a){
return vec2(p.x * cos(a) - p.y * sin(a), p.x * sin(a) + p.y * cos(a));
}
float plane(vec3 p, vec4 n){
return dot(p,n.xyz) + n.w;
}
float dBox(vec3 p, vec3 r){
vec3 q = abs(p) - r;
return length(max(q, .0)) + min(max(q.x, max(q.y, q.z)), 0.);
}
float map(vec3 p){
vec3 q = p;
q.y += 2.5;
float pl = plane(q, normalize(vec4(0., 1., 0., 1.)));
float h = dBox(q, vec3(2.5 + 2.5 * sin(time), 10., 10.));
pl = max(pl, -h);
q = p;
q.xy = rot(q.xy, time);
q.xz = rot(q.xz, time);
float b = dBox(q - vec3(.0, -.2, 0.), vec3(.2, .1 + .05 * sin(time), .2));
float th = dot(q, normalize(sign(q))) - .15;
b = mix(b, th, sin(time));
return min(pl, b);
}
vec3 normal(vec3 p){
vec2 xy = vec2(1., .0);
return normalize(vec3(
map(p + EPS * xy.xyy) - map(p)
,map(p + EPS * xy.yxy) - map(p)
,map(p + EPS * xy.yyx) - map(p)
));
}
void main(){
vec2 p = (gl_FragCoord.xy * 2. - resolution) / min(resolution.x, resolution.y);
vec3 color = vec3(.6, .4, .9);
vec3 up = vec3(0., 1., .0);
vec3 fwd = vec3(.0, 0., 1.);
vec3 side = cross(up, fwd);
float focus = PI;
vec3 ray = vec3(-.1, -.1, -1.);
vec3 dir = normalize(p.x * side + p.y * up + fwd * focus);
float d, tD = 0., fog = .0;
vec3 N;
color = clamp(color, 0., .5 * fract(.3 * time));
vec3 lCol = vec3(.2, .4, .7);
vec3 lDir = normalize(vec3(-1., -2., 3.));
float steps = 256.;
for(float j=.0; j<256.; j++){
d = map(ray);
tD += d;
fog += tD;
if(d < EPS) {
steps = j;
N = normal(ray);
lCol = vec3(HUE2RGB(steps * PHI));
color *= lCol * pow(.5 * dot(N, lDir) + .5, .2);
break;
}
ray += d * dir;
}
color *= clamp(fog / 2., .0, 1.2);
gl_FragColor = vec4(color, 1.);
}
code:concrete world.GLSL
// - glslfan.com --------------------------------------------------------------
// Ctrl + s or Command + s: compile shader
// Ctrl + m or Command + m: toggle visibility for codepane
// ----------------------------------------------------------------------------
precision mediump float;
uniform vec2 resolution; // resolution (width, height)
uniform vec2 mouse; // mouse (0.0 ~ 1.0)
uniform float time; // time (1second == 1.0)
uniform sampler2D backbuffer; // previous scene
const float PI = 3.1415926;
//--- concrete world
// by Catzpaw 2018
vec3 rotX(vec3 p,float a){return vec3(p.x,p.y*cos(a)-p.z*sin(a),p.y*sin(a)+p.z*cos(a));}
vec3 rotY(vec3 p,float a){return vec3(p.x*cos(a)-p.z*sin(a),p.y,p.x*sin(a)+p.z*cos(a));}
vec3 rotZ(vec3 p,float a){return vec3(p.x*cos(a)-p.y*sin(a), p.x*sin(a)+p.y*cos(a), p.z);}
vec3 hsv(float h,float s,float v){return ((clamp(abs(fract(h+vec3(0.,.666,.333))*6.-3.)-1.,0.,1.)-1.)*s+1.)*v;}
float map(vec3 p){float r=1.,lr=0.,s=1.;;p=rotX(p,time*.15);p=rotZ(p,time*.111);p.xy+=vec2(3.4,9.3);p.z+=time;
for(int i=0;i<OCT;i++){vec3 q=clamp(sin(p),.27,1.);r=max(lr,.3-dot(q,q));lr=r;s*=1.274;p*=s;}
return r;}
float trace(vec3 ro,vec3 rd,out float n){float t=NEAR,d;
for(int i=0;i<ITER;i++){d=map(ro+rd*t);if(abs(d)<EPS||t>FAR)break;t+=step(d,1.)*d*.2+d*.5;n+=1.;}
return min(t,FAR);}
void main(void){
vec2 uv=(gl_FragCoord.xy-.5*resolution.xy)/resolution.y;
vec3 rd=vec3(uv,-.5);
float n=0.,v=1.-trace(vec3(0),rd,n)/FAR;n/=float(ITER);
gl_FragColor=vec4(mix(hsv(v,n,.5),vec3(1),n)*n,1);
}
code:rainbow temple.GLSL
//--- rainbow temple
// by Catzpaw 2018
precision mediump float;
uniform float time;
uniform vec2 mouse;
uniform vec2 resolution;
vec3 rotX(vec3 p,float a){
return vec3(p.x,p.y*cos(a)-p.z*sin(a),p.y*sin(a)+p.z*cos(a));
}
vec3 rotY(vec3 p,float a){
return vec3(p.x*cos(a)-p.z*sin(a),p.y,p.x*sin(a)+p.z*cos(a));
}
vec3 rotZ(vec3 p,float a){
return vec3(p.x*cos(a)-p.y*sin(a), p.x*sin(a)+p.y*cos(a), p.z);
}
vec3 hsv(float h, float s, float v){
return ((clamp(abs(fract(h+vec3(0.,.666,.333))*6.-3.)-1.,0.,1.)-1.)*s+1.)*v;
}
float map(vec3 p){
float r=1.;
p.xz=fract(p.xz)-.5;
for(int i=0;i<OCT;i++){
p=abs(p);
p.y-=SHIFT;
float s=2./clamp(dot(p,p),.28,.99);
p*=s;
p-=vec3(.51,4.,.7);
r*=s;
}
return length(p/r);
}
float trace(vec3 ro,vec3 rd,out float n){
float t=NEAR,d;
for(int i=0;i<ITER;i++){
d=map(ro+rd*t);
if(abs(d)<EPS||t>FAR)break;
t+=step(d,1.)*d*.2+d*.5;
n+=1.;
}
return min(t,FAR);
}
void main(void){
vec2 uv=(gl_FragCoord.xy-.5*resolution.xy)/resolution.y;
vec3 rd=vec3(uv,-.9);
rd=rotX(rd,sin(time*.1));
rd=rotY(rd,sin(time*.13));
rd=rotZ(rd,sin(time*.11));
float c=clamp(sin(time*.1)*30.,0.,1.),
n=0.,
v=1.-trace(vec3(sin(time*.314)*.15,sin(time*.1)*.6+SHIFT,1.-time*SPEED),rd,n)/FAR;
n/=float(ITER);
gl_FragColor=vec4(mix(vec3(c),mix(hsv(v*4.-time*SPEED*5./FAR,1.,v),vec3(1.-c),n),n)*v,1);
}
code:rainbow temple commented by Gaz.GLSL
// ©Catzpaw
// - glslfan.com --------------------------------------------------------------
// Ctrl + s or Command + s: compile shader
// Ctrl + m or Command + m: toggle visibility for codepane
// ----------------------------------------------------------------------------
precision mediump float;
uniform vec2 resolution; // resolution (width, height)
uniform vec2 mouse; // mouse (0.0 ~ 1.0)
uniform float time; // time (1second == 1.0)
uniform sampler2D backbuffer; // previous scene
const float PI = 3.1415926;
vec2 rot(vec2 p, float a){
return vec2(p.x * cos(a) - p.y * sin(a), p.x * sin(a) + p.y * cos(a));
}
vec3 hsv(float h, float s, float v){
vec4 t = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
vec3 p = abs(fract(vec3(h) + t.xyz) * 6.0 - vec3(t.w));
return v * mix(vec3(t.x), clamp(p - vec3(t.x), 0.0, 1.0), s);
}
float map(vec3 p){
// ぱっと見の印象だと、空間を折りたたんで、半径 0の球の距離関数を返している。
// この rが肝な気がする。普通、折り畳みと言えば、折りたたんで移動、折りたたんで回転だけど、
// これは、折りたたんで拡大になっている。最後に拡大した座標を戻す処理をしている。
// 確かめてないけど、rayの距離がマイナスになったりして、行ったり来たりして収束する気がする。
// 距離関数評価に"if(abs(d)<EPS||t>FAR)break;"とabs()を使ってる要因だと思う。
// 結局、こんな形の関数ではなくてIFSとおなじ表現ってことかな。
// 収束の回数で形を作る特殊なやり方ですね。
// たしか、マンデルブロもそうだった気がしたけど。
// なら、ポイントが解れば、適当な形が生み出せるかも?
float r = 1.;
p.xz = fract(p.xz) - .5;
for(int i=0; i < OCT; i++){
p = abs(p);
p.y -= SHIFT;
p.z += .1 * sin(time);
float s = 2. / clamp(dot(p,p), .28, .99);
p *= s;
p -= vec3(.51, 4., .7);
// p -= vec3(2., 20., 20.);
r *= s;
}
return length(p/r);
//return length(p);
}
float trace(vec3 ro,vec3 rd,out float n){
float t=NEAR,d;
for(int i=0;i<ITER;i++){
d=map(ro+rd*t);
// abs(d)で距離関数を評価しているので、この距離関数はsignedだと思う。
if(abs(d)<EPS||t>FAR)break;
// 距離関数にフィルター(距離の制限)を掛けてるけど、意味がわからない。
// ゆっくりと考えてみます。
// t+=d;にしても、絵がでるのでstep数の調整で疑似AOの調整と思われる。
//t+=d;
t+=step(d,1.)*d*.2+d*.5;
n+=1.;
}
// この nは、疑似AO(3Dの立体感をこれのみで表現)に使うために算出
n/=float(ITER);
// この関数の出力をFARを使って正規化するのでmin()を使って制限をかけている。
return min(t,FAR);
}
void main(){
// ©Catzpaw
vec2 uv = (gl_FragCoord.xy-.5*resolution.xy)/resolution.y;
vec3 rd = vec3(uv , -.8);
// 単純にrayの飛ばす方向を変えているだけ。
rd.yz = rot(rd.yz,sin(.1 * time));
rd.zx = rot(rd.zx,sin(.2 * time));
rd.xy = rot(rd.xy,sin(.3 * time));
// この cは、バックの色の明暗に使われているようだ。
// じかんによってvec3(0),vec3(1)の色の間を行き来してる。
float c = clamp(sin(time * .1) * 30., 0., 1.),
// この nは,色の陰影に使われる数値(疑似AO)。これを加工して使っている。
n = 0.,
// この vは、FARによって正規されているので、vは 0~1の間にある。
// NEARとFARがあるところを見ると、視錐台を表現してると推測できる。
// NEARを0.0にしたけど動いてた。?
// 1.-trace()としているのは、使い勝手の問題だけかな。
v = 1. - trace(
// 単純にrayの原点を変えているだけ。
vec3(.3
,2. + .8 * sin(time/32.)
,-time / 4.
)
, rd, n) / FAR;
// どうも、時間によってホワイトバランスを調整してるようだ。
n /= mix(1., float(ITER)/16., fract(time / 24.));
//n /= float(ITER)/16.;
// どうも、距離で色を決めて、AOで陰影をつけてるだけかな?
// ならば、距離関数が肝ですね。
gl_FragColor =
vec4(
mix(
vec3(c)
,mix(hsv(v*4.-time*SPEED*5./FAR
,1.
,v)
,vec3(1.-c)
,n)
,n)
*v
,1);
//gl_FragColor = vec4(vec3(c),1);
}