precision highp float; uniform vec2 resolution; uniform float time; //// rayの定義に視野角を使うか #define RAY_FOVY //// アニメーションするか // #define SCALE_ANIMATION // #define GO_ANIMATION // #define DIR_ANIMATION //// rotateするか #define USE_ROTATE //// 各種パラメータ設定 #define duration 30. #define iGlobalTime time #define gTime time * .75 #define PI 3.14159265 #define INFINITY 1. / 0. #define RAY_HIT_THRESHOLD 0.001 #define MAX_MARCHING_ITTRATION 128 #define EDGE_THRESHOLD 0.0005 #define FAR_CLIP 1E30 #define FRACTAL_STEP 5 //// enum #define OR 0 #define AND 1 #define SUB 2 // material #define M_BASE 0. #define M_CROSS 1. #define M_EDGE 2. #define M_SPHEREE 3. #define M_TORUS 4. // color #define C_YELLOW vec3(.9, 1., .4) #define C_BLACK vec3(.0) #define C_WHITE vec3(1.) #define C_GRAY vec3(.05) #define C_PINK vec3(.8, .05, .35) #define C_RED vec3(.99, .0, .0) #define C_BASE C_BLACK #define C_CROSS C_RED #define C_EDGE C_RED #define C_TORUS C_BLACK #define C_AO C_WHITE /// Easing float easeOutExpo(float t, float from, float to, float dur) { return from + (to - from) * (1. - pow(2., -10. * t / dur)); } /// math float sin2(float x, float min, float max) { float len = max - min; return min + (len * sin(x) + len) * .5; } float max2(vec2 v) { return max(v.x, v.y); } /// Noise Functions ============================== vec2 dotedRandom(vec2 st) { st = vec2( dot(st,vec2(127.1,311.7)), dot(st,vec2(269.5,183.3)) ); return -1.0 + 2.0*fract(sin(st)*43758.5453123); } float perlinNoise(vec2 st) { vec2 p = floor(st); vec2 f = fract(st); vec2 u = f*f*(3.0-2.0*f); vec2 v00 = dotedRandom(p+vec2(0,0)); vec2 v10 = dotedRandom(p+vec2(1,0)); vec2 v01 = dotedRandom(p+vec2(0,1)); vec2 v11 = dotedRandom(p+vec2(1,1)); return mix( mix( dot( v00, f - vec2(0,0) ), dot( v10, f - vec2(1,0) ), u.x ), mix( dot( v01, f - vec2(0,1) ), dot( v11, f - vec2(1,1) ), u.x ), u.y) + 0.5; } float fBm (vec2 st) { float f = 0.; vec2 q = st; f += 0.5000 * perlinNoise( q ); q *= 2.01; f += 0.2500 * perlinNoise( q ); q *= 2.02; f += 0.1250 * perlinNoise( q ); q *= 2.03; f += 0.0625 * perlinNoise( q ); q *= 2.01; return f; } float animNoise(float speed, float offset, float scale) { return scale * (fBm(vec2(cos(gTime * speed + offset / PI), sin(gTime * speed + offset / PI))) - .5); } vec3 getRayDirection(vec3 cDir, vec3 cUp, vec2 fPosition) { vec3 cSide = cross(cDir, cUp); float targetDepth = 1.0; #ifdef RAY_FOVY float angle = 135. + 45. * easeOutExpo(gTime, 1., 0., 2.); vec2 aspect = resolution.xy / min(resolution.x, resolution.y); float fov = angle * 0.5 * PI / 180.; float aspectm = max2(aspect); return normalize( cDir + cSide * targetDepth * tan(fov * aspect.x / aspectm) * fPosition.x / aspect.x + cUp * targetDepth * tan(fov * aspect.y / aspectm) * fPosition.y / aspect.y); #else return normalize(cSide * fPosition.x + cUp * fPosition.y + cDir * targetDepth); #endif } 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; } vec2 rotate2d(vec2 xy, float thete) { return mat2(cos(thete), -sin(thete), sin(thete), cos(thete)) * xy; } /// Filter effect ============================== // horizontal displacement map float displacementAmount(float gTimeOffset) { // エフェクトの間隔 float gTimeInterval = 2.; // sinc関数のxの範囲(0. ~ xRange) float xRange = 20.; float x = mod((iGlobalTime + gTimeOffset) * xRange / gTimeInterval, xRange); return sin(x) / pow(x, 3.); } vec2 flHorizontalDisplacement(vec2 fPosition, float timeOffset) { float noiseValue = (perlinNoise(floor(vec2(fPosition.y * 100., iGlobalTime + timeOffset)) / 1.01) - .5) * displacementAmount(0.) * 2.; fPosition.x = fPosition.x + noiseValue * 3.0; return fPosition; } /// Operations for Ray Marching ============================== // Union float opU(float d1, float d2) { return min(d1, d2); } vec2 opU(vec2 d1, vec2 d2) { if(d1.x < d2.x) return d1; return d2; } // Substraction float opS(float d1, float d2) { return max(d1, -d2); } vec2 opS(vec2 d1, vec2 d2) { if(d1.x > -d2.x + EDGE_THRESHOLD) return d1; if(d1.x < -d2.x - EDGE_THRESHOLD) return vec2(-d2.x, d2.y); return vec2(d1.x, M_EDGE); } vec2 opS(vec2 d1, vec2 d2, vec3 p) { if(d1.x > -d2.x + EDGE_THRESHOLD) return d1; if(d1.x < -d2.x - EDGE_THRESHOLD) return vec2(-d2.x, d2.y); // edge float radius = mod(iGlobalTime / 2., 2.); float margin = .1 * perlinNoise(p.xy * 10.); float l = length(p); if(l < radius + margin && l > radius - margin) return vec2(d1.x, M_EDGE); return d1; } // Intersection float opI(float d1, float d2) { return max(d1, d2); } // Repetition vec3 opRep(vec3 p, vec3 interval) { return mod(p, interval * 2.) - interval; } vec3 opRep(vec3 p, float interval) { return opRep(p, vec3(interval)); } /// Distance Functions ============================== // 2d Rectangle float dfRect(vec2 p, vec2 size) { vec2 d = abs(p) - size; return min(max(d.x, d.y), 0.) + length(max(d, 0.)); } // 3d Box vec2 dfBox(vec3 p, vec3 size) { vec3 d = abs(p) - size; return vec2(min(max(d.x, max(d.y, d.z)), .0) + length(max(d, .0)), M_BASE); } vec2 dfInfCross(vec3 p, float side) { // optimized float pillarX = dfRect(p.xy, vec2(side)); float pillarY = dfRect(p.yz, vec2(side)); float pillarZ = dfRect(p.zx, vec2(side)); /* vec2 pillarX = dfBox(p, vec3(INFINITY, side, side)); vec2 pillarY = dfBox(p, vec3(side, INFINITY, side)); vec2 pillarZ = dfBox(p, vec3(side, side, INFINITY)); */ return vec2(opU(pillarX, opU(pillarY, pillarZ)), M_CROSS); } vec2 dfSphere(vec3 p, vec3 position, float scale) { float radius = 1. * scale; return vec2(length(p - position) - radius, M_SPHEREE); } vec2 dfTorus(vec3 p, vec3 position, float size, float thickness){ vec2 r = vec2(length(p.xy) - size, p.z); return vec2(length(r) - thickness, M_TORUS); } vec2 dfMenger(vec3 p) { float cubeSize = 1.; float count = 1.; vec2 baseCube = dfBox(p, vec3(cubeSize)); vec2 dist = baseCube; for(int i=1; i<=FRACTAL_STEP; i++) { // if(i > int(floor(mod(gTime * 3., 5.)))) break; // float repeatInterval = 1.25 - abs(pow(1. * cos(gTime / PI), 2.) * 1.0); float repeatInterval = 0.6 - abs(.2 * cos(gTime / PI *.5)); // float repeatInterval = 1. / 3.; vec3 a = opRep(p * count, repeatInterval); vec3 r = 1. - 3. * abs(a); count *= 3.; vec2 c = vec2(dfInfCross(r, cubeSize / 3.).x / count, M_CROSS); dist = opS(dist, c, p); } return dist; } vec2 dfSphere2(vec3 p) { float z = 1.; return opS(opS(opS( dfSphere(p, vec3(0., 0., z), .065), dfSphere(p, vec3(cos(gTime * 3.) * 0.05, sin(gTime * 2.) * 0.05, 0.04 * sin(gTime * 3.) + z), .025)), dfSphere(p, vec3(cos(gTime * 2.) * 0.05, sin(gTime * 2.5) * 0.065, 0.04 * sin(gTime * 2.) + z), .045)), dfSphere(p, vec3(cos(gTime * 1.) * 0.05, sin(gTime * 3.5) * 0.065, 0.05 * sin(gTime * 1.) + z), .03)); } vec2 distanceFunc(vec3 p) { vec2 dist = dfMenger(rotate(p, radians(gTime / PI * 10.), vec3(1., 1., 0.))); // vec2 dist = opU( // dfMenger(opRep(vec3(p.xy, p.z -1.125 * gTime), vec3(vec2(1.25 + .25 * displacementAmount(-1.)), 1.001))), // dfSphere2(p)); return dist; } vec3 getNormal(vec3 p){ float d = 0.0001; // 法線を得るためにrayの始点をずらす量 return normalize(vec3( distanceFunc(p + vec3( d, 0.0, 0.0)).x - distanceFunc(p + vec3( -d, 0.0, 0.0)).x, distanceFunc(p + vec3(0.0, d, 0.0)).x - distanceFunc(p + vec3(0.0, -d, 0.0)).x, distanceFunc(p + vec3(0.0, 0.0, d)).x - distanceFunc(p + vec3(0.0, 0.0, -d)).x )); } float getSimpleLightingDiffuse(vec3 rPosition, vec3 lightPos) { vec3 normal = getNormal(rPosition); return clamp(dot(lightPos, normal), 0.05, 1.0); } float getSoftShadow(vec3 rPosition, vec3 lDirection){ lDirection = normalize(lDirection); float h = 0.0; float c = 0.001; float r = 1.0; float shadowCoef = 0.5; for(float t = 0.0; t < 50.0; t++){ h = distanceFunc(rPosition + lDirection * c).x; if(h < 0.001){ return shadowCoef; } r = min(r, h * 16.0 / c); c += h; } return 1.0 - shadowCoef + r * shadowCoef; } vec4 getColor(vec2 fPosition) { // camera #ifdef SCALE_ANIMATION float k = 9.; float animTime = mod(gTime, 3.); if(mod(floor(gTime / 3.), 2.) == 1.) animTime = 3. - animTime; vec3 cPosition = vec3(0.0, 0.0, 2.) + vec3(fBm(vec2(cos(gTime / PI), sin(gTime / PI))) - .5, fBm(vec2(sin(gTime / PI), cos(gTime / PI))) - .5, mix(200., .0, 1.0 - exp( -animTime * k ))); #elif defined GO_ANIMATION float camSpeed = 1.; vec3 cPosition = vec3(0.0, 0.0, 2.25) + vec3(animNoise(1., 0., .1), animNoise(1., 10., .2), -1.125) ; #else vec3 cPosition = vec3(0.0, 0.0, 1.25); #endif #ifdef DIR_ANIMATION vec3 cDirection = vec3( animNoise(0.1, 1., 7.5), animNoise(0.1, 0., 7.5), -1.); #else vec3 cDirection = vec3(0.0, 0.0, -1.0); #endif // light vec3 lPosition = vec3(0.577, 2., 1.577); // rayの方向ベクトル vec3 rDirection = getRayDirection(cDirection, vec3(0., 1., 0.), fPosition); // marching loop vec2 distance = vec2(0.); // rayとオブジェクト間の最短距離 float rLength = 0.0; // rayの長さ vec3 rPosition = cPosition; // rayの先端位置 float ittrCount = 0.; for(int i = 0; i < MAX_MARCHING_ITTRATION; i++) { distance = distanceFunc(rPosition); float absDist = abs(distance.x); if(distance.y == M_SPHEREE && (absDist < RAY_HIT_THRESHOLD || absDist > FAR_CLIP)) { rLength += distance.x; vec3 newDir = getNormal(rPosition); rPosition = cPosition + rDirection * rLength; rDirection = newDir; ittrCount++; continue; } if(absDist < RAY_HIT_THRESHOLD || absDist > FAR_CLIP) { break; } rLength += distance.x; rPosition = cPosition + rDirection * rLength; ittrCount++; } // 衝突判定 float diffuse = getSimpleLightingDiffuse(rPosition, lPosition); float shadow = getSoftShadow(rPosition + getNormal(rPosition) * 0.001, lPosition); vec3 color = C_BASE; if (distance.y == M_BASE) color = C_BASE; if (distance.y == M_CROSS) color = C_CROSS; if (distance.y == M_EDGE) color = C_EDGE; float aoCoeff = smoothstep(0., 1., ittrCount / float(MAX_MARCHING_ITTRATION)); // AOの係数(濃さ) return vec4(color * diffuse * max(.5, shadow) * (1. - aoCoeff) + C_AO * aoCoeff, 1.0); } void main() { // fragment position vec2 fPosition = (gl_FragCoord.xy * 2.0 - resolution.xy) / min(resolution.x, resolution.y); gl_FragColor = getColor(flHorizontalDisplacement(fPosition, 0.)); }