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 USE_BRDF_1 //#define USE_RAYCAST #define ENABLE_FOG //#if HW_PERFORMANCE==0 #define AA 1 //#else //#define AA 2 //#endif #define saturate(x) clamp(x, 0.0, 1.0) #define MAX_MARCH 200 #define MAX_RAYCAST 100 #define MAX_RAYCAST_L 6 #define MAX_DIST 100. #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-3; const float EPS_N = 1e-4; const float OFFSET = EPS * 10.0; const float CAMERA_SPEED = 0.1; //const vec3 sunDir = normalize(vec3(-1,1,-0.25)); const vec3 lightPos = vec3(0.50, 0.8, -0.5); const vec3 lightColor = vec3(0.98, 0.92, 0.89) * 4.0; //const vec3 lightColor = vec3(0.3, 0.6, 0.9) * 2.0; struct surface { float dist; vec4 albedo; vec3 emission; float roughness; float metalness; int count; bool isTransparent; float refractPower; bool isHit; }; vec3 sinebow(float h) { vec3 r = sin((.5-h)*M_PI + vec3(0,M_PI03,M_PI06)); return r*r; } #define COLOR_SEA (vec3(0,0.05,0.1)) // 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_PLANETEX(float d, vec3 pos) { vec4 col = vec4(texture(iChannel0, vec2(pos.xz)).rgb, 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)) #define SURF_MIRROR(d) (surface(d, vec4(0.5,0.5,0.5,1), vec3(0), 0.3, 0.8, 0, false, 2.2, true)) #define SURF_SEA(d) (surface(d, vec4(COLOR_SEA,0), vec3(0), 0.2, 0.5, 0, true, 1.53, true)) /* surface SURF_WATERMELON(float d, vec3 pos, vec3 center) { pos = center - pos; vec2 uv = vec2(atan(pos.z,pos.x), pos.y); uv.x = abs(uv.x)-M_PI/5.; vec2 guv = fract(uv*1.5)-0.5; vec2 id = floor(uv*1.5)-0.5; float mask = step(abs(guv.x),0.25+sin((uv.y+id.x)*200.)*0.05); vec4 col = vec4(mix (vec3(0.05,0.3,0.025),vec3(0.025, 0.05, 0.025), mask), 1); return surface(d, col, vec3(0), 0.2, 0.001, 0, false, 2.2, true); } */ //#define SURF_LOAD(d) (surface(d, vec4(0.2,0.2,0.2,1), vec3(0), 0.0001, 0.01, 0, false, 0.0, true)) surface SURF_LOAD(float d, vec3 p, vec3 cp) { float len = length(cp - p); vec3 col = mix(vec3(0), vec3(0,0.4,1), smoothstep(0.4, 0.41, len)); return surface(d, vec4(0.2,0.2,0.2,1), col, 0.01, 0.5, 0, false, 0.5, true); } //#define SURF_DESERT(d) (surface(d, vec4(0.8,0.5,0.4,1), vec3(0), 0.0001, 0.01, 0, false, 0.0, true)) #define SURF_SHARI(d) (surface(d, vec4(0.9,0.9,0.9,1), vec3(0), 0.3, 0.1, 0, false, 1.1, true)) #define SURF_NETA(d, col) (surface(d, vec4(col,1), vec3(0), 0.01, 0.2, 0, false, 1.1, true)) #define SURF_PUMPKIN(d) (surface(d, vec4(0.9,0.3,0.1,1), vec3(0), 0.5, 0.0, 0, false, 1.1, true)) #define SURF_PUMPKIN_STALK(d) (surface(d, vec4(0.5,0.9,0.2,1), vec3(0), 0.5, 0.0, 0, false, 1.1, true)) /* //================================================================== // Catmull-Rom Spline // https://www.shadertoy.com/view/ls3SRr //================================================================== const int POINT_COUNT = 8; struct CtrlPts { vec3 p[POINT_COUNT]; }; vec3 PointArray(int i, CtrlPts ctrlPts) { //i = int(mod(float(i), float(POINT_COUNT))); //return ctrlPts.p[i]; if(i==0 || i==POINT_COUNT ) return ctrlPts.p[0]; if(i==1 || i==POINT_COUNT+1) return ctrlPts.p[1]; if(i==2 || i==POINT_COUNT+2) return ctrlPts.p[2]; if(i==3) return ctrlPts.p[3]; if(i==4) return ctrlPts.p[4]; if(i==5) return ctrlPts.p[5]; if(i==6) return ctrlPts.p[6]; if(i==7) return ctrlPts.p[7]; return vec3(0); } vec3 catmullRom(float fTime, CtrlPts ctrlPts) { float t = fTime; const float n = float(POINT_COUNT); int idxOffset = int(t*n); vec3 p1 = PointArray(idxOffset,ctrlPts); vec3 p2 = PointArray(idxOffset+1,ctrlPts); vec3 p3 = PointArray(idxOffset+2,ctrlPts); vec3 p4 = PointArray(idxOffset+3,ctrlPts); //For some reason, fract(t*n) returns garbage on my machine with small values of t. //return fract(n*t); //Using this below yields the same results, minus the glitches. t *= n; t = (t-float(int(t))); //A classic catmull-rom //e.g. //http://steve.hollasch.net/cgindex/curves/catmull-rom.html //http://www.lighthouse3d.com/tutorials/maths/catmull-rom-spline/ vec3 val = 0.5 * ((-p1 + 3.*p2 -3.*p3 + p4)*t*t*t + (2.*p1 -5.*p2 + 4.*p3 - p4)*t*t + (-p1+p3)*t + 2.*p2); return val; } float distanceToLineSeg(vec3 p, vec3 a, vec3 b, out vec3 e, out vec3 forward) { //e = capped [0,1] orthogonal projection of ap on ab // p // / // / // a--e-------b vec3 ap = p-a; vec3 ab = b-a; e = a+clamp(dot(ap,ab)/dot(ab,ab),0.0,1.0)*ab; forward = normalize(a-b); return length(p-e); } float sdCatmullRomSpline(vec3 p, CtrlPts ctrlPts, out vec3 cp) { const float maxDist = 10000.0; float bestX = 0.0; //Primary (rough) estimate : decent results with 2 lines per control point (faint blue lines) const int iter = POINT_COUNT*2+1; //const int iter = POINT_COUNT*1+1; //<-Faster //const int iter = POINT_COUNT*3+1; //<-Nicer float primarySegLength = 1.0/float(iter-1); vec3 pA = catmullRom(0., ctrlPts); float minRoughDist = maxDist; float x = 0.0; vec3 e, fwd; for(int i=0; i < iter; ++i) { vec3 pB = catmullRom(x, ctrlPts); float d = distanceToLineSeg(p, pA, pB, e, fwd); pA = pB; if(dsc.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 sdCappedCylinder( vec3 p, float h, float r ) { vec2 d = abs(vec2(length(p.xz),p.y)) - vec2(h,r); return min(max(d.x,d.y),0.0) + length(max(d,0.0)); } 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; } float sdJoint3DSphere( in vec3 p, in float l, in float a, in float w1, float w2) { if( abs(a)<0.001 ) { return length(p-vec3(0,clamp(p.y,0.0,l),0))-mix(w2, w1, p.y / l); } 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)-mix(w2, w1, (p.y / l)); } // 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 opU( float d1, float d2 ) { return min(d1,d2); } float opS( float d1, float d2 ) { return max(-d1,d2); } float opI( float d1, float d2 ) { return max(d1,d2); } float smin( 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); } vec4 quat_from_axis_angle(vec3 axis, float angle) { vec4 qr; //float half_angle = (angle * 0.5) * 3.14159 / 180.0; float half_angle = (angle * 0.5); qr.x = axis.x * sin(half_angle); qr.y = axis.y * sin(half_angle); qr.z = axis.z * sin(half_angle); qr.w = cos(half_angle); return qr; } vec4 quat_conj(vec4 q) { return vec4(-q.x, -q.y, -q.z, q.w); } vec4 quat_mult(vec4 q1, vec4 q2) { vec4 qr; qr.x = (q1.w * q2.x) + (q1.x * q2.w) + (q1.y * q2.z) - (q1.z * q2.y); qr.y = (q1.w * q2.y) - (q1.x * q2.z) + (q1.y * q2.w) + (q1.z * q2.x); qr.z = (q1.w * q2.z) + (q1.x * q2.y) - (q1.y * q2.x) + (q1.z * q2.w); qr.w = (q1.w * q2.w) - (q1.x * q2.x) - (q1.y * q2.y) - (q1.z * q2.z); return qr; } vec3 rotate_vertex_position(vec3 position, vec3 axis, float angle) { vec4 qr = quat_from_axis_angle(axis, angle); vec4 qr_conj = quat_conj(qr); vec4 q_pos = vec4(position.x, position.y, position.z, 0); vec4 q_tmp = quat_mult(qr, q_pos); qr = quat_mult(q_tmp, qr_conj); return vec3(qr.x, qr.y, qr.z); } vec2 foldRotate(in vec2 p, in float s, out float index) { float a = M_PI / s - atan(p.x, p.y); float n = M_PI2 / s; index = floor(a / n); a = index * 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 sdMouseTunnel(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(p - vec3(0,0,0.2), vec3(0.08, 0.01 * ms,2)); } 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 opU(opU(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(1e5); 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 = smin(d, d1, 0.1); vec3 mxp = vec3(-abs(p.x), p.yz); // ear float d2 = sdEar(mxp); d = opU(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 = opU(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); } */ surface sdColorBoze(vec3 p, vec3 sc, float ms, vec3 color) { surface result = SURF_NOHIT(1e5); 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 = smin(d, d1, 0.1); vec3 mxp = vec3(-abs(p.x), p.yz); // ear float d2 = sdEar(mxp); d = opU(d, d2); surface head = SURF_FACE(d); head.albedo.rgb = color; // 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 = opU(eye.dist, d9); // integration mouse = opU(eye, mouse); result = opS(mouse, head); result = opU(cheep, result); result.dist *= minsc; return result; } #define LEG_X 0.05 #define LEG_WIDTH1 0.05 #define LEG_WIDTH2 0.025 #define LEG_WIDTH3 0.045 #define ARM_X1 0.18 #define ARM_X2 0.2 #define ARM_WIDTH1 0.05 #define ARM_WIDTH2 0.025 #define ARM_WIDTH3 0.03 /* void calcArm(out vec3 a0, out vec3 a1, out vec3 a2, float spd, float flip, float h) { //vec3 n = noised(vec2(330. + spd * 0.97 + 578.4516 * flip, spd * flip)); vec3 n = vec3(sin(spd * 0.97+ 578.4516 * flip), cos(spd * 0.75* flip), sin(spd * flip + RAD90)); float r = n.z * 0.15 + 0.15; float theta = (n.x * 0.5 + 0.5) * RAD90; float phi = (n.y * 0.5 + 0.5) * RAD90; a0 = vec3(ARM_X1 * flip, 0.9-h, 0.); a2 = vec3(ARM_X2 * flip + sin(theta) * cos(phi) * r * flip, 0.75 + cos(n.y * M_PI2) * r-h, -sin(theta) * sin(phi) * r); a1 = solve(a0, a2, 0.25, 0.15, vec3(0.5,0,0.5 * flip)); } surface sdBozeFullBody(vec3 p) { surface result = SURF_NOHIT(0.); float spd = iTime * 2.5; // leg //vec3 n1 = noised(vec2(spd, spd * 0.75)); vec3 n1 = vec3(sin(spd), cos(spd * 0.75), sin(spd + M_PI)); float r1 = n1.z * 0.25 + 0.25; vec3 ll2 = vec3(LEG_X + sin(n1.y * M_PI) * cos(n1.x * M_PI) * r1, cos(n1.y * M_PI) * 0.3, sin(n1.y * M_PI) * sin(n1.x * M_PI) * r1); //vec3 n2 = noised(vec2(-spd * 0.75, spd)); vec3 n2 = vec3(cos(spd), sin(spd * 0.75), cos(spd + RAD90)); float r2 = n2.z * 0.25 + 0.25; vec3 rl2 = vec3(-LEG_X + sin(n2.y * M_PI) * cos(n2.x * M_PI) * r2, cos(n2.y * M_PI) * 0.3, sin(n2.y * M_PI) * sin(n2.x * M_PI) * r2); float h = min(ll2.y, rl2.y); vec3 ll0 = vec3(LEG_X, 0.5-h, 0.); vec3 ll1 = solve(ll0, ll2, 0.25, 0.25, vec3(-1,0,0)); vec3 rl0 = vec3(-LEG_X, 0.5-h, 0.); vec3 rl1 = solve(rl0, rl2, 0.25, 0.25, vec3(-1,0,0)); //result = SURF_MIRROR(sdCapsule(p, ll0, ll1, LEG_WIDTH1, LEG_WIDTH2)); //result = opSU(result, SURF_MIRROR(sdCapsule(p, ll1, ll2, LEG_WIDTH2, LEG_WIDTH3)), 0.01); float body = sdCapsule(p, ll0, ll1, LEG_WIDTH1, LEG_WIDTH2); //body = smin(body, sdCapsule(p, ll1, ll2, LEG_WIDTH2, LEG_WIDTH3), 0.01); body = min(body, sdCapsule(p, ll1, ll2, LEG_WIDTH2, LEG_WIDTH3)); //result = opU(result, SURF_MIRROR(sdCapsule(p, rl0, rl1, LEG_WIDTH1, LEG_WIDTH2))); //result = opSU(result, SURF_MIRROR(sdCapsule(p, rl1, rl2, LEG_WIDTH2, LEG_WIDTH3)), 0.01); body = min(body, sdCapsule(p, rl0, rl1, LEG_WIDTH1, LEG_WIDTH2)); //body = smin(body, sdCapsule(p, rl1, rl2, LEG_WIDTH2, LEG_WIDTH3), 0.01); body = min(body, sdCapsule(p, rl1, rl2, LEG_WIDTH2, LEG_WIDTH3)); // body //result = opSU(result, SURF_MIRROR(sdRoundBox(p - vec3(0,0.6 - h,0), vec3(0.125,0.2,0.0),0.05)), 0.05); //result = opSU(result, SURF_MIRROR(sdRoundBox(p - vec3(0,0.8 - h,-0.0125), vec3(0.15,0.1,0.0),0.075)), 0.05); //body = smin(body, sdRoundBox(p - vec3(0,0.6 - h,0), vec3(0.125,0.2,0.0),0.05), 0.05); //body = smin(body, sdRoundBox(p - vec3(0,0.8 - h,-0.0125), vec3(0.15,0.1,0.0),0.075), 0.05); body = min(body, sdRoundBox(p - vec3(0,0.6 - h,0), vec3(0.125,0.2,0.0),0.05)); body = min(body, sdRoundBox(p - vec3(0,0.8 - h,-0.0125), vec3(0.15,0.1,0.0),0.075)); // left arm vec3 la0, la1, la2; calcArm(la0, la1, la2, spd, 1., h); //result = opSU(result, SURF_MIRROR(sdCapsule(p, la0, la1, ARM_WIDTH1, ARM_WIDTH2)), 0.025); //result = opSU(result, SURF_MIRROR(sdCapsule(p, la1, la2, ARM_WIDTH2, ARM_WIDTH3)), 0.01); //body = smin(body, sdCapsule(p, la0, la1, ARM_WIDTH1, ARM_WIDTH2), 0.025); //body = smin(body, sdCapsule(p, la1, la2, ARM_WIDTH2, ARM_WIDTH3), 0.01); body = min(body, sdCapsule(p, la0, la1, ARM_WIDTH1, ARM_WIDTH2)); body = min(body, sdCapsule(p, la1, la2, ARM_WIDTH2, ARM_WIDTH3)); // right arm vec3 ra0, ra1, ra2; calcArm(ra0, ra1, ra2, spd, -1., h); //result = opSU(result, SURF_MIRROR(sdCapsule(p, ra0, ra1, ARM_WIDTH1, ARM_WIDTH2)), 0.025); //result = opSU(result, SURF_MIRROR(sdCapsule(p, ra1, ra2, ARM_WIDTH2, ARM_WIDTH3)), 0.01); //body = smin(body, sdCapsule(p, ra0, ra1, ARM_WIDTH1, ARM_WIDTH2), 0.025); //body = smin(body, sdCapsule(p, ra1, ra2, ARM_WIDTH2, ARM_WIDTH3), 0.01); body = min(body, sdCapsule(p, ra0, ra1, ARM_WIDTH1, ARM_WIDTH2)); body = min(body, sdCapsule(p, ra1, ra2, ARM_WIDTH2, ARM_WIDTH3)); result = SURF_MIRROR(body); // head vec3 b = p; b = rotate(b, M_PI, vec3(0,1,0)); b.y -= 1.01-h; result = opSU(result, sdBoze(b, vec3(1), 1.), 0.02); return result; } surface sdWatermelonBoze(vec3 p, vec3 sc, float ms) { //surface result = sdBoze(p, vec3(1), 1.); surface result = SURF_NOHIT(1e5); 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 = smin(d, d1, 0.1); vec3 mxp = vec3(-abs(p.x), p.yz); // ear float d2 = sdEar(mxp); d = opUnion(d, d2); // outer skin surface head = SURF_WATERMELON(d, p, vec3(0)); if(head.dist < 0.){ if(head.dist > -0.01){ // inner skin head.albedo = mix(head.albedo, vec4(1,1,0.5,1), smoothstep(0., 0.01, abs(head.dist))); }else{ // flesh meat float n = fbm(p * 25.); head.albedo = mix(vec4(1,1,0.5,1), vec4(1,0,0,1) + n * 0.2, smoothstep(0.01, 0.015, abs(head.dist))); // seed const float mb = M_PI2 / 32.; vec3 ps = p; ps.y -= 0.025; float b = mod(atan(ps.y, ps.z), mb) - 0.5 * mb; float c = smoothstep(.15, .18, length(vec2(b*12.,abs(head.dist)*15.0 - 0.5))); head.roughness = mix(0.01, 0.1, c); head.albedo = mix(vec4(0.02), head.albedo, c); } } // 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); d4 = min(d4, d6); // eyebrows float d9 = sdEyeBrow(mxp); //eye.dist = opUnion(eye.dist, d9); d4 = min(d4, d9); // cheep float d7 = sdCheep(mxp); //surface cheep = SURF_BLACK(d7); head.dist = min(head.dist, d7); head.dist = max(-d4, head.dist); // integration //mouse = opU(eye, mouse); //result = opS(mouse, head); //result = opU(cheep, result); result = head; result.dist *= minsc; return result; } */ surface sdBozeGate(vec3 p, vec3 sc, float ms) { surface result = SURF_NOHIT(1e5); 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 = smin(d, d1, 0.1); vec3 mxp = vec3(-abs(p.x), p.yz); // ear float d2 = sdEar(mxp); d = opU(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 = sdMouseTunnel(p, ms); surface mouse = SURF_MOUSE(d6); // cheep float d7 = sdCheep(mxp); surface cheep = SURF_CHEEP(d7); // eyebrows float d9 = sdEyeBrow(mxp); eye.dist = opU(eye.dist, d9); // integration mouse = opU(eye, mouse); result = opS(mouse, head); result = opU(cheep, result); result.dist *= minsc; return result; } // Base Pumpkin Distance function @ P_Malin // https://www.shadertoy.com/view/MdBXR3 float sdPumpkinBody(vec3 p, float radius, float height) { float fAngle1 = atan(p.x, p.z); float fSin = sin(fAngle1 * 16.0); fSin = 1.0 - sqrt(abs(fSin)); vec3 sc = 1.0 + fSin * vec3(0.05, 0.025, 0.05); p *= sc; p.y *= height + 0.5 * (radius - length(p.xz)) / radius; return length(p) - radius; } surface sdPumpkinBoze(vec3 p, float ms) { surface result = SURF_NOHIT(1e5); float fSphereRadius = 0.2; vec3 vOffset = p; float fFirstDist = length(vOffset); //float fOutDist; if(fFirstDist < 1.5) { // body float bottom = sdPumpkinBody(vOffset, fSphereRadius, 1.75); float top = sdPumpkinBody(vOffset + vec3(0, -0.075, 0), fSphereRadius * 0.65, 0.5); result = SURF_PUMPKIN(smin(bottom, top, 0.05)); // stalk(heta) vec3 vStalkOffset = p; vStalkOffset.x += -(vStalkOffset.y - fSphereRadius) * 0.1; float fDist2d = length(vStalkOffset.xz); float fStalkDist = fDist2d - 0.02; fStalkDist = max(fStalkDist, p.y - 0.25 + p.x * 0.2); fStalkDist = max(fStalkDist, -p.y); surface stalk = SURF_PUMPKIN_STALK(fStalkDist); result = opSU(result, stalk, 0.02); vec3 mxp = vec3(-abs(p.x), p.yz); // ear float d2 = sdEar(mxp + vec3(0.01,-0.01,0)); result.dist = smin(result.dist, d2, 0.005); // eye #define eyeZ 0.12 //float d4 = sdCapsule(mxp, vec3(-EYE_SPACE, 0.06, 0.13), vec3(-EYE_SPACE, 0.08, 0.125), 0.0175); float d4 = sdCapsule(mxp, vec3(-EYE_SPACE, 0.06, eyeZ+0.01), vec3(-EYE_SPACE, 0.1, eyeZ), 0.0175); surface eye = SURF_BLACK(d4); // mouse float d6 = sdMouse(p, ms); surface mouse = SURF_MOUSE(d6); // cheep float d7 = sdCheep(mxp + vec3(0,0,-0.015)); surface cheep = SURF_CHEEP(d7); // eyebrows float d9 = sdEyeBrow(mxp); eye.dist = opU(eye.dist, d9); // integration mouse = opU(eye, mouse); result = opS(mouse, result); //result = opU(mouse, result); result = opU(cheep, result); } return result; } ///////////////////////////////////////////////////////////////////////////////////////////////// // End of Mikka Boze ///////////////////////////////////////////////////////////////////////////////////////////////// surface sdSushi(vec3 p, vec3 sc, vec3 col) { surface result = SURF_NOHIT(1e5); float minsc = min(sc.x, min(sc.y, sc.z)); p /= sc; // shari float shari = sdRoundBox(p, vec3(0.75,0.5,1.75), 0.125); result = SURF_SHARI(shari); //float neta = sdRoundBox(p-vec3(0,0.5625,0), vec3(1,0.25,2), 0.05); surface neta = SURF_NETA(sdRoundBox(p-vec3(0,0.5625,0), vec3(1,0.25,2), 0.05), col); result = opU(result, neta); result.dist *= minsc; return result; } //CtrlPts ctrlPts; surface map(vec3 p) { surface result = SURF_NOHIT(1e5); float ms = 1.; // boze //vec3 q = rotate(p, iTime * 0.2, vec3(0,1,0)); //vec3 q = p; //surface boze = sdBoze(q-vec3(0.5,0.0,0), vec3(1), ms); surface pumpkin = sdPumpkinBoze(p, ms); // sushi #define SUSHI_REP_Y 0.2 float r = M_PI2 / 27.; for(int i = 0; i < 3; i++) { float index; float angle = float(i) * r; float yindex = floor((p.y +0.5*SUSHI_REP_Y + time * 0.1) / SUSHI_REP_Y ); vec3 q = rotate(p, angle + time + hash11(yindex * 30.2)*RAD90, vec3(0,1,0)); vec2 sr = foldRotate(q.xz, 9., index); q.y = mod(q.y+0.5*SUSHI_REP_Y + time * 0.1, SUSHI_REP_Y)-0.5 * SUSHI_REP_Y; vec3 sq =vec3(sr.x, q.y - abs(sin(index * 0.85+ time * 5. + angle))*0.05, sr.y -0.35 + sin(hash11(yindex * 13.24) * M_PI2 + time * 3.6 + hash11(index) * 0.6)*0.05); float sp = step(hash11(yindex * 561.817), 0.1); sq = rotate(sq, RAD90 * sp, vec3(1,0,0)); sq = rotate(sq, (time *10.+ angle) * sp, vec3(0,0,1)); // maguro vec3 col1 = mix(vec3(1,0.8,0.9), vec3(0.95,0,0.01), smoothstep(0.0, 0.2, fract(abs(sq.x + sq.y + sq.z)*100.))); // tamago vec3 col2 = vec3(0.9,0.87,0.05); // sake vec3 col3 = mix(vec3(1,0.8,0.7), vec3(0.95,0.3,0.01), smoothstep(0.0, 0.2, fract(abs(sq.x + sq.y + sq.z+2.3)*220.))); vec3 col = (i == 0) ? col1 : (i == 1) ? col2 : col3; surface sushi = sdSushi(sq, vec3(0.025), col); result = opU(result, sushi); } //surface sushi = sdSushi(p + vec3(0.25), vec3(0.1), vec3(1,0,0)); //result = opU(result, sushi); //result = opU(result, boze); result = opU(result, pumpkin); return result; } /* float mapNormal(vec3 p) { surface result; // background float h = sea_octave(p.xz * 0.75, 5.5) * 0.2; //h += sea_octave(p.xz * 100., 0.1) * 0.01; //float gl = noise(p*500.); //h += noise(p*500.) * 0.00075; h += hash12(p.xz*100.) * 0.0002; float sand = abs(p.y - h * length(p.xz*0.5) + 0.2); float dist = sand * 0.5; //result = SURF_DESERT(sand * 0.5); //result.roughness = 0.0001; //result.metalness = 0.1; //result.metalness = saturate(gl*10.); //result.roughness = 0.1; // boze p = rotate(p, M_PI, vec3(0,1,0)); float a = 1. - smoothstep(0., 5., cos(iTime*1.) * 5. + 2.5); vec3 b = p; b.y += (1.-a)*0.1; b.x += 0.15 * a; b = rotate(b, (-RAD90-RAD90*0.25)*a, vec3(0,0,1)); float boze = sdBoze(b, vec3(1), 2.).dist; //surface boze = sdBoze(b, vec3(1), 2.); boze = max(boze, sdBox(b + vec3(0.5, 0.5, 0), vec3(0.5,1,1))); dist = min(boze, dist); //result = opU(result, boze); b = p; b.y += (1.-a)*0.1; b.x -= 0.15 * a; b = rotate(b, (RAD90+RAD90*0.25)*a, vec3(0,0,1)); boze = sdBoze(b, vec3(1), 2.).dist; //boze = sdBoze(b, vec3(1), 2.); boze = max(boze, sdBox(b + vec3(-0.5, 0.5, 0), vec3(0.5,1,1))); dist = min(boze, dist); //result = opU(result, boze); //return result; return dist; } */ #if 0 vec3 norm(vec3 p) { /* vec2 e=vec2(.00001,.0); return normalize(.000001+map(p).dist-vec3(map(p-e.xyy).dist,map(p-e.yxy).dist,map(p-e.yyx).dist)); */ float c=mapNormal(p).dist; float e=1e-3; return normalize(vec3(mapNormal(p+vec3(e,0,0)).dist-c, mapNormal(p+vec3(0,e,0)).dist-c, mapNormal(p+vec3(0,0,e)).dist-c)); } #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); */ /* // inspired by tdhooper and klems - a way to prevent the compiler from inlining map() 4 times // https://iquilezles.org/www/articles/normalsSDF/normalsSDF.htm vec3 n = vec3(0.0); for( int i=0; i<4; i++ ) { vec3 e = 0.5773*(2.0*vec3((((i+3)>>1)&1),((i>>1)&1),(i&1))-1.0); n += e*map(position+0.0005*e).dist; //if( n.x+n.y+n.z>100.0 ) break; } return normalize(n); */ // https://www.shadertoy.com/view/XltyRf vec4 n = vec4(0); for (int i = 0 ; i < 4 ; i++) { vec4 s = vec4(position, 0); s[i] += 0.001; n[i] = map(s.xyz).dist; } return normalize(n.xyz-n.w); } #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); } */ float shadow(in vec3 p, in vec3 l) { float t = 0.15; float t_max = 20.0; float res = 1.0; for (int i = 0; i < 16; ++i) { if (t > t_max) break; float d = map(p + t*l).dist; if (d < 0.01) { return 0.0; } t += d; res = min(res, 1.0 * d / t); } return res; } // --------------------------------------------------- // 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) * iTime * 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); // test 1 UV //return rd * 0.5 + 0.5; // sinebow return sinebow(time*0.5) * 0.1; //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 * 10.; 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 ground = mix(vec3(0.25,0.4,0.8), COLOR_SEA, 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)); vec3 sky = mix(vec3(0.25,0.4,0.8), vec3(0.5, 0.8, 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) * 500., 0.99 )); */ // 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 } #ifdef USE_BRDF_1 //------------------------------------------------------------------------------ // BRDF 1 //------------------------------------------------------------------------------ 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; } #else //------------------------------------------------------------------------------ // BRDF 2 //------------------------------------------------------------------------------ float ndfGGX(float NdotH, float roughness) { float alpha = roughness * roughness; float alphaSq = alpha * alpha; float denom = (NdotH * NdotH) * (alphaSq - 1.0) + 1.0; return alphaSq / (M_PI * denom * denom); } float gaSchlickG1(float theta, float k) { return theta / (theta * (1.0 - k) + k); } float gaSchlickGGX(float NdotL, float NdotV, float roughness) { float r = roughness + 1.0; float k = (r * r) / 8.0; return gaSchlickG1(NdotL, k) * gaSchlickG1(NdotV, k); } vec3 fresnelSchlick_roughness(vec3 F0, float cosTheta, float roughness) { return F0 + (max(vec3(1.0 - roughness), F0) - F0) * pow(1.0 - cosTheta, 5.0); } //surface surf //vec3 shade(vec3 pos, vec3 albedo, float metalness, float roughness, vec3 N, vec3 V, vec3 L, vec3 Lradiance) vec3 shade(vec3 pos, vec3 N, vec3 V, vec3 L, vec3 Lradiance, surface surf) { vec3 H = normalize(L + V); float NdotV = max(0.0, dot(N, V)); float NdotL = max(0.0, dot(N, L)); float NdotH = max(0.0, dot(N, H)); vec3 F0 = mix(vec3(0.04), surf.albedo.rgb, surf.metalness); vec3 F = fresnelSchlick_roughness(F0, max(0.0, dot(H, L)), surf.roughness); float D = ndfGGX(NdotH, surf.roughness); float G = gaSchlickGGX(NdotL, NdotV, surf.roughness); vec3 kd = mix(vec3(1.0) - F, vec3(0.0), surf.metalness); float shadow = shadow(pos, L); vec3 diffuseBRDF = kd * surf.albedo.rgb / M_PI; vec3 specularBRDF = (F * D * G) / max(0.0001, 4.0 * NdotL * NdotV); return (diffuseBRDF + specularBRDF) * Lradiance * NdotL * shadow; } // 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; } // Specular Occlusion // https://media.contentapi.ea.com/content/dam/eacom/frostbite/files/course-notes-moving-frostbite-to-pbr-v2.pdf float so(float NoV, float ao, float roughness) { return clamp(pow(NoV + ao, exp2(-16.0 * roughness - 1.0)) - 1.0 + ao, 0.0, 1.0); } vec3 calcAmbient(vec3 pos, vec3 N, vec3 V, float t, vec3 ambientColor, surface surf) { vec3 F0 = mix(vec3(0.04), surf.albedo.rgb, surf.metalness); vec3 F = fresnelSchlick_roughness(F0, max(0.0, dot(N, V)), surf.roughness); vec3 kd = mix(vec3(1.0) - F, vec3(0.0), surf.metalness); float aoRange = t/40.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 = mix(vec3(0.2,0.5,0.85)*0.5, vec3(0.2,0.25,0.8) * 0.75, 0.5+0.5*N.y); //ambientColor = mix(vec3(0.3, 0.15, 0.05), ambientColor, 1.0 - smoothstep(0.2, -0.5, sunDir.y)); //ambientColor = mix(vec3(0.03), ambientColor, 1.0 - smoothstep(-0.2, -0.5, sunDir.y)); vec3 diffuseAmbient = kd * surf.albedo.rgb * ambientColor * min(1.0, 0.75+0.5*N.y) * 3.0; vec3 R = reflect(-V, N); //vec3 col = mix(fakeSky(R) * pow( 1.0-max(-R.y,0.0), 4.0), ambientColor, pow(roughness, 0.5)); vec3 col = ambientColor; vec3 ref = EnvBRDFApprox(F0, surf.roughness, max(dot(N, V), 0.0)); vec3 specularAmbient = col * ref; diffuseAmbient *= occlusion; specularAmbient *= so(max(0.0, dot(N, V)), occlusion, surf.roughness); return vec3(diffuseAmbient + specularAmbient); } #endif //------------------------------------------------------------------------------ // 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)); } #ifdef USE_RAYCAST /////////////// /* 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)); } 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, iTime * -15.)) - min(air, 1.) * (20.); } */ float densitycalc(vec3 p){ //p = rotate(p, 0.45, vec3(0,0,1)); //p = rotate(p, M_PI, vec3(0,1,0)); p = opRep(p, vec3(0.5,100,100.0)); p = rotate(p + vec3(0,0.04,0.2), RAD90, vec3(1,0,0)); float d = 10000.; for(int i = 0; i < 5; i++) { float k = fract(float(i) / 5. + iTime * 0.25); vec3 q = p + vec3(0, -2.8*k, -0.1*k); //surface r = sdBoze(p, vec3(1), (sin(iTime * 2.0) * 0.5 + 0.5)*1.5); //surface r = sdBoze(p, vec3(1.2), 1.); //float d = sdCapsule(p, vec3(0,0.01,0.2), vec3(0,0.1,1.0), 0.01, 0.1); //float d = sdTorus(p, vec2(0.2 + sin(iTime) * 0.1, 0.05)); float d2 = sdTorus(q, vec2(0.2*k, 0.05*k)); //return fbm(p * 25. + iTime * 2.2) - min(d, 1.) * 25.; //return fbm(p * (25. + p.y * 25.) *vec3(1,0.5,1)+ vec3(0, iTime * -5.2, 0)) - min(d, 1.) * (20. - p.y * 20.); //return fbm(p * (25. + p.y * 25.) *vec3(1,0.5,1)+ vec3(0, iTime * -5.2, 0)) - min(d, 1.) * (20. - p.x * 20.); d = min(d, d2); } return fbm(p * (25. + p.z * 25.) * vec3(1,1,0.5)+ vec3(0, 0, iTime * -5.2)) - min(d, 1.) * 25.; } surface rayCast(vec3 pos, vec3 dir, float dist) { const vec3 boxPos = vec3(0,0,0); const vec3 boxSize = vec3(100., 0.5, 10.); 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 = 2.0 / float(MAX_RAYCAST_L); float start = max(0., sd.x) - step; pos = pos + dir * start; float t = hash13(pos * 5.5) * 0.001; float alpha = 0.; float transmittance = 1.0; float absorption = 20.; 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 *= 2. - dd * absorption; if(transmittance < 0.001) break; alpha += 20. * dd * transmittance; //result.albedo.rgb += vec3(0.5,0.65,0.85) * (150. * dd * transmittance); //result.emission.rgb += vec3(1,0.3,0.05) * (150. * dd * transmittance); result.emission.rgb += vec3(0.1,0.3,1.0) * (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; } #endif #define fog_density(x) (1.0 - saturate(exp2(4.5 - (x) * 11.0))) 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 * 0.2; 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); //vec3 lightPos; //vec3 lightColor; //fireworkLight(lightPos, lightColor); #ifdef USE_BRDF_1 // BRDF 1 // Calc Ambient hit.albedo.rgb = calcAmb(pos, direction, nor, lightPos, lightColor, hit); #else // BRDF 2 //Shade hit.albedo.rgb = shade(pos, nor, -direction, normalize(lightPos), lightColor, hit); // Calc Ambient hit.albedo.rgb += calcAmbient(pos, nor, -direction, hit.dist, vec3(0.5), hit); #endif #ifdef ENABLE_FOG // Exponential distance fog hit.albedo.rgb = mix(hit.albedo.rgb, sky, fog_density(hit.dist + dist)); #endif } #ifdef USE_RAYCAST // 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; hit.isHit = volume.isHit; } if(d <= EPS || volume.isHit){ #else if(d <= EPS){ #endif 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) { if (!mat.isHit) { 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(ray*3823.) * mat.roughness); bool isIncoming = dot(ray, nor) < 0.0; vec3 orientingNormal = isIncoming ? nor : -nor; //orientingNormal = normalize(orientingNormal + hash33(pos) * mat.roughness * 0.05); 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); //ray = normalize(ray + hash33(ray) * mat.roughness * 0.05); pos = pos + orientingNormal * OFFSET; } mat = traceRay(pos, ray, dist, pos); dist += mat.dist; pos = pos + mat.dist * ray; 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; } /* vec3 postEffect(vec3 col, vec2 index) { //float shift = rand(index * 82.345); float shift = (index.x + index.y * 3.0) / 9.0; vec3 hsv = rgb2hsv(col); hsv.x += shift + iTime * 0.1; hsv.y = 0.75; //hsv.y *= 2.5; //hsv.y = hsv.y < 0.25 ? 0.25 : hsv.y; //hsv.y = floor(hsv.y * 8.0) / 8.0; //hsv.z = 1.0; //hsv.z = hsv.z < 0.7 ? hsv.z < 0.5 ? 0.0 : 0.5 : hsv.z; hsv.z = floor(hsv.z * 8.0) / 8.0; hsv.z = hsv.z < 0.6 ? 0.0 : hsv.z; hsv.x += hsv.z * 3.0; col = hsv2rgb(hsv); //col = floor(col * 8.0) / 8.0; 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) { #define ZERO (min(iFrame,0)) vec3 tot = vec3(0.0); #if AA>1 for( int m=ZERO; m1 } tot /= float(AA*AA); #endif //col = postEffect(col, idx); gl_FragColor = vec4(tot,1.0); }

Halloween Boze