precision highp float; uniform vec2 resolution; uniform float time; uniform vec2 mouse; uniform sampler2D backbuffer; // ------------------------------------------------------------------------------------ // Original "thinking..." created by kaneta : https://www.shadertoy.com/view/wslSRr // Original Character By MikkaBouzu : https://twitter.com/mikkabouzu777 // ------------------------------------------------------------------------------------ // Rendering Option //#define ENABLE_REFLECTION #define ENABLE_GRID_BOUNDARY #define SMOOTH_HSV #define saturate(x) clamp(x, 0.0, 1.0) #define MAX_MARCH 100 #define MAX_RAYCAST 100 #define MAX_RAYCAST_L 6 #define MAX_DIST 20. #define M_PI 3.1415926 #define M_PI2 M_PI*2.0 #define RAD90 (M_PI * 0.5) #define RAD45 (M_PI * 0.25) #define M_PI03 1.04719 #define M_PI06 2.09439 const float EPS = 1e-4; const float EPS_N = 1e-5; const float OFFSET = EPS * 10.0; //const vec3 sunDir = normalize(vec3(-1,1,-0.25)); const vec3 lightPos = vec3(0.1, 0.3, -0.5); const vec3 lightColor = vec3(0.98, 0.92, 0.89) * 3.0; struct surface { float dist; vec4 albedo; vec3 emission; float roughness; float metalness; int count; bool isTransparent; float refractPower; bool isHit; }; // Surface Data Define #define SURF_NOHIT(d) (surface(d, vec4(0), vec3(0), 0.0, 0.0, 0, false, 0.0, false)) #define SURF_BLACK(d) (surface(d, vec4(0,0,0,1), vec3(0), 0.3, 0.0, 0, false, 0.0, true)) #define SURF_FACE(d) (surface(d, vec4(1,0.7,0.6,1), vec3(0), 0.3, 0.0, 0, false, 0.0, true)) #define SURF_MOUSE(d) (surface(d, vec4(1,0,0.1,1), vec3(0), 0.3, 0.0, 0, false, 0.0, true)) #define SURF_CHEEP(d) (surface(d, vec4(1,0.3,0.4,1), vec3(0), 0.3, 0.0, 0, false, 0.0, true)) surface SURF_BG1(float d, vec3 pos) { //vec3 index = floor((pos +vec3(0,0,iTime*3.0) )* 2. + 0.5); vec3 index = floor(pos * 2. + 0.5); vec4 col = vec4(vec3(0.25) + vec3(0.75) * mod(mod(index.x + index.y, 2.0) + index.z + index.y, 2.0), 1); return surface(d, col, vec3(0), 0.5, 0.3, 0, false, 0., true); } #define SURF_CS(d) (surface(d, vec4(0.9,0.9,0.9,1), vec3(0), 0.1, 0.8, 0, false, 0., true)) #define SURF_SPHERE(d) (surface(d, vec4(0,0,0,1), vec3(0), 0.1, 0.8, 0, false, 2.2, true)) #define SURF_CUBE(d) (surface(d, vec4(0,1,0,1), vec3(0), 0.5, 0.0, 0, false, 2.2, true)) #define SURF_SPHERE2(d) (surface(d, vec4(0,0,1,1), vec3(0), 0.1, 0.2, 0, false, 2.2, true)) #define SURF_LEG(d) (surface(d, vec4(0.5,0.2,0.1,1), vec3(0), 0.3, 0.0, 0, false, 0.0, true)) vec3 sinebow(float h) { vec3 r = sin((.5-h)*M_PI + vec3(0,M_PI03,M_PI06)); return r*r; } //-----------------HSV----------------- //HSV functions from iq (https://www.shadertoy.com/view/MsS3Wc) #ifdef SMOOTH_HSV vec3 hsv2rgb( in vec3 c ) { vec3 rgb = clamp( abs(mod(c.x*6.0+vec3(0.0,4.0,2.0),6.0)-3.0)-1.0, 0.0, 1.0 ); rgb = rgb*rgb*(3.0-2.0*rgb); // cubic smoothing return c.z * mix( vec3(1.0), rgb, c.y); } #else vec3 hsv2rgb( in vec3 c ) { vec3 rgb = clamp( abs(mod(c.x*6.0+vec3(0.0,4.0,2.0),6.0)-3.0)-1.0, 0.0, 1.0 ); return c.z * mix( vec3(1.0), rgb, c.y); } #endif //From Sam Hocevar: http://lolengine.net/blog/2013/07/27/rgb-to-hsv-in-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); } // Hash without Sine by Dave_Hoskins // https://www.shadertoy.com/view/4djSRW //---------------------------------------------------------------------------------------- // 1 out, 2 in... 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); } // 1 out, 3 in... float hash13(vec3 p3) { p3 = fract(p3 * .1031); p3 += dot(p3, p3.yzx + 33.33); return fract((p3.x + p3.y) * p3.z); } /// 2 out, 2 in... vec2 hash22(vec2 p) { vec3 p3 = fract(vec3(p.xyx) * vec3(.1031, .1030, .0973)); p3 += dot(p3, p3.yzx+33.33); return fract((p3.xx+p3.yz)*p3.zy); } // 3 out, 1 in... vec3 hash31(float p) { vec3 p3 = fract(vec3(p) * vec3(.1031, .1030, .0973)); p3 += dot(p3, p3.yzx+33.33); return fract((p3.xxy+p3.yzz)*p3.zyx); } /// 3 out, 3 in... vec3 hash33(vec3 p3) { p3 = fract(p3 * vec3(.1031, .1030, .0973)); p3 += dot(p3, p3.yxz+33.33); return fract((p3.xxy + p3.yxx)*p3.zyx); } float rand(vec2 st) { return fract(sin(dot(st.xy, vec2(12.9898, 78.233))) * 10000.0); } float rand3d(vec3 st) { return fract(sin(dot(st.xyz, vec3(12.9898, 78.233, 56.787))) * 10000.0); } float noise(vec3 st) { vec3 ip = floor(st); vec3 fp = smoothstep(vec3(0.), vec3(1.), fract(st)); vec4 a = vec4(rand3d(ip+vec3(0.)),rand3d(ip+vec3(1.,0.,0.)),rand3d(ip+vec3(0.,1.,0.)),rand3d(ip+vec3(1.,1.,0.))); vec4 b = vec4(rand3d(ip+vec3(0.,0.,1.)),rand3d(ip+vec3(1.,0.,1.)),rand3d(ip+vec3(0.,1.,1.)),rand3d(ip+vec3(1.,1.,1.))); a = mix(a, b, fp.z); a.xy = mix(a.xy, a.zw, fp.y); return mix(a.x, a.y, fp.x); } mat3 m = mat3( 0.00, 0.80, 0.60, -0.80, 0.36, -0.48, -0.60, -0.48, 0.64 ); float fbm( vec3 p ) { float f; f = 0.5000*noise( p ); p = m*p*2.02; f += 0.2500*noise( p ); p = m*p*2.03; f += 0.1250*noise( p ); return f; } float easeInOutQuad(float t) { if ((t *= 2.0) < 1.0) { return 0.5 * t * t; } else { return -0.5 * ((t - 1.0) * (t - 3.0) - 1.0); } } vec2 hash( in vec2 x ) // replace this by something better { const vec2 k = vec2( 0.3183099, 0.3678794 ); x = x*k + k.yx; return -1.0 + 2.0*fract( 16.0 * k*fract( x.x*x.y*(x.x+x.y)) ); } 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( hash12( i + vec2(0.0,0.0) ), hash12( i + vec2(1.0,0.0) ), u.x), mix( hash12( i + vec2(0.0,1.0) ), hash12( i + vec2(1.0,1.0) ), u.x), u.y); } // return gradient noise (in x) and its derivatives (in yz) vec3 noised( in vec2 p ) { vec2 i = floor( p ); vec2 f = fract( p ); #if 1 // quintic interpolation vec2 u = f*f*f*(f*(f*6.0-15.0)+10.0); vec2 du = 30.0*f*f*(f*(f-2.0)+1.0); #else // cubic interpolation vec2 u = f*f*(3.0-2.0*f); vec2 du = 6.0*f*(1.0-f); #endif vec2 ga = hash( i + vec2(0.0,0.0) ); vec2 gb = hash( i + vec2(1.0,0.0) ); vec2 gc = hash( i + vec2(0.0,1.0) ); vec2 gd = hash( i + vec2(1.0,1.0) ); float va = dot( ga, f - vec2(0.0,0.0) ); float vb = dot( gb, f - vec2(1.0,0.0) ); float vc = dot( gc, f - vec2(0.0,1.0) ); float vd = dot( gd, f - vec2(1.0,1.0) ); return vec3( va + u.x*(vb-va) + u.y*(vc-va) + u.x*u.y*(va-vb-vc+vd), // value ga + u.x*(gb-ga) + u.y*(gc-ga) + u.x*u.y*(ga-gb-gc+gd) + // derivatives du * (u.yx*(va-vb-vc+vd) + vec2(vb,vc) - va)); } // Distance functions by iq // https://iquilezles.org/www/articles/distfunctions/distfunctions.htm float sdSphere(in vec3 p, float s) { return length(p) - s; } float sdRoundBox(vec3 p, vec3 size, float r) { return length(max(abs(p) - size * 0.5, 0.0)) - r; } float sdBox( vec3 p, vec3 b ) { vec3 d = abs(p) - b; return min(max(d.x,max(d.y,d.z)),0.0) + length(max(d,0.0)); } float sdCapsule(vec3 p, vec3 a, vec3 b, float r) { vec3 pa = p - a, ba = b - a; float h = clamp(dot(pa, ba) / dot(ba, ba), 0.0, 1.0); return length(pa - ba*h) - r; } float sdCapsule(vec3 p, vec3 a, vec3 b, float r1, float r2) { vec3 pa = p - a, ba = b - a; float h = clamp(dot(pa, ba) / dot(ba, ba), 0.0, 1.0); return length(pa - ba*h) - mix(r1, r2, h); } float sdEllipsoid( vec3 p, vec3 r ) { float k0 = length(p/r); float k1 = length(p/(r*r)); return k0*(k0-1.0)/k1; } float sdCappedTorus(in vec3 p, in vec2 sc, in float ra, in float rb) { p.x = abs(p.x); float k = (sc.y*p.x>sc.x*p.y) ? dot(p.xy,sc) : length(p.xy); return sqrt( dot(p,p) + ra*ra - 2.0*ra*k ) - rb; } float sdRoundedCylinder( vec3 p, float ra, float rb, float h ) { vec2 d = vec2( length(p.xz)-2.0*ra+rb, abs(p.y) - h ); return min(max(d.x,d.y),0.0) + length(max(d,0.0)) - rb; } float sdPlane( vec3 p, vec4 n ) { // n must be normalized return dot(p,n.xyz) + n.w; } float dot2( in vec2 v ) { return dot(v,v); } float dot2( in vec3 v ) { return dot(v,v); } float ndot( in vec2 a, in vec2 b ) { return a.x*b.x - a.y*b.y; } float sdCappedCone( vec3 p, float h, float r1, float r2 ) { vec2 q = vec2( length(p.xz), p.y ); vec2 k1 = vec2(r2,h); vec2 k2 = vec2(r2-r1,2.0*h); vec2 ca = vec2(q.x-min(q.x,(q.y<0.0)?r1:r2), abs(q.y)-h); vec2 cb = q - k1 + k2*clamp( dot(k1-q,k2)/dot2(k2), 0.0, 1.0 ); float s = (cb.x<0.0 && ca.y<0.0) ? -1.0 : 1.0; return s*sqrt( min(dot2(ca),dot2(cb)) ); } float sdTorus( vec3 p, vec2 t ) { vec2 q = vec2(length(p.xz)-t.x,p.y); return length(q)-t.y; } // Distance Function 2D float sdSegment( in vec2 p, in vec2 a, in vec2 b ) { vec2 pa = p-a, ba = b-a; float h = clamp( dot(pa,ba)/dot(ba,ba), 0.0, 1.0 ); return length( pa - ba*h ); } // SdJoint3DSphere & joint3DMatrix & matrix utility // by PixelPhil // https://www.shadertoy.com/view/3tKGDW mat4 scaleMatrix( in vec3 sc ) { return mat4(sc.x, 0, 0, 0, 0, sc.y, 0, 0, 0, 0, sc.z, 0, 0, 0, 0, 1); } mat4 rotationX( in float angle ) { float c = cos(angle); float s = sin(angle); return mat4(1.0, 0, 0, 0, 0, c, -s, 0, 0, s, c, 0, 0, 0, 0, 1); } mat4 rotationY( in float angle ) { float c = cos(angle); float s = sin(angle); return mat4( c, 0, s, 0, 0, 1.0, 0, 0, -s, 0, c, 0, 0, 0, 0, 1); } mat4 rotationZ( in float angle ) { float c = cos(angle); float s = sin(angle); return mat4(c, -s, 0, 0, s, c, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1); } mat4 translate( in vec3 p) { return mat4(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, p.x, p.y, p.z, 1); } // returns distance in .x and UVW parametrization in .yzw float sdJoint3DSphere( in vec3 p, in float l, in float a, in float w) { if( abs(a)<0.001 ) { return length(p-vec3(0,clamp(p.y,0.0,l),0))-w; } vec2 sc = vec2(sin(a),cos(a)); float ra = 0.5 * l / a; p.x -= ra; vec2 q = p.xy - 2.0*sc*max(0.0,dot(sc,p.xy)); float u = abs(ra)-length(q); float d2 = (q.y<0.0) ? dot2( q + vec2(ra,0.0) ) : u*u; return sqrt(d2+p.z*p.z)-w; } // A matrix to the tip of a sdJoint3DSphere // Could probably use some optimisations mat4 joint3DMatrix(in float l, in float a) { if( abs(a)<0.001 ) { return translate(vec3(0, -l, 0)); } float ra = 0.5 * l / a; float ara = abs(ra); return rotationZ(-a * 2.0) * translate(vec3(-ra + cos(2.0 * a) * ra, -sin(2.0 * a) * ra, 0.0)); } // Union, Subtraction, SmoothUnion (distance, Material) surface opU(surface d1, surface d2) { //return (d1.dist < d2.dist) ? d1 : d2; if(d1.dist < d2.dist){ return d1; } else { return d2; } } surface opS( surface d1, surface d2 ) { //return (-d1.dist > d2.dist) ? vec2(-d1.x, d1.y): d2; //return (-d1.dist > d2.dist) ? surface(-d1.dist, d1.albedo, d1.emission, d1.roughness, d1.metalness) : d2; if(-d1.dist > d2.dist){ d1.dist = -d1.dist; return d1; } else { return d2; } } surface opSU( surface d1, surface d2, float k ) { float h = clamp( 0.5 + 0.5*(d2.dist - d1.dist)/k, 0.0, 1.0 ); float d = mix( d2.dist, d1.dist, h ) - k*h*(1.0-h); vec4 albedo = mix( d2.albedo, d1.albedo, h ); vec3 emission = mix( d2.emission, d1.emission, h ); float roughness = mix( d2.roughness, d1.roughness, h ); float metalness = mix( d2.metalness, d1.metalness, h ); float refractPower = mix( d2.refractPower, d1.refractPower, h ); return surface(d, albedo, emission, roughness, metalness, d1.count, h > 0.5 ? d1.isTransparent : d2.isTransparent, refractPower, true); } surface opI( surface d1, surface d2 ) { //return (d1.dist > d2.dist) ? d1 : d2;] if(d1.dist > d2.dist) { return d1; }else{ return d2; } } surface opPaint(surface d1, surface d2) { //return (d1.dist < d2.dist) ? d1 : surface(d1.dist, d2.albedo, d2.emission, d2.roughness, d2.metalness); if(d1.dist < d2.dist) { return d1; } else { d2.dist = d1.dist; return d2; } } // Union, Subtraction, SmoothUnion (distance only) float opUnion( float d1, float d2 ) { return min(d1,d2); } float opSubtraction( float d1, float d2 ) { return max(-d1,d2); } float opIntersection( float d1, float d2 ) { return max(d1,d2); } 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); } vec3 rotate(vec3 p, float angle, vec3 axis) { vec3 a = normalize(axis); float s = sin(angle); float c = cos(angle); float r = 1.0 - c; mat3 m = mat3( a.x * a.x * r + c, a.y * a.x * r + a.z * s, a.z * a.x * r - a.y * s, a.x * a.y * r - a.z * s, a.y * a.y * r + c, a.z * a.y * r + a.x * s, a.x * a.z * r + a.y * s, a.y * a.z * r - a.x * s, a.z * a.z * r + c ); return m * p; } mat2 rot( float th ){ vec2 a = sin(vec2(RAD90, 0) + th); return mat2(a, -a.y, a.x); } vec2 foldRotate(in vec2 p, in float s) { float a = M_PI / s - atan(p.x, p.y); float n = M_PI2 / s; a = floor(a / n) * n; p *= rot(a); return p; } vec3 opTwist(in vec3 p, float k ) { float c = cos(k*p.y); float s = sin(k*p.y); mat2 m = mat2(c,-s,s,c); vec3 q = vec3(m*p.xz,p.y); return vec3(q.x, q.y, q.z); } vec3 TwistY(vec3 p, float power) { float s = sin(power * p.y); float c = cos(power * p.y); mat3 m = mat3( c, 0.0, -s, 0.0, 1.0, 0.0, s, 0.0, c ); return m*p; } vec3 opRep( in vec3 p, in vec3 c) { return mod(p+0.5*c,c)-0.5*c; } vec2 opRep2D( in vec2 p, in vec2 c) { return mod(p+0.5*c,c)-0.5*c; } // 線分と無限平面の衝突位置算出 // rayPos : レイの開始地点 // rayDir : レイの向き // planePos : 平面の座標 // planeNormal : 平面の法線 float GetIntersectLength(vec3 rayPos, vec3 rayDir, vec3 planePos, vec3 planeNormal) { return dot(planePos - rayPos, planeNormal) / dot(rayDir, planeNormal); } // 直方体とレイの衝突位置算出 vec2 GetIntersectBox(vec3 rayPos, vec3 rayDir, vec3 boxPos, vec3 boxSize) { vec3 diff = rayPos - boxPos; vec3 m = 1.0 / rayDir; vec3 n = m * diff; vec3 k = abs(m) * boxSize; vec3 t1 = -n - k; vec3 t2 = -n + k; float tN = max(max(t1.x, t1.y), t1.z); float tF = min(min(t2.x, t2.y), t2.z); return vec2(tN, tF); //return vec2(tF, tN); /* if(tN > tF || tF < 0.0) return vec2(-1.0); // no intersection return vec2(tN, tF); */ } /* // 球とレイの衝突位置算出 vec2 GetIntersectSphere(vec3 rayPos, vec3 rayDir, vec3 spherePos, float radius) { float rsq = radius * radius; vec3 xc = rayPos - spherePos; float xc2 = dot(xc, xc); float vxc = dot(rayDir, xc); float d = vxc * vxc - xc2 + rsq; //if(d < 0.0) return vec2(d,d); float sqrtd = sqrt(d); float tn = -vxc - sqrtd; float tp = -vxc + sqrtd; return vec2(min(tn, tp), max(tn, tp)); //if(tn >= 0.0 && tp >= 0.0) return vec2(min(tn, tp), max(tn, tp); //return tn; } */ vec2 GetIntersectSphere(vec3 rayPos, vec3 rayDir, vec3 sphereCenter, float radius) { float a = length(rayDir); float a2 = a * a; vec3 diff = rayPos - sphereCenter; float b = dot(diff, rayDir); float c = length(diff); float c2 = c * c - radius * radius; float b2ac = sqrt(b * b - a2 * c2); float t1 = (-b + b2ac) / a2; float t2 = (-b - b2ac) / a2; return vec2(min(t1, t2), max(t1, t2)); } // IK vec3 solve( vec3 p, float l1, float l2, vec3 dir ) { vec3 q = p*( 0.5 + 0.5*(l1*l1-l2*l2)/dot(p,p) ); float s = l1*l1 - dot(q,q); s = max( s, 0.0 ); q += sqrt(s)*normalize(cross(p,dir)); return q; } vec3 solve( vec3 a, vec3 b, float l1, float l2, vec3 dir ) { return a + solve( b-a, l1, l2, dir ); } ///////////////////////////////////////////////////////////////////////////////////////////////// // easing function ///////////////////////////////////////////////////////////////////////////////////////////////// float ease_cubic_out(float p) { float f = (p - 1.0); return f * f * f + 1.0; } float easeInCirc(float x) { return 1. - sqrt(1. - pow(x, 2.)); } float easeOutCirc(float x) { return sqrt(1. - pow(x - 1., 2.)); } float easeInExpo(float x) { return x == 0. ? 0. : pow(2., 10. * x - 10.); } ///////////////////////////////////////////////////////////////////////////////////////////////// // Mikka Boze Distance Function ///////////////////////////////////////////////////////////////////////////////////////////////// float sdEar(vec3 p) { p = rotate(p, RAD90+0.25, vec3(0,0,1)); return sdCappedTorus(p + vec3(0.05, 0.175, 0), vec2(sin(0.7),cos(0.7)), 0.03, 0.01); } #define EYE_SPACE 0.04 vec3 opBendXY(vec3 p, float k) { float c = cos(k*p.x); float s = sin(k*p.x); mat2 m = mat2(c,-s,s,c); return vec3(m*p.xy,p.z); } vec3 opBendXZ(vec3 p, float k) { float c = cos(k*p.x); float s = sin(k*p.x); mat2 m = mat2(c,-s,s,c); vec2 xz = m*p.xz; return vec3(xz.x, p.y, xz.y); } float sdMouse(vec3 p, float ms) { vec3 q = opBendXY(p, 2.0); ms += 0.00001; //return sdEllipsoid(q - vec3(0,0,0.2) * sc, vec3(0.05,0.015 + sin(iTime * 1.) * 0.05,0.05) * sc); return sdEllipsoid(q - vec3(0,0,0.2), vec3(0.035, 0.01 * ms,0.05 * ms)); } float sdCheep(vec3 p) { const float x = 0.05; const float z = -0.175; const float r = 0.0045; const float rb1 = 100.; p = rotate(p, M_PI * -0.6 * (p.x - x), vec3(-0.2,0.8,0)); float d = sdCapsule(opBendXY(p + vec3(x, -0.01, z), rb1), vec3(-0.005,0.0,0.0), vec3(0.005, 0., 0.001), r); float d1 = sdCapsule(opBendXY(p + vec3(x+0.01, -0.01, z), 200.0), vec3(-0.0026,0.0,0), vec3(0.0026, 0., 0), r); float d2 = sdCapsule(opBendXY(p + vec3(x+0.019, -0.015, z), -rb1), vec3(-0.01,0.0,-0.01), vec3(0.0045, 0., 0.0), r); return opUnion(opUnion(d, d1), d2); } float sdEyeBrow(vec3 p) { const float x = 0.05; p = opBendXZ(p + vec3(0.02,0,-0.02), -6.5); return sdRoundBox(p + vec3(0.005, -0.14,-0.11), vec3(0.003,0.0025,0.05), 0.001); } surface sdBoze(vec3 p, vec3 sc, float ms) { surface result = SURF_NOHIT(0.); float minsc = min(sc.x, min(sc.y, sc.z)); p /= sc; // head float d = sdCapsule(p, vec3(0,0.05,0), vec3(0, 0.11, 0), 0.125); float d1 = sdRoundedCylinder(p + vec3(0,0.025,0), 0.095, 0.05, 0.0); d = opSmoothUnion(d, d1, 0.1); vec3 mxp = vec3(-abs(p.x), p.yz); // ear float d2 = sdEar(mxp); d = opUnion(d, d2); surface head = SURF_FACE(d); // eye float d4 = sdCapsule(mxp, vec3(-EYE_SPACE, 0.06, 0.13), vec3(-EYE_SPACE, 0.08, 0.125), 0.0175); surface eye = SURF_BLACK(d4); // mouse float d6 = sdMouse(p, ms); surface mouse = SURF_MOUSE(d6); // cheep float d7 = sdCheep(mxp); surface cheep = SURF_CHEEP(d7); // eyebrows float d9 = sdEyeBrow(mxp); eye.dist = opUnion(eye.dist, d9); // integration mouse = opU(eye, mouse); result = opS(mouse, head); result = opU(cheep, result); result.dist *= minsc; return result; } surface sdCapsuleBoze(vec3 p, vec3 a, vec3 b, vec3 sc, float ms) { vec3 pa = p - a, ba = b - a; float h = clamp(dot(pa, ba) / dot(ba, ba), 0.0, 1.0); return sdBoze(pa - ba*h, sc, ms); } surface sdUFBoze(vec3 p, vec3 sc, float ms) { float sl = length(sc); surface cone = SURF_CS(sdCappedCone(p + vec3(0, 0.08 * sl, 0), 0.06 * sl, 0.5 * sl, 0.25 * sl)); return opU(sdBoze(p, sc, ms), cone); } surface sdCapsuleUFBoze(vec3 p, vec3 a, vec3 b, vec3 sc, float ms) { vec3 pa = p - a, ba = b - a; float h = clamp(dot(pa, ba) / dot(ba, ba), 0.0, 1.0); return sdUFBoze(pa - ba*h, sc, ms); //vec3 q = rotate(pa - ba*h, h * M_PI2, normalize(ba)); //return sdUFBoze(q, sc, ms); } ///////////////////////////////////////////////////////////////////////////////////////////////// // End of Mikka Boze ///////////////////////////////////////////////////////////////////////////////////////////////// surface map(vec3 p) { surface result; vec3 b = p; b = rotate(b, M_PI, vec3(0,5,0)); //float scb = saturate(sin(b.z *200. + iTime*50.)) * 0.025; b = opRep(b, vec3(1)); result = sdBoze(b - vec3(0, 0.0, 0), vec3(1, 1, 1), 1.); return result; } #if 0 vec3 norm(vec3 p) { vec2 e=vec2(.00001,.0); return normalize(.000001+map(p).x-vec3(map(p-e.xyy).x,map(p-e.yxy).x,map(p-e.yyx).x)); } #else vec3 norm(in vec3 position) { vec3 epsilon = vec3(0.001, 0.0, 0.0); vec3 n = vec3( map(position + epsilon.xyy).dist - map(position - epsilon.xyy).dist, map(position + epsilon.yxy).dist - map(position - epsilon.yxy).dist, map(position + epsilon.yyx).dist - map(position - epsilon.yyx).dist); return normalize(n); } #endif float shadow(in vec3 origin, in vec3 direction) { float hit = 1.0; float t = 0.02; for (int i = 0; i < MAX_MARCH; i++) { float h = map(origin + direction * t).dist; if (h < EPS) return 0.0; t += h; hit = min(hit, 10.0 * h / t); if (t >= 2.5) break; } return clamp(hit, 0.0, 1.0); } // --------------------------------------------------- // Starfield01 by xaot88 // https://www.shadertoy.com/view/Md2SR3 // --------------------------------------------------- // License Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License. // Return random noise in the range [0.0, 1.0], as a function of x. float Noise2d( in vec2 x ) { float xhash = cos( x.x * 37.0 ); float yhash = cos( x.y * 57.0 ); return fract( 415.92653 * ( xhash + yhash ) ); } // Convert Noise2d() into a "star field" by stomping everthing below fThreshhold to zero. float NoisyStarField( in vec2 vSamplePos, float fThreshhold ) { float StarVal = Noise2d( vSamplePos ); if ( StarVal >= fThreshhold ) StarVal = pow( (StarVal - fThreshhold)/(1.0 - fThreshhold), 6.0 ); else StarVal = 0.0; return StarVal; } // Stabilize NoisyStarField() by only sampling at integer values. float StableStarField( in vec2 vSamplePos, float fThreshhold ) { // Linear interpolation between four samples. // Note: This approach has some visual artifacts. // There must be a better way to "anti alias" the star field. float fractX = fract( vSamplePos.x ); float fractY = fract( vSamplePos.y ); vec2 floorSample = floor( vSamplePos ); float v1 = NoisyStarField( floorSample, fThreshhold ); float v2 = NoisyStarField( floorSample + vec2( 0.0, 1.0 ), fThreshhold ); float v3 = NoisyStarField( floorSample + vec2( 1.0, 0.0 ), fThreshhold ); float v4 = NoisyStarField( floorSample + vec2( 1.0, 1.0 ), fThreshhold ); float StarVal = v1 * ( 1.0 - fractX ) * ( 1.0 - fractY ) + v2 * ( 1.0 - fractX ) * fractY + v3 * fractX * ( 1.0 - fractY ) + v4 * fractX * fractY; return StarVal; } vec2 getPoint(vec2 id, vec2 offset) { return sin(hash22(id + offset) * time * 1.5 + hash22(id + offset)) * 0.4 + offset; } vec3 SkyColor( vec3 rd ) { #if 0 // Cube Map // hide cracks in cube map rd -= sign(abs(rd.xyz)-abs(rd.yzx))*.01; vec3 ldr = texture( iChannel0, rd ).rgb; // fake hdr vec3 hdr = 1.0/(1.2-ldr) - 1.0/1.2; return hdr; #else // Black return vec3(0,0,0); // test 1 UV //return rd * 0.5 + 0.5; //return vec3(0,0.5,0); /* // plexus vec2 uv = vec2(atan(rd.z/rd.x), atan(length(rd.xz)/rd.y)) / M_PI; uv += vec2(10.); uv = abs(uv); vec2 suv = uv * 50.; vec2 id = floor(suv) - 0.5; vec2 fuv = fract(suv) - 0.5; vec2 pp = getPoint(id, vec2(0)); vec3 col = vec3(0); for(int x = -1; x <= 1; x++){ for(int y = -1; y <= 1; y++){ vec2 pos = getPoint(id, vec2(x,y)); //sin(hash22(id + vec2(x,y)) * iTime * 1.5) * 0.4 + vec2(x,y); float d = 1.0 / pow(length(fuv - pos), 1.75) * 0.001; col += d; float len = smoothstep(1.0,0.5,length(pp - pos)); col += smoothstep(0.025,0.001,sdSegment(fuv, pos, pp)) * len; } } return col * sinebow(uv.x); */ // fake unity default sky-box //vec3 ground = mix(vec3(0.25,0.4,0.8), vec3(0.2,0.15,0.15), saturate(abs(rd.y) * 25.0)); //vec3 sky = mix(vec3(0.25,0.4,0.8), vec3(0.001, 0.15, 1.), saturate(abs(rd.y) * 10.0)); //return rd.y < 0. ? ground :sky; /* // Starfield float x = atan(rd.z / rd.x); float y = acos(rd.y); return vec3(StableStarField(vec2(x,y) * 1000., 0.97 )); */ // wave z //vec2 uv = vec2(atan(rd.z/rd.x), atan(length(rd.xz)/rd.y)) / M_PI; //return vec3(saturate(uv),0); //return vec3(1,0,0) * saturate(sin(rd.z *100.- iTime * 10.)); //return sinebow(rd.z * 5.- iTime * 3.) * 0.25; //return smoothstep(0.01,0.,mod(rd.z - iTime * 0.1, 0.1))*vec3(0.05,0.2,0.5); #endif } //------------------------------------------------------------------------------ // BRDF //------------------------------------------------------------------------------ float pow5(float x) { float x2 = x * x; return x2 * x2 * x; } float D_GGX(float linearRoughness, float NoH, const vec3 h) { // Walter et al. 2007, "Microfacet Models for Refraction through Rough Surfaces" float oneMinusNoHSquared = 1.0 - NoH * NoH; float a = NoH * linearRoughness; float k = linearRoughness / (oneMinusNoHSquared + a * a); float d = k * k * (1.0 / M_PI); return d; } float V_SmithGGXCorrelated(float linearRoughness, float NoV, float NoL) { // Heitz 2014, "Understanding the Masking-Shadowing Function in Microfacet-Based BRDFs" float a2 = linearRoughness * linearRoughness; float GGXV = NoL * sqrt((NoV - a2 * NoV) * NoV + a2); float GGXL = NoV * sqrt((NoL - a2 * NoL) * NoL + a2); return 0.5 / (GGXV + GGXL); } vec3 F_Schlick(const vec3 f0, float VoH) { // Schlick 1994, "An Inexpensive BRDF Model for Physically-Based Rendering" return f0 + (vec3(1.0) - f0) * pow5(1.0 - VoH); } float F_Schlick(float f0, float f90, float VoH) { return f0 + (f90 - f0) * pow5(1.0 - VoH); } float Fd_Burley(float linearRoughness, float NoV, float NoL, float LoH) { // Burley 2012, "Physically-Based Shading at Disney" float f90 = 0.5 + 2.0 * linearRoughness * LoH * LoH; float lightScatter = F_Schlick(1.0, f90, NoL); float viewScatter = F_Schlick(1.0, f90, NoV); return lightScatter * viewScatter * (1.0 / M_PI); } float Fd_Lambert() { return 1.0 / M_PI; } //------------------------------------------------------------------------------ // Indirect lighting //------------------------------------------------------------------------------ vec3 Irradiance_SphericalHarmonics(const vec3 n) { // Irradiance from "Ditch River" IBL (http://www.hdrlabs.com/sibl/archive.html) return max( vec3( 0.754554516862612, 0.748542953903366, 0.790921515418539) + vec3(-0.083856548007422, 0.092533500963210, 0.322764661032516) * (n.y) + vec3( 0.308152705331738, 0.366796330467391, 0.466698181299906) * (n.z) + vec3(-0.188884931542396, -0.277402551592231, -0.377844212327557) * (n.x) , 0.0); } vec2 PrefilteredDFG_Karis(float roughness, float NoV) { // Karis 2014, "Physically Based Material on Mobile" const vec4 c0 = vec4(-1.0, -0.0275, -0.572, 0.022); const vec4 c1 = vec4( 1.0, 0.0425, 1.040, -0.040); vec4 r = roughness * c0 + c1; float a004 = min(r.x * r.x, exp2(-9.28 * NoV)) * r.x + r.y; return vec2(-1.04, 1.04) * a004 + r.zw; } vec3 calcAmb(vec3 pos, vec3 rayDir, vec3 normal, vec3 lightPos, vec3 lightColor, surface surf) { vec3 color = vec3(0); vec3 lightDir = normalize(lightPos); vec3 viewDir = normalize(-rayDir); vec3 halfV = normalize(viewDir + lightDir); //vec3 r = normalize(reflect(rayDir, normal)); float NoV = abs(dot(normal, viewDir)) + 1e-5; float NoL = saturate(dot(normal, lightDir)); float NoH = saturate(dot(normal, halfV)); float LoH = saturate(dot(lightDir, halfV)); float indirectIntensity = 0.64; vec3 albedo = surf.albedo.rgb; float roughness = surf.roughness; float metallic = surf.metalness; float linearRoughness = roughness * roughness; vec3 diffuseColor = (1.0 - metallic) * albedo.rgb; vec3 f0 = 0.04 * (1.0 - metallic) + albedo.rgb * metallic; float attenuation = shadow(pos, lightDir); // specular BRDF float D = D_GGX(linearRoughness, NoH, halfV); float V = V_SmithGGXCorrelated(linearRoughness, NoV, NoL); vec3 F = F_Schlick(f0, LoH); vec3 Fr = (D * V) * F; // diffuse BRDF vec3 Fd = diffuseColor * Fd_Burley(linearRoughness, NoV, NoL, LoH); color = Fd + Fr; color *= (attenuation * NoL) * lightColor; // diffuse indirect vec3 indirectDiffuse = Irradiance_SphericalHarmonics(normal) * Fd_Lambert(); vec3 ibl = diffuseColor * indirectDiffuse; color += ibl * indirectIntensity; color += surf.emission.rgb; return color; } //------------------------------------------------------------------------------ // Tone mapping and transfer functions //------------------------------------------------------------------------------ vec3 Tonemap_ACES(const vec3 x) { // Narkowicz 2015, "ACES Filmic Tone Mapping Curve" const float a = 2.51; const float b = 0.03; const float c = 2.43; const float d = 0.59; const float e = 0.14; return (x * (a * x + b)) / (x * (c * x + d) + e); } vec3 OECF_sRGBFast(const vec3 linear) { return pow(linear, vec3(1.0 / 2.2)); } /////////////// vec3 fresnelSchlick_roughness(vec3 F0, float cosTheta, float roughness) { return F0 + (max(vec3(1.0 - roughness), F0) - F0) * pow(1.0 - cosTheta, 5.0); } // Unreal Engine Ambient BRDF Approx // https://www.unrealengine.com/en-US/blog/physically-based-shading-on-mobile?lang=en-US vec3 EnvBRDFApprox( vec3 SpecularColor, float Roughness, float NoV ) { const vec4 c0 = vec4( -1, -0.0275, -0.572, 0.022 ); const vec4 c1 = vec4( 1, 0.0425, 1.04, -0.04 ); vec4 r = Roughness * c0 + c1; float a004 = min( r.x * r.x, exp2( -9.28 * NoV ) ) * r.x + r.y; vec2 AB = vec2( -1.04, 1.04 ) * a004 + r.zw; return SpecularColor * AB.x + AB.y; } vec3 calcAmbient(vec3 pos, vec3 albedo, float metalness, float roughness, vec3 N, vec3 V, float t) { vec3 F0 = mix(vec3(0.04), albedo, metalness); vec3 F = fresnelSchlick_roughness(F0, max(0.0, dot(N, V)), roughness); vec3 kd = mix(vec3(1.0) - F, vec3(0.0), metalness); float aoRange = t/20.0; float occlusion = max( 0.0, 1.0 - map( pos + N*aoRange ).dist/aoRange ); occlusion = min(exp2( -.8 * pow(occlusion, 2.0) ), 1.0); vec3 ambientColor = vec3(0.5); vec3 diffuseAmbient = kd * albedo * ambientColor * min(1.0, 0.75+0.5*N.y) * 3.0; vec3 R = reflect(-V, N); vec3 col = mix(vec3(0.5) * pow( 1.0-max(-R.y,0.0), 4.0), ambientColor, pow(roughness, 0.5)); vec3 ref = EnvBRDFApprox(F0, roughness, max(dot(N, V), 0.0)); vec3 specularAmbient = col * ref; diffuseAmbient *= occlusion; return vec3(diffuseAmbient + specularAmbient); } float sdAirLine(vec3 p) { const float w = 0.0125; float angle = -radians(30.); p.y += 0.4; float air = sdCapsule(p, vec3(0), vec3(0., -1.0, 0), w); air = min(air, sdJoint3DSphere(p, 0.3, angle, w)); mat4 mat = joint3DMatrix(0.3, angle); p = (mat * vec4(p, 1.0)).xyz; air = min(air, sdJoint3DSphere(p, 0.25, radians(30.), w)); mat = joint3DMatrix(0.25, -angle); p = (mat * vec4(p, 1.0)).xyz; return min(air, sdCapsule(p, vec3(0, 0, 0), vec3(0., 1.0, 0), w)); } #define fog_density(x) (1.0 - saturate(exp2(10.0 - (x) * 1.5))) float densitycalc(vec3 p){ float air = MAX_DIST; float ad = M_PI / 5.0; for(int i = 0; i < 6; i++){ vec3 q = p; q = rotate(q, -RAD90, vec3(1,0,0)); q = rotate(q, ad * float(i), vec3(0,1,0)); q.x += 0.1; air = min(air, sdAirLine(q)); } return fbm(p * (50,50,15.) *vec3(1,1,1)+ vec3(0, 0, time * -15.)) - min(air, 1.) * (20.); } surface rayCast(vec3 pos, vec3 dir, float dist) { const vec3 boxPos = vec3(0); const vec3 boxSize = vec3(0.4, 0.5, 2.); vec2 sd =GetIntersectBox(pos, dir, boxPos, boxSize); surface result = SURF_NOHIT(MAX_DIST); if((sd.y >= 0.) && (dist > sd.x) && (sd.x < sd.y)) { const float step = 4.0 / float(MAX_RAYCAST); const float lightStep = 4.0 / float(MAX_RAYCAST_L); float start = max(0., sd.x) - step; pos = pos + dir * start; float t = hash13(pos * 250.) * 0.01; float alpha = 0.; float transmittance = 1.0; float absorption = 25.; for(int i = 0; i < MAX_RAYCAST; i++){ t += step; vec3 pp = pos + dir * t; if((t >= sd.y)||(start + t >= dist)) break; vec3 q = pp - boxPos; float density = densitycalc(q); if(density > 0.0){ float dd = density * step; transmittance *= 1.0 - dd * absorption; if(transmittance < 0.01) break; alpha += 20. * dd * transmittance; result.albedo.rgb += vec3(0.5,0.65,0.85) * (150. * dd * transmittance); } } result.emission.rgb *= max(0., alpha); result.albedo.a = saturate(alpha); result.dist = alpha > 0. ? t : dist; result.isHit = alpha > 0. ? true : false; } return result; } surface traceRay(in vec3 origin, in vec3 direction, float dist, out vec3 pos) { float t = 0.0; pos = origin; int count = 0; surface hit; float d; //surface volume = SURF_NOHIT(MAX_DIST); for (int i = 0; i < MAX_MARCH; i++) { hit = map(pos); d = hit.dist; if (d <= EPS || d >= MAX_DIST) { break; } #ifdef ENABLE_GRID_BOUNDARY // grid overshoot check vec2 iBox = GetIntersectBox(pos, direction, floor(pos + 0.5), vec3(0.5)); if(iBox.x < iBox.y && iBox.y > 0.0 && iBox.y < d) { d = iBox.y + EPS; } #endif t += d; pos = origin + direction * t; count++; } hit.dist = t; hit.count = count; pos = origin + direction * t; vec3 sky = SkyColor(direction); if(hit.isHit) { vec3 nor = norm(pos); // Calc Ambient hit.albedo.rgb = calcAmb(pos, direction, nor, lightPos, lightColor, hit); // Exponential distance fog hit.albedo.rgb = mix(hit.albedo.rgb, sky, fog_density(hit.dist + dist)); } /* // raycast surface volume = rayCast(origin, direction, t); if(volume.isHit) { // Calc Ambient //volume.albedo.rgb = calcAmb(pos, direction, nor, lightPos, lightColor, volume); // Exponential distance fog volume.albedo.rgb = mix(volume.albedo.rgb, sky, fog_density(volume.dist + dist)); hit.albedo.rgb = mix(hit.albedo.rgb, volume.albedo.rgb, volume.albedo.a); hit.albedo.a = max(hit.albedo.a, volume.albedo.a); hit.albedo.rgb = mix(sky, hit.albedo.rgb, hit.albedo.a); // Exponential distance fog volume.emission.rgb = mix(volume.emission.rgb, sky, fog_density(volume.dist + dist)); hit.albedo.rgb += volume.emission; //hit.albedo.rgb += volume.albedo.rgb; } */ if(d <= EPS){ hit.isHit = true; return hit; //return surface(hit.dist, hit.albedo, hit.emission, hit.roughness, hit.metalness, count, hit.isTransparent, hit.refractPower, true); }else{ hit.isHit = false; return hit; //return surface(hit.dist, hit.albedo, hit.emission, hit.roughness, hit.metalness, count, hit.isTransparent, hit.refractPower, false); } } vec3 render(vec3 p, vec3 ray, vec2 uv) { vec3 pos; surface mat = traceRay(p, ray, 0., pos); //pos = p + mat.dist * ray; //return materialize(pos, ray, mat, uv); vec3 col = vec3(0,0,0); vec3 sky = SkyColor(ray); if (!mat.isHit && mat.albedo.a < EPS) { col = sky; } else { col = mat.albedo.rgb; #ifdef ENABLE_REFLECTION float metalness = mat.metalness; float dist = mat.dist; if(mat.isHit){ // reflection for(int i = 0; i < 1; i++) { vec3 nor = norm(pos); //nor = normalize(nor + hash33(pos) * mat.roughness * 0.05); bool isIncoming = dot(ray, nor) < 0.0; vec3 orientingNormal = isIncoming ? nor : -nor; bool isTotalReflection = false; if(mat.isTransparent){ // refract //float nnt = isIncoming ? 1.0 / mat.refractPower : mat.refractPower; //float nnt = 1.0 / mat.refractPower; float nnt = isIncoming ? 1.0 / mat.refractPower : 1.0; ray = refract(ray, orientingNormal, nnt); pos = pos - orientingNormal * OFFSET; isTotalReflection = (length(ray) <= 0.9); } if(isTotalReflection || !mat.isTransparent) { // reflect ray = reflect(ray, orientingNormal); pos = pos + orientingNormal * OFFSET; } mat = traceRay(pos, ray, dist, pos); dist += mat.dist; col += mat.albedo.rgb * metalness; //col += result; metalness *= mat.metalness; if(!mat.isHit || metalness < 0.0001) break; } } #endif } // Glow //col += (sinebow(iTime * 10.) +vec3(0.1))* pow((mat.z + 10.) / float(MAX_MARCH), 3.5); // Tone mapping col = Tonemap_ACES(col); // Gamma compression col = OECF_sRGBFast(col); return col; } mat3 camera(vec3 ro, vec3 ta, float cr ) { vec3 cw = normalize(ta - ro); vec3 cp = vec3(sin(cr), cos(cr),0.); vec3 cu = normalize( cross(cw,cp) ); vec3 cv = normalize( cross(cu,cw) ); return mat3( cu, cv, cw ); } void main(void) { vec2 p = (gl_FragCoord.xy * 2.0 - resolution.xy) / min(resolution.x, resolution.y); float y = 0.06; float r = 0.65; float distortionPower = sin(time * 0.05 * M_PI2); float theta = RAD90 + noise(vec2(p.x * 3., time * 0.1 * M_PI)) * RAD90 * distortionPower; float phi = noise(vec2(p.y * 3., time * 0.1 * M_PI)) * RAD90 * distortionPower; vec3 ro = vec3(cos(theta) * r, y + sin(phi), -sin(theta) * r); vec3 ta = vec3(0., y, 0); mat3 c = camera(ro, ta, 0.0); vec3 ray = c * normalize(vec3(p, 3.5)); vec3 col = render(ro, ray, gl_FragCoord.xy); gl_FragColor = vec4(col,1.0); }