[{"_1":2,"_3":-5,"_4":-5},"loaderData",{"_5":6,"_7":8},"actionData","errors","root",{"_20":-5},"routes/shader",{"_9":10,"_11":12,"_13":14,"_15":16,"_17":16,"_18":16,"_19":16},"slug","lU5omCHr","source","-- \"Seascape\" by Alexander Alekseev aka TDM - 2014\n-- Wyn port of the Shadertoy classic\n-- License: Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License\n-- Original: https://www.shadertoy.com/view/Ms2SD1\n\nopen f32\n\n------------------------------------------------------------\n-- Constants\n------------------------------------------------------------\ndef NUM_STEPS: i32 = 32\ndef PI: f32 = 3.141592\ndef EPSILON: f32 = 0.001\n\ndef ITER_GEOMETRY: i32 = 3\ndef ITER_FRAGMENT: i32 = 5\ndef SEA_HEIGHT: f32 = 0.6\ndef SEA_CHOPPY: f32 = 4.0\ndef SEA_SPEED: f32 = 0.8\ndef SEA_FREQ: f32 = 0.16\ndef SEA_BASE: vec3f32 = @[0.0, 0.09, 0.18]\ndef SEA_WATER_COLOR: vec3f32 = @[0.48, 0.54, 0.36] -- vec3(0.8,0.9,0.6)*0.6\n\ndef sea_time(t: f32) f32 = 1.0 + t * SEA_SPEED\n\n-- octave_m = mat2(1.6, 1.2, -1.2, 1.6) - used for rotating UV in octaves\ndef octave_m: mat2f32 = @[[1.6, -1.2], [1.2, 1.6]]\n\n------------------------------------------------------------\n-- Vertex shader: full-screen triangle\n------------------------------------------------------------\n\n------------------------------------------------------------\n-- Math helpers\n------------------------------------------------------------\n\n-- Hash function for noise\ndef hash(p: vec2f32) f32 =\n let h = dot(p, @[127.1, 311.7]) in\n fract(sin(h) * 43758.5453123)\n\n-- 2D noise\ndef noise(p: vec2f32) f32 =\n let i = vec.floor(p) in\n let f = vec.fract(p) in\n let u = f * f * (3.0 - 2.0 * f) in\n let h00 = hash(i) in\n let h10 = hash(@[i.x + 1.0, i.y]) in\n let h01 = hash(@[i.x, i.y + 1.0]) in\n let h11 = hash(@[i.x + 1.0, i.y + 1.0]) in\n let mix_x0 = mix(h00, h10, u.x) in\n let mix_x1 = mix(h01, h11, u.x) in\n -1.0 + 2.0 * mix(mix_x0, mix_x1, u.y)\n\n-- Euler angles to rotation matrix\ndef from_euler(ang: vec3f32) mat3f32 =\n let a1 = @[sin(ang.x), cos(ang.x)] in\n let a2 = @[sin(ang.y), cos(ang.y)] in\n let a3 = @[sin(ang.z), cos(ang.z)] in\n -- Row-major: m[row][col]\n @[[a1.y*a3.y + a1.x*a2.x*a3.x, a1.y*a2.x*a3.x + a3.y*a1.x, 0.0 - a2.y*a3.x],\n [0.0 - a2.y*a1.x, a1.y*a2.y, a2.x],\n [a3.y*a1.x*a2.x + a1.y*a3.x, a1.x*a3.x - a1.y*a3.y*a2.x, a2.y*a3.y]]\n\n------------------------------------------------------------\n-- Lighting\n------------------------------------------------------------\n\ndef diffuse(n: vec3f32, l: vec3f32, p: f32) f32 =\n (dot(n, l) * 0.4 + 0.6) ** p\n\ndef specular(n: vec3f32, l: vec3f32, e: vec3f32, s: f32) f32 =\n let nrm = (s + 8.0) / (PI * 8.0) in\n let refl = reflect(e, n) in\n (max(dot(refl, l), 0.0)) ** s * nrm\n\n------------------------------------------------------------\n-- Sky\n------------------------------------------------------------\n\ndef get_sky_color(e: vec3f32) vec3f32 =\n let ey = (max(e.y, 0.0) * 0.8 + 0.2) * 0.8 in\n let r = (1.0 - ey) ** 2.0 in\n let g = 1.0 - ey in\n let b = 0.6 + (1.0 - ey) * 0.4 in\n @[r * 1.1, g * 1.1, b * 1.1]\n\n------------------------------------------------------------\n-- Sea\n------------------------------------------------------------\n\ndef sea_octave(uv: vec2f32, choppy: f32) f32 =\n let uv2 = uv + noise(uv) in\n let wv = 1.0 - vec.abs(vec.sin(uv2)) in\n let swv = vec.abs(vec.cos(uv2)) in\n let wv2 = mix(wv, swv, wv) in\n (1.0 - (wv2.x * wv2.y) ** 0.65) ** choppy\n\n-- Height map function for geometry (fewer iterations)\ndef height_map(p: vec3f32, time: f32) f32 =\n let sea_t = sea_time(time) in\n let uv_init = @[p.x * 0.75, p.z] in\n let h_result = loop (i, uv, h, freq, amp, choppy) = (0, uv_init, 0.0, SEA_FREQ, SEA_HEIGHT, SEA_CHOPPY) while i < ITER_GEOMETRY do\n let d1 = sea_octave((uv + sea_t) * freq, choppy) in\n let d2 = sea_octave((uv - sea_t) * freq, choppy) in\n let h2 = h + (d1 + d2) * amp in\n let uv2 = uv * octave_m in\n (i + 1, uv2, h2, freq * 1.9, amp * 0.22, mix(choppy, 1.0, 0.2))\n in p.y - h_result.2\n\n-- Map function for detailed normals (more iterations)\ndef map_detailed(p: vec3f32, time: f32) f32 =\n let sea_t = sea_time(time) in\n let uv_init = @[p.x * 0.75, p.z] in\n let h_result = loop (i, uv, h, freq, amp, choppy) = (0, uv_init, 0.0, SEA_FREQ, SEA_HEIGHT, SEA_CHOPPY) while i < ITER_FRAGMENT do\n let d1 = sea_octave((uv + sea_t) * freq, choppy) in\n let d2 = sea_octave((uv - sea_t) * freq, choppy) in\n let h2 = h + (d1 + d2) * amp in\n let uv2 = uv * octave_m in\n (i + 1, uv2, h2, freq * 1.9, amp * 0.22, mix(choppy, 1.0, 0.2))\n in p.y - h_result.2\n\ndef get_sea_color(p: vec3f32, n: vec3f32, l: vec3f32, eye: vec3f32, dist: vec3f32) vec3f32 =\n let fresnel_raw = clamp(1.0 - dot(n, -eye), 0.0, 1.0) in\n let fresnel = min(fresnel_raw * fresnel_raw * fresnel_raw, 0.5) in\n\n let reflected = get_sky_color(reflect(eye, n)) in\n let diff = diffuse(n, l, 80.0) in\n let refracted = SEA_BASE + diff * SEA_WATER_COLOR * 0.12 in\n\n let color = mix(refracted, reflected, fresnel) in\n\n let atten = max(1.0 - dot(dist, dist) * 0.001, 0.0) in\n let color2 = color + SEA_WATER_COLOR * (p.y - SEA_HEIGHT) * 0.18 * atten in\n\n let spec = specular(n, l, eye, 600.0 / sqrt(dot(dist, dist))) in\n color2 + spec\n\n------------------------------------------------------------\n-- Tracing\n------------------------------------------------------------\n\ndef get_normal(p: vec3f32, eps: f32, time: f32) vec3f32 =\n let ny = map_detailed(p, time) in\n let nx = map_detailed(@[p.x + eps, p.y, p.z], time) - ny in\n let nz = map_detailed(@[p.x, p.y, p.z + eps], time) - ny in\n normalize(@[nx, eps, nz])\n\n-- Height map tracing - returns (t, p)\ndef height_map_tracing(ori: vec3f32, dir: vec3f32, time: f32) (f32, vec3f32) =\n let tx = 1000.0 in\n let p_far = ori + dir * tx in\n let hx = height_map(p_far, time) in\n if hx > 0.0 then (tx, p_far)\n else\n let hm = height_map(ori, time) in\n let step_result =\n loop (i, tm, tx, hm, hx, p) = (0, 0.0, tx, hm, hx, ori) while i < NUM_STEPS do\n let tmid = mix(tm, tx, hm / (hm - hx)) in\n let p_mid = ori + dir * tmid in\n let hmid = height_map(p_mid, time) in\n if abs(hmid) < EPSILON then (NUM_STEPS, tm, tx, hm, hx, p_mid)\n else if hmid < 0.0 then (i + 1, tm, tmid, hm, hmid, p_mid)\n else (i + 1, tmid, tx, hmid, hx, p_mid)\n in\n let t_final = mix(step_result.1, step_result.2, step_result.3 / (step_result.3 - step_result.4)) in\n let p_result = ori + dir * t_final in\n (t_final, p_result)\n\n------------------------------------------------------------\n-- Main rendering\n------------------------------------------------------------\n\ndef get_pixel(coord: vec2f32, time: f32, resolution: vec3f32, time: f32) vec3f32 =\n let uv = coord / resolution.xy in\n let uv2 = uv * 2.0 - 1.0 in\n let uv3 = @[uv2.x * resolution.x / resolution.y, uv2.y] in\n\n -- Ray setup\n let ang = @[sin(time * 3.0) * 0.1, sin(time) * 0.2 + 0.3, time] in\n let ori = @[0.0, 3.5, time * 5.0] in\n let dir_base = normalize(@[uv3.x, uv3.y, -2.0]) in\n let dir_z_adj = @[dir_base.x, dir_base.y, dir_base.z + magnitude(uv3.xy) * 0.14] in\n let dir_norm = normalize(dir_z_adj) in\n let rot = from_euler(ang) in\n let dir = dir_norm * rot in\n\n -- Tracing (sea functions use raw iTime, not camera time)\n let (_, p) = height_map_tracing(ori, dir, time) in\n let dist = p - ori in\n let eps_nrm = 0.1 / resolution.x in\n let n = get_normal(p, dot(dist, dist) * eps_nrm, time) in\n let light = normalize(@[0.0, 1.0, 0.8]) in\n\n -- Color\n let sky = get_sky_color(dir) in\n let sea = get_sea_color(p, n, light, dir, dist) in\n let blend = (smoothstep(0.0, 0.0 - 0.02, dir.y)) ** 0.2 in\n mix(sky, sea, blend)\n\n------------------------------------------------------------\n-- Fragment shader\n------------------------------------------------------------\n\n\ndef main_image(\n resolution: vec3f32, time: f32, mouse: vec4f32, frag_coord: vec2f32\n ) vec4f32 =\n -- Flip Y coordinate for Vulkan\n let coord = @[frag_coord.x, resolution.y - frag_coord.y] in\n let animation_time = time * 0.3 + mouse.x * 0.01 in\n let color = get_pixel(coord, animation_time, resolution, animation_time) in\n -- Gamma correction\n let gamma = 0.65 in\n @[color.x ** gamma, color.y ** gamma, color.z ** gamma, 1.0]\n\n------------------------------------------------------------\n-- Original GLSL (commented out)\n------------------------------------------------------------\n\n-- /*\n-- * \"Seascape\" by Alexander Alekseev aka TDM - 2014\n-- * License Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License.\n-- * Contact: tdmaav@gmail.com\n-- */\n--\n-- const int NUM_STEPS = 32;\n-- const float PI\t \t= 3.141592;\n-- const float EPSILON\t= 1e-3;\n-- #define EPSILON_NRM (0.1 / iResolution.x)\n-- //#define AA\n--\n-- // sea\n-- const int ITER_GEOMETRY = 3;\n-- const int ITER_FRAGMENT = 5;\n-- const float SEA_HEIGHT = 0.6;\n-- const float SEA_CHOPPY = 4.0;\n-- const float SEA_SPEED = 0.8;\n-- const float SEA_FREQ = 0.16;\n-- const vec3 SEA_BASE = vec3(0.0,0.09,0.18);\n-- const vec3 SEA_WATER_COLOR = vec3(0.8,0.9,0.6)*0.6;\n-- #define SEA_TIME (1.0 + iTime * SEA_SPEED)\n-- const mat2 octave_m = mat2(1.6,1.2,-1.2,1.6);\n--\n-- // math\n-- mat3 fromEuler(vec3 ang) {\n-- \tvec2 a1 = vec2(sin(ang.x),cos(ang.x));\n-- vec2 a2 = vec2(sin(ang.y),cos(ang.y));\n-- vec2 a3 = vec2(sin(ang.z),cos(ang.z));\n-- mat3 m;\n-- m[0] = vec3(a1.y*a3.y+a1.x*a2.x*a3.x,a1.y*a2.x*a3.x+a3.y*a1.x,-a2.y*a3.x);\n-- \tm[1] = vec3(-a2.y*a1.x,a1.y*a2.y,a2.x);\n-- \tm[2] = vec3(a3.y*a1.x*a2.x+a1.y*a3.x,a1.x*a3.x-a1.y*a3.y*a2.x,a2.y*a3.y);\n-- \treturn m;\n-- }\n-- float hash( vec2 p ) {\n-- \tfloat h = dot(p,vec2(127.1,311.7));\n-- return fract(sin(h)*43758.5453123);\n-- }\n-- float noise( in vec2 p ) {\n-- vec2 i = floor( p );\n-- vec2 f = fract( p );\n-- \tvec2 u = f*f*(3.0-2.0*f);\n-- return -1.0+2.0*mix( mix( hash( i + vec2(0.0,0.0) ),\n-- hash( i + vec2(1.0,0.0) ), u.x),\n-- mix( hash( i + vec2(0.0,1.0) ),\n-- hash( i + vec2(1.0,1.0) ), u.x), u.y);\n-- }\n--\n-- // lighting\n-- float diffuse(vec3 n,vec3 l,float p) {\n-- return pow(dot(n,l) * 0.4 + 0.6,p);\n-- }\n-- float specular(vec3 n,vec3 l,vec3 e,float s) {\n-- float nrm = (s + 8.0) / (PI * 8.0);\n-- return pow(max(dot(reflect(e,n),l),0.0),s) * nrm;\n-- }\n--\n-- // sky\n-- vec3 getSkyColor(vec3 e) {\n-- e.y = (max(e.y,0.0)*0.8+0.2)*0.8;\n-- return vec3(pow(1.0-e.y,2.0), 1.0-e.y, 0.6+(1.0-e.y)*0.4) * 1.1;\n-- }\n--\n-- // sea\n-- float sea_octave(vec2 uv, float choppy) {\n-- uv += noise(uv);\n-- vec2 wv = 1.0-abs(sin(uv));\n-- vec2 swv = abs(cos(uv));\n-- wv = mix(wv,swv,wv);\n-- return pow(1.0-pow(wv.x * wv.y,0.65),choppy);\n-- }\n--\n-- float map(vec3 p) {\n-- float freq = SEA_FREQ;\n-- float amp = SEA_HEIGHT;\n-- float choppy = SEA_CHOPPY;\n-- vec2 uv = p.xz; uv.x *= 0.75;\n--\n-- float d, h = 0.0;\n-- for(int i = 0; i < ITER_GEOMETRY; i++) {\n-- \td = sea_octave((uv+SEA_TIME)*freq,choppy);\n-- \td += sea_octave((uv-SEA_TIME)*freq,choppy);\n-- h += d * amp;\n-- \tuv *= octave_m; freq *= 1.9; amp *= 0.22;\n-- choppy = mix(choppy,1.0,0.2);\n-- }\n-- return p.y - h;\n-- }\n--\n-- float map_detailed(vec3 p) {\n-- float freq = SEA_FREQ;\n-- float amp = SEA_HEIGHT;\n-- float choppy = SEA_CHOPPY;\n-- vec2 uv = p.xz; uv.x *= 0.75;\n--\n-- float d, h = 0.0;\n-- for(int i = 0; i < ITER_FRAGMENT; i++) {\n-- \td = sea_octave((uv+SEA_TIME)*freq,choppy);\n-- \td += sea_octave((uv-SEA_TIME)*freq,choppy);\n-- h += d * amp;\n-- \tuv *= octave_m; freq *= 1.9; amp *= 0.22;\n-- choppy = mix(choppy,1.0,0.2);\n-- }\n-- return p.y - h;\n-- }\n--\n-- vec3 getSeaColor(vec3 p, vec3 n, vec3 l, vec3 eye, vec3 dist) {\n-- float fresnel = clamp(1.0 - dot(n, -eye), 0.0, 1.0);\n-- fresnel = min(fresnel * fresnel * fresnel, 0.5);\n--\n-- vec3 reflected = getSkyColor(reflect(eye, n));\n-- vec3 refracted = SEA_BASE + diffuse(n, l, 80.0) * SEA_WATER_COLOR * 0.12;\n--\n-- vec3 color = mix(refracted, reflected, fresnel);\n--\n-- float atten = max(1.0 - dot(dist, dist) * 0.001, 0.0);\n-- color += SEA_WATER_COLOR * (p.y - SEA_HEIGHT) * 0.18 * atten;\n--\n-- color += specular(n, l, eye, 600.0 * inversesqrt(dot(dist,dist)));\n--\n-- return color;\n-- }\n--\n-- // tracing\n-- vec3 getNormal(vec3 p, float eps) {\n-- vec3 n;\n-- n.y = map_detailed(p);\n-- n.x = map_detailed(vec3(p.x+eps,p.y,p.z)) - n.y;\n-- n.z = map_detailed(vec3(p.x,p.y,p.z+eps)) - n.y;\n-- n.y = eps;\n-- return normalize(n);\n-- }\n--\n-- float heightMapTracing(vec3 ori, vec3 dir, out vec3 p) {\n-- float tm = 0.0;\n-- float tx = 1000.0;\n-- float hx = map(ori + dir * tx);\n-- if(hx > 0.0) {\n-- p = ori + dir * tx;\n-- return tx;\n-- }\n-- float hm = map(ori);\n-- for(int i = 0; i < NUM_STEPS; i++) {\n-- float tmid = mix(tm, tx, hm / (hm - hx));\n-- p = ori + dir * tmid;\n-- float hmid = map(p);\n-- if(hmid < 0.0) {\n-- tx = tmid;\n-- hx = hmid;\n-- } else {\n-- tm = tmid;\n-- hm = hmid;\n-- }\n-- if(abs(hmid) < EPSILON) break;\n-- }\n-- return mix(tm, tx, hm / (hm - hx));\n-- }\n--\n-- vec3 getPixel(in vec2 coord, float time) {\n-- vec2 uv = coord / iResolution.xy;\n-- uv = uv * 2.0 - 1.0;\n-- uv.x *= iResolution.x / iResolution.y;\n--\n-- // ray\n-- vec3 ang = vec3(sin(time*3.0)*0.1,sin(time)*0.2+0.3,time);\n-- vec3 ori = vec3(0.0,3.5,time*5.0);\n-- vec3 dir = normalize(vec3(uv.xy,-2.0)); dir.z += length(uv) * 0.14;\n-- dir = normalize(dir) * fromEuler(ang);\n--\n-- // tracing\n-- vec3 p;\n-- heightMapTracing(ori,dir,p);\n-- vec3 dist = p - ori;\n-- vec3 n = getNormal(p, dot(dist,dist) * EPSILON_NRM);\n-- vec3 light = normalize(vec3(0.0,1.0,0.8));\n--\n-- // color\n-- return mix(\n-- getSkyColor(dir),\n-- getSeaColor(p,n,light,dir,dist),\n-- \tpow(smoothstep(0.0,-0.02,dir.y),0.2));\n-- }\n--\n-- // main\n-- void mainImage( out vec4 fragColor, in vec2 fragCoord ) {\n-- float time = iTime * 0.3 + iMouse.x*0.01;\n--\n-- #ifdef AA\n-- vec3 color = vec3(0.0);\n-- for(int i = -1; i <= 1; i++) {\n-- for(int j = -1; j <= 1; j++) {\n-- \tvec2 uv = fragCoord+vec2(i,j)/3.0;\n-- \t\tcolor += getPixel(uv, time);\n-- }\n-- }\n-- color /= 9.0;\n-- #else\n-- vec3 color = getPixel(fragCoord, time);\n-- #endif\n--\n-- // post\n-- \tfragColor = vec4(pow(color,vec3(0.65)), 1.0);\n-- }\n","title","Seascape","isOwner",false,"isSignedIn","isAdmin","isFeatured","session"]