From c2d5cd9ee441db40056adf38a84652ae8ed9c132 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Petri=20J=C3=A4rvisalo?= Date: Fri, 26 Jul 2024 00:54:30 +0300 Subject: [PATCH] additions --- base.config | 4 +- minified.config | 12 +- music/4k_sg_v2.xrns | Bin 27620 -> 27590 bytes petrinshader.glsl | 1007 +++++++++++++++++++++++++++++++++++++++++++ shader.glsl | 227 ++++++---- shader_minified.h | 264 ++++++------ shader_new.glsl | 444 +++++++++++++++++++ shadertoy.glsl | 2 +- 8 files changed, 1734 insertions(+), 226 deletions(-) create mode 100644 petrinshader.glsl create mode 100644 shader_new.glsl diff --git a/base.config b/base.config index b8987aa..ef18196 100644 --- a/base.config +++ b/base.config @@ -18,10 +18,10 @@ RESOLUTION_UNIFORM_NAME='u_resolution' # Frame-to-texture, mipmaps -TWO_PASS_RENDERING=1 +TWO_PASS_RENDERING=0 FRAME_TO_TEXTURE=0 USE_MIPMAP=0 -SECOND_PASS_NEGATIVE_TIME=1 +SECOND_PASS_NEGATIVE_TIME=0 # Texts USE_TEXTS=1 diff --git a/minified.config b/minified.config index 1ffbf6c..3e74b8a 100644 --- a/minified.config +++ b/minified.config @@ -12,12 +12,12 @@ CRINKLER_ORDERTRIES=4000 SHADER_FILE=shader_minified.h TIME_UNIFORM_NAME='v' RESOLUTION_UNIFORM_NAME='y' -TEXTS_UNIFORM_NAME='a' +TEXTS_UNIFORM_NAME='f' USE_WIDECHAR_TEXTS=1 -TIME_DIVIDER=44100.000 -TIME_BASE=seconds -TIME_DIVIDER_INT=44100 -TWO_PASS_RENDERING=1 -SECOND_PASS_NEGATIVE_TIME=1 +TIME_DIVIDER=91241.383 +TIME_BASE=bars +TIME_DIVIDER_INT=91241 +TWO_PASS_RENDERING=0 +SECOND_PASS_NEGATIVE_TIME=0 USE_TEXTS=0 USE_TEXTS_UNIFORM=0 diff --git a/music/4k_sg_v2.xrns b/music/4k_sg_v2.xrns index 1ec95459bdc4a36fa25ee476ec4c9c55b4fcd86b..50642f90c30c7325466306f157e06db690745497 100644 GIT binary patch delta 17694 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 delta 17742 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É-Ok#S*ZD+vyKz>;DnMIdlUTu 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. +// Unless otherwise noted, (if the object has an intrinsic "up" +// side or direction) the y axis is "up" and the object is +// centered at the origin. +// +//////////////////////////////////////////////////////////////// + +float fSphere(vec3 p, float r) { + return length(p) - r; +} + +// Plane with normal n (n is normalized) at some distance from the origin +float fPlane(vec3 p, vec3 n, float distanceFromOrigin) { + return dot(p, n) + distanceFromOrigin; +} + +// Cheap Box: distance to corners is overestimated +float fBoxCheap(vec3 p, vec3 b) { //cheap box + return vmax(abs(p) - b); +} + +// Box: correct distance to corners +float fBox(vec3 p, vec3 b) { + vec3 d = abs(p) - b; + return length(max(d, vec3(0))) + vmax(min(d, vec3(0))); +} + +// Same as above, but in two dimensions (an endless box) +float fBox2Cheap(vec2 p, vec2 b) { + return vmax(abs(p)-b); +} + +float fBox2(vec2 p, vec2 b) { + vec2 d = abs(p) - b; + return length(max(d, vec2(0.))) + vmax(min(d, vec2(0.))); +} + + +// Endless "corner" +float fCorner (vec2 p) { + return length(max(p, vec2(0.))) + vmax(min(p, vec2(0.))); +} + +// Cylinder standing upright on the xz plane +float fCylinder(vec3 p, float r, float height) { + float d = length(p.xz) - r; + d = max(d, abs(p.y) - height); + return d; +} + +// Capsule: A Cylinder with round caps on both sides +float fCapsule(vec3 p, float r, float c) { + return mix(length(p.xz) - r, length(vec3(p.x, abs(p.y) - c, p.z)) - r, step(c, abs(p.y))); +} + +// Distance to line segment between and , used for fCapsule() version 2below +float fLineSegment(vec3 p, vec3 a, vec3 b) { + vec3 ab = b - a; + float t = clamp( dot(p - a, ab) / dot(ab, ab), 0., 1. ); + return length((ab*t + a) - p); +} + +// Capsule version 2: between two end points and with radius r +float fCapsule(vec3 p, vec3 a, vec3 b, float r) { + return fLineSegment(p, a, b) - r; +} + +// Torus in the XZ-plane +float fTorus(vec3 p, float smallRadius, float largeRadius) { + return length(vec2(length(p.xz) - largeRadius, p.y)) - smallRadius; +} + +// A circle line. Can also be used to make a torus by subtracting the smaller radius of the torus. +float fCircle(vec3 p, float r) { + float l = length(p.xz) - r; + return length(vec2(p.y, l)); +} + +// A circular disc with no thickness (i.e. a cylinder with no height). +// Subtract some value to make a flat disc with rounded edge. +float fDisc(vec3 p, float r) { + float l = length(p.xz) - r; + return l < 0. ? abs(p.y) : length(vec2(p.y, l)); +} + +// Hexagonal prism, circumcircle variant +float fHexagonCircumcircle(vec3 p, vec2 h) { + vec3 q = abs(p); + return max(q.y - h.y, max(q.x*sqrt(3.)*0.5 + q.z*0.5, q.z) - h.x); + //this is mathematically equivalent to this line, but less efficient: + //return max(q.y - h.y, max(dot(vec2(cos(PI/3), sin(PI/3)), q.zx), q.z) - h.x); +} + +// Hexagonal prism, incircle variant +float fHexagonIncircle(vec3 p, vec2 h) { + return fHexagonCircumcircle(p, vec2(h.x*sqrt(3.)*0.5, h.y)); +} + +// Cone with correct distances to tip and base circle. Y is up, 0 is in the middle of the base. +float fCone(vec3 p, float radius, float height) { + vec2 q = vec2(length(p.xz), p.y); + vec2 tip = q - vec2(0, height); + vec2 mantleDir = normalize(vec2(height, radius)); + float mantle = dot(tip, mantleDir); + float d = max(mantle, -q.y); + float projected = dot(tip, vec2(mantleDir.y, -mantleDir.x)); + + // distance to tip + if ((q.y > height) && (projected < 0.)) { + d = max(d, length(tip)); + } + + // distance to base ring + if ((q.x > radius) && (projected > length(vec2(height, radius)))) { + d = max(d, length(q - vec2(radius, 0))); + } + return d; +} + +//////////////////////////////////////////////////////////////// +// +// DOMAIN MANIPULATION OPERATORS +// +//////////////////////////////////////////////////////////////// +// +// Conventions: +// +// Everything that modifies the domain is named pSomething. +// +// Many operate only on a subset of the three dimensions. For those, +// you must choose the dimensions that you want manipulated +// by supplying e.g. or +// +// is always the first argument and modified in place. +// +// Many of the operators partition space into cells. An identifier +// or cell index is returned, if possible. This return value is +// intended to be optionally used e.g. as a random seed to change +// parameters of the distance functions inside the cells. +// +// Unless stated otherwise, for cell index 0,

is unchanged and cells +// are centered on the origin so objects don't have to be moved to fit. +// +// +//////////////////////////////////////////////////////////////// + +// Rotate around a coordinate axis (i.e. in a plane perpendicular to that axis) by angle . +// Read like this: R(p.xz, a) rotates "x towards z". +// This is fast if is a compile-time constant and slower (but still practical) if not. +void pR(inout vec2 p, float a) { + p = cos(a)*p + sin(a)*vec2(p.y, -p.x); +} + +// Shortcut for 45-degrees rotation +void pR45(inout vec2 p) { + p = (p + vec2(p.y, -p.x))*sqrt(0.5); +} + +// Repeat space along one axis. Use like this to repeat along the x axis: +// - using the return value is optional. +float pMod1(inout float p, float size) { + float halfsize = size*0.5; + float c = floor((p + halfsize)/size); + p = mod(p + halfsize, size) - halfsize; + return c; +} + +// Same, but mirror every second cell so they match at the boundaries +float pModMirror1(inout float p, float size) { + float halfsize = size*0.5; + float c = floor((p + halfsize)/size); + p = mod(p + halfsize,size) - halfsize; + p *= mod(c, 2.0)*2. - 1.; + return c; +} + +// Repeat the domain only in positive direction. Everything in the negative half-space is unchanged. +float pModSingle1(inout float p, float size) { + float halfsize = size*0.5; + float c = floor((p + halfsize)/size); + if (p >= 0.) + p = mod(p + halfsize, size) - halfsize; + return c; +} + +// Repeat only a few times: from indices to (similar to above, but more flexible) +float pModInterval1(inout float p, float size, float start, float stop) { + float halfsize = size*0.5; + float c = floor((p + halfsize)/size); + p = mod(p+halfsize, size) - halfsize; + if (c > stop) { //yes, this might not be the best thing numerically. + p += size*(c - stop); + c = stop; + } + if (c = (repetitions/2.)) c = abs(c); + return c; +} + +// Repeat in two dimensions +vec2 pMod2(inout vec2 p, vec2 size) { + vec2 c = floor((p + size*0.5)/size); + p = mod(p + size*0.5,size) - size*0.5; + return c; +} + +// Same, but mirror every second cell so all boundaries match +vec2 pModMirror2(inout vec2 p, vec2 size) { + vec2 halfsize = size*0.5; + vec2 c = floor((p + halfsize)/size); + p = mod(p + halfsize, size) - halfsize; + p *= mod(c,vec2(2.))*2. - vec2(1); + return c; +} + +// Same, but mirror every second cell at the diagonal as well +vec2 pModGrid2(inout vec2 p, vec2 size) { + vec2 c = floor((p + size*0.5)/size); + p = mod(p + size*0.5, size) - size*0.5; + p *= mod(c,vec2(2.))*2. - vec2(1.); + p -= size/2.; + if (p.x > p.y) p.xy = p.yx; + return floor(c/2.); +} + +// Repeat in three dimensions +vec3 pMod3(inout vec3 p, vec3 size) { + vec3 c = floor((p + size*0.5)/size); + p = mod(p + size*0.5, size) - size*0.5; + return c; +} + +// Mirror at an axis-aligned plane which is at a specified distance from the origin. +float pMirror (inout float p, float dist) { + float s = sgn(p); + p = abs(p)-dist; + return s; +} + +// Mirror in both dimensions and at the diagonal, yielding one eighth of the space. +// translate by dist before mirroring. +vec2 pMirrorOctant (inout vec2 p, vec2 dist) { + vec2 s = sgn(p); + pMirror(p.x, dist.x); + pMirror(p.y, dist.y); + if (p.y > p.x) + p.xy = p.yx; + return s; +} + +// Reflect space at a plane +float pReflect(inout vec3 p, vec3 planeNormal, float offset) { + float t = dot(p, planeNormal)+offset; + if (t < 0.) { + p = p - (2.*t)*planeNormal; + } + return sgn(t); +} + + +//////////////////////////////////////////////////////////////// +// +// OBJECT COMBINATION OPERATORS +// +//////////////////////////////////////////////////////////////// +// +// We usually need the following boolean operators to combine two objects: +// Union: OR(a,b) +// Intersection: AND(a,b) +// Difference: AND(a,!b) +// (a and b being the distances to the objects). +// +// The trivial implementations are min(a,b) for union, max(a,b) for intersection +// and max(a,-b) for difference. To combine objects in more interesting ways to +// produce rounded edges, chamfers, stairs, etc. instead of plain sharp edges we +// can use combination operators. It is common to use some kind of "smooth minimum" +// instead of min(), but we don't like that because it does not preserve Lipschitz +// continuity in many cases. +// +// Naming convention: since they return a distance, they are called fOpSomething. +// The different flavours usually implement all the boolean operators above +// and are called fOpUnionRound, fOpIntersectionRound, etc. +// +// The basic idea: Assume the object surfaces intersect at a right angle. The two +// distances and constitute a new local two-dimensional coordinate system +// with the actual intersection as the origin. In this coordinate system, we can +// evaluate any 2D distance function we want in order to shape the edge. +// +// The operators below are just those that we found useful or interesting and should +// be seen as examples. There are infinitely more possible operators. +// +// They are designed to actually produce correct distances or distance bounds, unlike +// popular "smooth minimum" operators, on the condition that the gradients of the two +// SDFs are at right angles. When they are off by more than 30 degrees or so, the +// Lipschitz condition will no longer hold (i.e. you might get artifacts). The worst +// case is parallel surfaces that are close to each other. +// +// Most have a float argument to specify the radius of the feature they represent. +// This should be much smaller than the object size. +// +// Some of them have checks like "if ((-a < r) && (-b < r))" that restrict +// their influence (and computation cost) to a certain area. You might +// want to lift that restriction or enforce it. We have left it as comments +// in some cases. +// +// usage example: +// +// float fTwoBoxes(vec3 p) { +// float box0 = fBox(p, vec3(1)); +// float box1 = fBox(p-vec3(1), vec3(1)); +// return fOpUnionChamfer(box0, box1, 0.2); +// } +// +//////////////////////////////////////////////////////////////// + + +// The "Chamfer" flavour makes a 45-degree chamfered edge (the diagonal of a square of size ): +float fOpUnionChamfer(float a, float b, float r) { + return min(min(a, b), (a - r + b)*sqrt(0.5)); +} + +// Intersection has to deal with what is normally the inside of the resulting object +// when using union, which we normally don't care about too much. Thus, intersection +// implementations sometimes differ from union implementations. +float fOpIntersectionChamfer(float a, float b, float r) { + return max(max(a, b), (a + r + b)*sqrt(0.5)); +} + +// Difference can be built from Intersection or Union: +float fOpDifferenceChamfer (float a, float b, float r) { + return fOpIntersectionChamfer(a, -b, r); +} + +// The "Round" variant uses a quarter-circle to join the two objects smoothly: +float fOpUnionRound(float a, float b, float r) { + vec2 u = max(vec2(r - a,r - b), vec2(0)); + return max(r, min (a, b)) - length(u); +} + +float fOpIntersectionRound(float a, float b, float r) { + vec2 u = max(vec2(r + a,r + b), vec2(0)); + return min(-r, max (a, b)) + length(u); +} + +float fOpDifferenceRound (float a, float b, float r) { + return fOpIntersectionRound(a, -b, r); +} + + +// The "Columns" flavour makes n-1 circular columns at a 45 degree angle: +float fOpUnionColumns(float a, float b, float r, float n) { + if ((a < r) && (b < r)) { + vec2 p = vec2(a, b); + float columnradius = r*sqrt(2.)/((n-1.)*2.+sqrt(2.)); + pR45(p); + p.x -= sqrt(2.)/2.*r; + p.x += columnradius*sqrt(2.); + if (mod(n,2.) == 1.) { + p.y += columnradius; + } + // At this point, we have turned 45 degrees and moved at a point on the + // diagonal that we want to place the columns on. + // Now, repeat the domain along this direction and place a circle. + pMod1(p.y, columnradius*2.); + float result = length(p) - columnradius; + result = min(result, p.x); + result = min(result, a); + return min(result, b); + } else { + return min(a, b); + } +} + +float fOpDifferenceColumns(float a, float b, float r, float n) { + a = -a; + float m = min(a, b); + //avoid the expensive computation where not needed (produces discontinuity though) + if ((a < r) && (b < r)) { + vec2 p = vec2(a, b); + float columnradius = r*sqrt(2.)/n/2.0; + columnradius = r*sqrt(2.)/((n-1.)*2.+sqrt(2.)); + + pR45(p); + p.y += columnradius; + p.x -= sqrt(2.)/2.*r; + p.x += -columnradius*sqrt(2.)/2.; + + if (mod(n,2.) == 1.) { + p.y += columnradius; + } + pMod1(p.y,columnradius*2.); + + float result = -length(p) + columnradius; + result = max(result, p.x); + result = min(result, a); + return -min(result, b); + } else { + return -m; + } +} + +float fOpIntersectionColumns(float a, float b, float r, float n) { + return fOpDifferenceColumns(a,-b,r, n); +} + +// The "Stairs" flavour produces n-1 steps of a staircase: +// much less stupid version by paniq +float fOpUnionStairs(float a, float b, float r, float n) { + float s = r/n; + float u = b-r; + return min(min(a,b), 0.5 * (u + a + abs ((mod (u - a + s, 2. * s)) - s))); +} + +// We can just call Union since stairs are symmetric. +float fOpIntersectionStairs(float a, float b, float r, float n) { + return -fOpUnionStairs(-a, -b, r, n); +} + +float fOpDifferenceStairs(float a, float b, float r, float n) { + return -fOpUnionStairs(-a, b, r, n); +} + + +// Similar to fOpUnionRound, but more lipschitz-y at acute angles +// (and less so at 90 degrees). Useful when fudging around too much +// by MediaMolecule, from Alex Evans' siggraph slides +float fOpUnionSoft(float a, float b, float r) { + float e = max(r - abs(a - b), 0.); + return min(a, b) - e*e*0.25/r; +} + + +// produces a cylindical pipe that runs along the intersection. +// No objects remain, only the pipe. This is not a boolean operator. +float fOpPipe(float a, float b, float r) { + return length(vec2(a, b)) - r; +} + +// first object gets a v-shaped engraving where it intersect the second +float fOpEngrave(float a, float b, float r) { + return max(a, (a + r - abs(b))*sqrt(0.5)); +} + +// first object gets a capenter-style groove cut out +float fOpGroove(float a, float b, float ra, float rb) { + return max(a, min(a + ra, rb - abs(b))); +} + +// first object gets a capenter-style tongue attached +float fOpTongue(float a, float b, float ra, float rb) { + return min(a, max(a - ra, abs(b) - rb)); +} + +//#endSection End of library + +// https://stackoverflow.com/questions/4200224/random-noise-functions-for-glsl +// golden_noise +float noise(in vec2 xy, in float seed){ + return fract(tan(distance(xy*PHI, xy)*seed)*xy.x); +} + +vec3 rnd23(vec2 p) +{ + vec3 p3 = fract(p.xyx * vec3(.1031, .1030, .0973)); + p3 += dot(p3, p3.yxz+33.33); + return fract((p3.xxy+p3.yzz)*p3.zyx); +} + +mat2 Rot(float a) { + float s=sin(a), c=cos(a); + return mat2(c, -s, s, c); +} + +float opExtrusion( in vec3 p, in float sdf, in float h ) +{ + vec2 w = vec2( sdf, abs(p.z) - h); + return min(max(w.x,w.y),0.0) + length(max(w,0.0)); +} + +float sdCog2d(vec2 pos) { + float r = length(pos)*2.; + float a = atan(pos.y,pos.x); + float f = 1. - smoothstep(-0.2, .8, sin(a * 12.))*0.14; + f = smoothstep(f,f + 2.,r); + return f; +} + +float sdCog(vec3 pos, float angle) { + pos.xy *= Rot(angle); + float d1 = opExtrusion(pos, sdCog2d(pos.xy), 0.05); + float d2 = fCapsule(pos, vec3(0., 0.0, 0.), vec3(0., 0., 1.), 0.2); + return 0.8 * fOpDifferenceRound(d1,d2,0.05)-0.003; +} + +float sdText(vec3 pos, float angle) { + //pos.xy *= Rot(angle); + vec3 color = texture2D(texts, getUV(vec2( 0.,0.))).rgb; + + //gl_FragColor = vec4(vec3(color), 1.); + + //float d1 = opExtrusion(pos, , 0.1); + return 0.; +// return d1; +} + + +float sdHex(vec3 pos, float i, float angle) { + vec3 po = pos; + + po.xz *= Rot(angle); + po.yz *= Rot(angle); + pR(po.yz, PI/2.); + + float d1 = fHexagonCircumcircle(po, vec2(0.5+i, .1)); + float d2 = fHexagonCircumcircle(po, vec2(0.2+i, .1)); + return fOpDifferenceRound(d1,d2,0.1); + +} + +// Scene +vec2 mapScene(in vec3 p) { + float mat = 0.; + float d = 1e10; + + //float dGround = p.y + 2.5; + //d = min(d, dGround); + + vec3 po = p; + //po.y += sin(u_time); + // pMod3(po, vec3(3.)); + po.xy *= scale(vec2(1.3, 1.3)); + + const float num = 6.; + for (float i = 1.; i <= num; i++) { + // pos.z += i*.1; + float a = sdHex(po,i*0.35, u_time + abs( 2. + 0.4 * sin(u_time)) * i*3.1415/num); + d = min(d,a); + if (d == a) mat = 1. + mod(i,3.); + } + + + //float c2 = sdText(p, u_time); + //d = min(d, c2); + //if ( d == c2) mat = 4.; + + // float c3 = fBox(p+vec3(0.5, .87, 0.), vec3(1., 1.,1.)); + // d = min(d, c3); + + + + // if ( d == c1) mat = 1.; + + //if ( d == c3) mat = 3.; + + return vec2(d, mat); +} + +vec3 castRay(vec3 ro, vec3 rd, inout vec3 pos) { + float t = 0.0; + float mat = 0.; + float hit = 0.; + for(int i=0; i < 150; i++) { + pos = ro + rd * t; + vec2 res = mapScene(pos); + t += res.x; + mat = res.y; + if (t > 80.) break; + if (res.x < abs(0.001*t) ) { + hit = 1.; + break; + } + } + if (t > 80.) t = -1.0; + return vec3(t, mat, hit); +} + + +vec3 castReflectedRay(vec3 ro, vec3 rd, vec3 pos) { + float t = 0.0; + float mat = 0.; + float hit = 0.; + for(int i=0; i < 50; i++) { + pos = ro + rd * t; + vec2 res = mapScene(pos); + t += res.x; + mat = res.y; + if (t > 40.) break; + if (res.x < abs(0.001*t) ) { + hit = 1.; + break; + } + + } + if (t > 40.) t = -1.0; + return vec3(t, mat, hit); +} + +float softshadow( in vec3 ro, in vec3 rd, float mint, float maxt, float w ) +{ + float res = 1.0; + float t = mint; + for( int i=0; i<40; i++ ) + { + if (t > maxt) break; + float h = mapScene(ro + t*rd).x; + res = min( res, h/(w*t) ); + t += clamp(h, 0.005, 0.50); + if( res < -1.0 || t>maxt ) break; + + } + res = max(res,-1.0); + return 0.25*(1.0+res)*(1.0+res)*(2.0-res); +} + +float castShadow(vec3 ro, vec3 rd) { + float res = 1.0; + float t = 0.001; + for(int i = 0; i < 40; i++) { + float h = mapScene(ro + t* rd).x; + res = min(res, 10.0*h/t); + if (abs(h) < (0.001*t) ) break; + t += h; + if (t > 20.) break; + } + return clamp(res,0., 1.); +} + +vec3 calcNormal(vec3 pos) { + vec2 e = vec2(.001, 0.); + vec3 n = vec3( mapScene(pos+e.xyy).x - mapScene(pos-e.xyy).x, + mapScene(pos+e.yxy).x - mapScene(pos-e.yxy).x, + mapScene(pos+e.yyx).x - mapScene(pos-e.yyx).x + ); + return normalize(n); +} + +vec3 fresnel( vec3 F0, vec3 h, vec3 l ) { + return F0 + ( 1.0 - F0 ) * pow( clamp( 1.0 - dot( h, l ), 0.0, 1.0 ), 5.0 ); +} + +// https://suricrasia.online/blog/shader-functions/ +vec3 eRot(vec3 p, vec3 ax, float ro) { + return mix(dot(ax,p)*ax, p, cos(ro)) + sin(ro)*cross(ax,p); +} + + + +vec3 addPointLight(vec3 light_pos, vec3 light_color, float shininess, vec3 v, vec3 dir, vec3 n, float occ) { + vec3 Ks = vec3( .5454 ); + vec3 Kd = vec3( 1. ); + vec3 ref = reflect( dir, n ); + vec3 vl = normalize( v ); + vec3 diffuse = Kd * vec3( max( 0.0, dot( vl, n ) ) ); + vec3 specular = vec3( max( 0.0, dot( vl, ref ) ) ); + vec3 F = fresnel( Ks, normalize( vl - dir ), vl )*occ; + float shadow = softshadow(v+n*0.01,light_pos, .01, 30., 18.); + //float shadow = castShadow(v + n*0.02, light_pos); + specular = pow( specular, vec3( shininess ) )*occ; + return light_color * mix( diffuse, specular, F ) * shadow; + +} + +float getAmbientOcc(vec3 p, vec3 n) { + float occ = 0.; + float weight = 1.; + for (int i = 0; i < 8; i++) { + float len = 0.01 + 0.02 * float(i*i); + float dist = mapScene(p+n*len).x; + occ += (len - dist) * weight; + weight *=0.85; + } + return 1.0 - clamp(0.6 * occ, 0., 1.); +} + +vec3 shading(vec3 v, vec3 n, vec3 dir, float material) { + float shininess = 1.; + float occ = getAmbientOcc(v,n); + vec3 outMaterial = vec3(0.1529, 0.1529, 0.1529); + + if (material == 0.) { + outMaterial = vec3(0.2863, 0.1059, 0.2431); + shininess = 1.5; + } else if (material == 1.) { + outMaterial = vec3(0.3294, 0.0941, 0.6); + shininess = 0.6; + } else if (material == 2.) { + outMaterial = vec3(0.5804, 0.9647, 1.0); + shininess = 1.; + } else if (material == 3.) { + outMaterial = vec3(0.0, 0.0, 0.0); + shininess = 100.; + } else if (material == 4.) { + outMaterial = vec3(0.9961, 1.0, 0.9922); + shininess = .3; + } + + vec3 lights = vec3(0.); + lights += addPointLight(vec3( 0., -40., -1. ),vec3(0.56, 0.44, 0.18)*2., shininess, v, dir, n, occ); + lights += addPointLight(vec3( -20.,4., 10. ),vec3(0.04, 0.2, 0.71)*2., shininess, v, dir, n, occ); + // lights += addPointLight(vec3( 2., -1.0, -1.0 ),vec3(0.12, 0.51, 0.63)*2., shininess, v,dir,n,occ ); + + + vec3 lightDir = vec3(0. , 4., 2.); + float sun_dif = clamp(dot(n, lightDir), 0., 1.); + float shadow = softshadow(v+n*0.01,lightDir, .01, 30., 18.); + lights += vec3(0.6627, 0.7098, 0.8863) * sun_dif*shadow*occ; //* shadow; //* mix( vec3(sun_dif), specular, F ) + + + // final += texture( iChannel0, ref ).rgb * fresnel( Ks, n, -dir ); + // vec3 col = vec3(0.4)* ref.x; + + float ind = clamp( dot( n, normalize(lightDir*vec3(-1.0,.0,-1.0)) ), 0.0, 1.0 ); + lights += vec3(0.1333, 0.1333, 0.1216) * ind *occ; + + return outMaterial * max(vec3(0.), lights); +} + +vec3 postProcess(vec3 col) { + // float random = noise(gl_FragCoord.xy, 0.01+u_time); + // float random2 = noise(gl_FragCoord.xy, .2+u_time); + //col += 0.075*clamp(vec3(0.5*random, 0.5*random2, 0.5*random), 0.02, 1.); // dither + + // Normalized pixel coordinates (from 0 to 1) + vec2 screenCoord = gl_FragCoord.xy/u_resolution.xy; + + // Vignette + float radius = 0.8; + float d = smoothstep(radius, radius-0.4, length(screenCoord-vec2(0.5))); + col = mix(col, col * d, .9); + + // Contrast + float constrast = .5; + col = mix(col, smoothstep(0.0, 1.0, col), constrast); + + + // Colour mapping + col *= vec3(1.0, 1.0, 1.0); + + col = pow( col, vec3(1.0/2.2) ); // gamma + + // fade in at the beginning + //col*=vec3(clamp((u_time-1.8)*0.5,0., 1.)); + + // fade out at the end + // col*=vec3(clamp((120.-u_time)*.35, 0., 1.)); + + return col; +} + +vec3 getCameraRayDir(vec2 uv, vec3 camPos, vec3 camTarget) +{ + // Calculate camera's "orthonormal basis", i.e. its transform matrix components + vec3 camForward = normalize(camTarget-camPos ); + vec3 camRight = normalize(cross(vec3(.0, 1.0, 0.0), camForward)); + vec3 camUp = normalize(cross(camForward, camRight)); + float fov = 0.7; + vec3 vDir = normalize(uv.x * camRight + uv.y * camUp + camForward * fov); + return vDir; +} + + +vec3 getCameraRayDir2(vec2 uv, vec3 camPos, vec3 lookAt, float zoom){ + vec3 f = normalize(lookAt - camPos); + vec3 r = cross(vec3(0.0,1.0,0.0),f); + vec3 u = cross(f,r); + vec3 c=camPos+f*zoom; + vec3 i=c+uv.x*r+uv.y*u; + return normalize(i-camPos); +} + +vec3 getCameraFov(vec2 uv, vec3 camPos, vec3 camTarget) { + vec3 camForward = normalize(camTarget-camPos); + vec3 camRight = normalize(cross(vec3(0.0, 1.0, 0.0), camForward)); + vec3 camUp = normalize(cross(camForward,camRight)); + float fov = 1.7; + // Depth of field + float dof = .25; + vec2 h = vec2( noise(gl_FragCoord.xy, .13), noise(gl_FragCoord.xy, .4)); + //vec3 h= rnd23(gl_FragCoord.xy); + vec3 voff = sqrt(h.x)*(camRight*sin(h.y*6.283)+camUp*cos(h.y*6.283))*dof; + // camTarget -=voff; + float focusdistance = 150.2; + return normalize(uv.x * camRight + uv.y * camUp + fov * camForward + voff * fov/focusdistance); +} + +vec3 applyFog(vec3 col, float t, vec3 rd, vec3 lightDir, float b ) { + float fogAmount = 1.0 - exp(-t*b); + float sunAmount = max( dot(rd, lightDir), 0.0 ); + vec3 fogColor = mix( vec3(0.3686, 0.2431, 0.4392), // blue + vec3(0.4, 0.7294, 0.9216), // yellow + pow(sunAmount,8.0) ); + return mix( col, fogColor, fogAmount ); +} + +vec3 render(vec2 uv) { + + bool useDof = !true; + //vec2 uv = (2.0 * gl_FragCoord.xy - u_resolution.xy) / u_resolution.y; + + float angle = -2.4 +u_time*0.4; + //angle = 0.; + + // camera + vec3 camPos = vec3(0., 5., -3.); + vec3 camTarget = vec3(0., 0., 0.); + vec3 rayDir; + + if (useDof) { + rayDir = getCameraFov(uv, camPos, camTarget); + } else { + rayDir = getCameraRayDir2(uv, camPos, camTarget, 1.0); + } + vec3 col = vec3(0.051, 0.0667, 0.1529); + //vec3 col = vec3(0.0314, 0.0118, 0.1255) + rayDir.y * 0.4; + vec3 hitPos = vec3(0.); + + vec3 t = castRay(camPos, rayDir, hitPos); + vec3 rd = rayDir; + + if (t.z > 0.) { + vec3 nor = calcNormal(hitPos); + col = shading(hitPos, nor, rayDir , t.y); + float fogAmount = 0.04; + col = col*exp(-t.x*fogAmount) + applyFog(col, t.x, rd, vec3(0., .3, -1.), fogAmount) * (1.0-exp(-t.x*fogAmount)); + + rayDir = normalize(reflect(rayDir, nor)); + vec3 rayOrigin = hitPos + (rayDir * 0.01); + vec3 t2 = castReflectedRay(rayOrigin, rayDir, hitPos); + + if (t2.z > 0.) { + hitPos = rayOrigin + rayDir * t2.x; + nor = calcNormal(hitPos); + col += 0.1 * shading(hitPos, nor, rayDir , t2.y); + + /* rayDir = normalize(reflect(rayDir, nor)); + rayOrigin = hitPos + (rayDir * 0.01); + vec3 t3 = castReflectedRay(rayOrigin, rayDir, hitPos); + + if (t3.z > 0.) { + hitPos = rayOrigin + rayDir * t3.x; + nor = calcNormal(hitPos); + col += 0.025 * shading(hitPos, nor, rayDir , t3.y); + } */ + } + } + // pixelColor*exp(-distance*b) + fogColor*(1.0-exp(-distance*b)); + + return col; +} + + +void main() +{ + + vec3 finalColor = vec3(0.); + const float AA_SIZE = 1.; + float count = 0.0; +/* + for (float aaY = 0.0; aaY < AA_SIZE; aaY++) { + for (float aaX = 0.0; aaX < AA_SIZE; aaX++) { + finalColor += render(getUV(vec2( aaX, aaY))); + count += 1.0; + } + } + finalColor /= count; */ + finalColor += render(getUV(vec2( 0.,0.))); + + finalColor = postProcess(finalColor); + + gl_FragColor = vec4(finalColor, 1.); + +} \ No newline at end of file diff --git a/shader.glsl b/shader.glsl index ed2c920..84cbeb8 100644 --- a/shader.glsl +++ b/shader.glsl @@ -1,3 +1,4 @@ +//precision mediump float; uniform vec2 u_resolution; uniform float u_time; uniform sampler2D texture_sampler; @@ -36,7 +37,7 @@ float noise( in vec2 p, float scale ) vec2 f = fract( p ); vec2 u = f*f*(3.0-2.0*f); return -scale+scale*mix( mix( hash( i + vec2(0.0,0.0) ), - hash( i + vec2(1.0,0.0) ), u.x), + hash( i + vec2(1.0,0.0) ), u.x), mix( hash( i + vec2(0.0,1.0) ), hash( i + vec2(1.0,1.0) ), u.x), u.y); } @@ -44,7 +45,7 @@ float noise( in vec2 p, float scale ) float displacement( vec3 p ) { - return noise(10.*p.xy+u_time, 0.2) + 0.5*noise(10.*(p.xy+2.0)-u_time, 0.2); + return noise(10.*p.xy+u_time+999., 0.4) + 0.5*noise(10.*(p.xz+2.0)-u_time+999., 0.4); } ///////////////// @@ -109,39 +110,33 @@ float ringRotateFunc(float d, float s, float timeFact) { float startTime = s; float phase = ((u_time * timeFact) - startTime) / TWOPI; phase = min(phase, maxCycles); -return TWOPI * phase; + return TWOPI * phase; } // Animate ring movements vec3 ringAnim( in vec3 p) { + const float STARTDELAY = 9.0; -const float STARTDELAY = 2.0; + float factor = 9.0+9.0*clamp(sin(ringRotateFunc(2.0, 0.0, 1.0) * 0.05), -0.9, 0.9); + // delay start + if( u_time >= STARTDELAY ) { + p.xy = rot2D(factor) * p.xy; + } -float factor = 9.0+9.0*clamp(sin(ringRotateFunc(2.0, 0.0, 1.0) * 0.05), -0.9, 0.9); + if(u_time >= 14.0) { + factor = 9.0+9.0*clamp(sin(ringRotateFunc(2.0, 14.0, 1.0) * 0.05), -0.9, 0.9); + p.xy = rot2D(factor * -1.0) * p.xy; + } -// delay start -if( u_time >= STARTDELAY ) { - factor = 9.0+9.0*clamp(sin(ringRotateFunc(2.0, 0.0, 1.0) * 0.05), -0.9, 0.9); - p.xy = rot2D(factor) * p.xy; -} - -if(u_time >= 14.0) { -factor = 9.0+9.0*clamp(sin(ringRotateFunc(2.0, 14.0, 1.0) * 0.05), -0.9, 0.9); -p.xy = rot2D(factor * -1.0) * p.xy; -} - -return p; + return p; } // Animate prism movements float prismAnim(in float x, in float delay) { - - -if(u_time >= delay) { -x += (0.045*clamp(sin((ringRotateFunc(2.4, delay*10.0, 10.0) * 0.4)),-0.9, 0.9)); -} - -return x; + if(u_time >= delay) { + x += (0.045*clamp(sin((ringRotateFunc(2.4, delay*10.0, 10.0) * 0.4)),-0.9, 0.9)); + } + return x; } @@ -149,7 +144,7 @@ return x; // SCENE // ////////////// -vec2 map( in vec3 p) +vec2 map(in vec3 p) { float mat = 0.; // Stargate @@ -162,8 +157,8 @@ vec2 map( in vec3 p) q.xy = mat2(cos(angrot),-sin(angrot), sin(angrot), cos(angrot))*q.xy; float d = sdBox( q.xy - vec2(1.8,0.0), vec2(0.24,0.14) ) - 0.02; - - // Main ring + + // Main ring float d2 = abs(length(p.xy) - 1.8) - 0.2; d = min(d,d2); @@ -174,13 +169,11 @@ vec2 map( in vec3 p) // Depth slice rings d = smax( d, abs(p.z)-0.1, 0.02 ); - + // Prisms float index = 1.0; for(int i=0; i<8; i++ ) { - - //vec3 p2 = prismAnim(p); - + float secDist = TWOPI / 8.0; // sector distance float angle = ((24.67 / TWOPI )); // sector size vec3 q = p; @@ -194,30 +187,25 @@ vec2 map( in vec3 p) rotationIncrement = rotationIncrement - 0.2; } - float prismSector = floor(atan(p.y,p.x)/(rotationIncrement) + 0.5); + // float prismSector = floor(atan(p.y,p.x)/(rotationIncrement) + 0.5); q.xy = rot2D(rotationIncrement) * q.xy; // We can now call each prism by it's index // draw all except the middle bottom prism - if (i > 0) { - - q.x = q.x - 1.95; - - if(i == 1) { - q.x = prismAnim(q.x, 13.0); - } - - if(i == 2) { - q.x = prismAnim(q.x, 26.0); - } + if (i > 0) { + q.x -= 1.95; + q.x = prismAnim(q.x, float(i)*1.); float d4 = sdTriPrism(vec3(q.x, q.y - 0.0 , q.z - 0.0), vec2(0.2,0.2), 0.5) - 0.02; d = min(d, d4); + if (d==d4) { + mat = 4.; + } } index += 1.0; - } - + } + //Rotating glyphs vec3 p2 = ringAnim(p); float an2 = (TWOPI/32.0); @@ -227,8 +215,10 @@ vec2 map( in vec3 p) q2.xy = rot2D(angrot2)*q2.xy; float d5 = sdBox2( q2.xyz - vec3(1.75,0.0,0.0), vec3(0.04, 0.14, 0.05) ) - 0.02; d = min(d, d5); - - + if (d==d5) { + mat = 4.; + } + // Gate Base const float stepHeight = 0.1; float stepDist = 1.5; @@ -245,19 +235,22 @@ vec2 map( in vec3 p) float water = 1000.; if (u_time > 2.0){ float cylinder1 = sdCylinder ( p, vec3(0.,0.,0.0), vec3(0.,0.,-0.01), 1.6); - float cylinder2 = sdCylinder ( p, vec3(0.,0.,1.), vec3(0.,0.,-1), (2. - (u_time*2.0 - 2.0*2.0))); + float cylinder2 = sdCylinder ( p, vec3(0.,0.,0.), vec3(0.,0.,-1), (2. - (u_time*2.0 - 2.0*13.0))); float cylinder3 = sdCylinder ( p, vec3(0.,0.,1.), vec3(0.,0.,-1.), 1.6); float disp = 0.; - if (u_time > 5.0){ - disp = displacement(p+4.)*min(((u_time-5.0)*0.5), 0.25); + if (u_time > 2.0){ + disp = displacement(p)*min(((u_time-14.0)*0.5), 0.25); } cylinder1 = cylinder1 + disp; - water = max(-cylinder2, cylinder1); - water = max(water, cylinder3); + water = max(-cylinder2+disp, cylinder1); + //water = max(water, cylinder3); d = min(d, water); } - if (d==min(water,0.1)) + float sand = (p.y + 4.25) + noise((p.xz*0.04)+100., 9.); + d = min(d,sand); + + if (d==water) { mat = 1.0; } @@ -265,6 +258,10 @@ vec2 map( in vec3 p) { mat = 2.0; } + else if (d==sand) { + mat = 3.0; + } + return vec2( d, mat ); } @@ -273,22 +270,18 @@ vec2 map( in vec3 p) //////////////// float rayMarch(vec3 ro, vec3 rd) { - float t = 0.; // total distance travelled float d; // Raymarching - for (int i = 0; i < 80; i++) { + for (int i = 0; i < 200; i++) { vec3 p = ro + rd * t; // "cast" rays - d = map(p).x; // Get distance to objects - - t += d; // "march" the ray - - if (d< .001 || t>100.) break; + if (abs(d) < .001 || t > 800.) break; } return t; } + vec3 getNormal(vec3 p) { float d = map(p).x; vec2 e = vec2(.01, 0); @@ -303,17 +296,25 @@ vec3 getNormal(vec3 p) { float getLight(vec3 p, vec3 lightPos, float intensity, float shadow) { vec3 l = normalize(lightPos - p); vec3 n = getNormal(p); - float dif = clamp(dot(n, l), 0., intensity); // Shadows float d = rayMarch(p+n*.0025, l); - if(d 0.0) - { - float d = rayMarch(ro, rd); + float d = rayMarch(ro, rd); - if (d < 1000.) - { + if (d < 500.) { // Lighting vec3 p = ro + rd * d; float mat = map(p).y; - // Light 1 - // Light 1 Position - vec3 lightPos1 = vec3( 3, 5, 4); + // Light 1 Arguments // 1: Ray starting point // 2: Light position // 3: Light intensity // 4: Shadow intensity - float dif = getLight(p, lightPos1, 0.75, 0.2); + float dif = 0.; //getLight(p, vec3( 2, 50, 2), .5, .2); // Color for light 1 - col = vec3(dif * vec3(1)); + // col = vec3(dif * vec3(0.9216, 0.9294, 0.9412)); // Light 2 - vec3 lightPos2 = vec3( -3, 5, -4); - dif = getLight(p, lightPos2, 0.75, 0.1); + dif = getLight(p, vec3( -3, 5, 5), 1., 0.2); // Color for light 2 - col += vec3(dif * vec3(0.5,0.2,0.1)); + col += vec3(dif * vec3(0.502, 0.2824, 0.102)); + + dif = getLight(p, vec3( 3, -2, 5), 0.75, .8); + // Color for light 2 + col += vec3(dif * vec3(0.2784, 0.3647, 0.6588)); + + vec3 n = getNormal(p); + vec3 dir = vec3(1. , 10., 1.); + float ind = clamp( dot( n, normalize(dir )), 0.0, 1.0 ); + col += vec3(0.1216, 0.1216, 0.1137) * ind; if(mat==0.){ - col *= vec3(1,1,1); + col *= vec3(.3,0.3,0.3); } else if(mat==1.){ col *= (noise(5.*(p.xy+2.)+u_time, -1.0) * noise(50.*(p.xy+2.), -0.4) + 0.5*noise(20.*(p.xy+2.0)-u_time, -0.5) * noise(5.*(p.xy+2.0), -0.75))*smoothstep(0.,0.75,(u_time-5.0)*0.1) + vec3(0.,0.,0.5*noise(10.*(p.xy+4.0)-u_time, -0.5)) + vec3(0.,0.,0.5); } else if(mat==2.){ - col *= vec3(0.545,0.27,0.074) - 0.2*noise((vec2(100.*p.x+300.,75.*p.z+150.0)), -2.2) * noise((vec2(15.*p.x+2.0,3.*p.z+2.)), -1.) + noise((vec2(15.*p.x+2.4,3.*p.z+2.)), -0.25); + col *= vec3(0.3608, 0.1765, 0.0471) - 0.2*noise((vec2(100.*p.x+300.,75.*p.z+150.0)), -2.2) * noise((vec2(15.*p.x+2.0,3.*p.z+2.)), -1.) + noise((vec2(15.*p.x+2.4,3.*p.z+2.)), -0.25); } + else if(mat==3.){ + col *= vec3(0.8471, 0.8549, 0.4667) + noise(p.yz*1000., 0.1) + noise(p.xy*1000., 0.1); + } + else if(mat==4.){ + col *= vec3(.1,0.1,0.1); + } + + float fogAmount = 0.02; + col = col*exp(-d*fogAmount) + applyFog(col, d, rd, vec3(0., .3, -1.), fogAmount) * (1.0-exp(-d*fogAmount)); + + } else { + col = vec3(0.1529, 0.1765, 0.3922) + rd.y * 0.4; } - gl_FragColor = vec4(col, 1); - } - - else { - - // ************* post-process pass ****************** - // Uncomment this to try a post-processing "effect" - - gl_FragColor = texture2D(texture_sampler, (gl_FragCoord.xy / u_resolution )); - - } + + gl_FragColor = vec4(postProcess(col), 1); + } diff --git a/shader_minified.h b/shader_minified.h index 4df6b92..0a05c3c 100644 --- a/shader_minified.h +++ b/shader_minified.h @@ -1,15 +1,15 @@ // Generated with Shader Minifier 1.3.6 (https://github.com/laurentlb/Shader_Minifier/) #ifndef SHADER_MINIFIED_H_ # define SHADER_MINIFIED_H_ -# define VAR_texts "a" -# define VAR_texture_sampler "f" +# define VAR_texts "f" +# define VAR_texture_sampler "x" # define VAR_u_resolution "y" # define VAR_u_time "v" const char *__temp_cleaned_shader_glsl = "uniform vec2 y;" "uniform float v;" - "uniform sampler2D f,a;" + "uniform sampler2D x,f;" "mat2 n(float v)" "{" "float f=sin(v),y=cos(v);" @@ -17,8 +17,8 @@ const char *__temp_cleaned_shader_glsl = "}" "float n(float v,float y,float x)" "{" - "float f=max(x-abs(v-y),0.);" - "return max(v,y)+f*f*.25/x;" + "float m=max(x-abs(v-y),0.);" + "return max(v,y)+m*m*.25/x;" "}" "float s(vec2 v)" "{" @@ -27,31 +27,31 @@ const char *__temp_cleaned_shader_glsl = "}" "float n(vec2 v,float y)" "{" - "vec2 f=floor(v),m=fract(v),a=m*m*(3.-2.*m);" - "return-y+y*mix(mix(s(f+vec2(0)),s(f+vec2(1,0)),a.x),mix(s(f+vec2(0,1)),s(f+vec2(1)),a.x),a.y);" + "vec2 m=floor(v),a=fract(v),f=a*a*(3.-2.*a);" + "return-y+y*mix(mix(s(m+vec2(0)),s(m+vec2(1,0)),f.x),mix(s(m+vec2(0,1)),s(m+vec2(1)),f.x),f.y);" "}" "float m(vec3 y)" "{" - "return n(10.*y.xy+v,.2)+.5*n(10.*(y.xy+2.)-v,.2);" + "return n(10.*y.xy+v+999.,.4)+.5*n(10.*(y.xz+2.)-v+999.,.4);" "}" - "float m(vec3 v,vec3 y,vec3 m,float x)" + "float m(vec3 v,vec3 m,float y)" "{" - "vec3 f=m-y,a=v-y;" - "float s=dot(f,f),c=dot(a,f),n=length(a*s-f*c)-x*s,h=abs(c-s*.5)-s*.5,i=n*n,z=h*h*s,g=max(n,h)<0.?" - "-min(i,z):" + "vec3 x=vec3(0),f=m-x,a=v-x;" + "float s=dot(f,f),c=dot(a,f),n=length(a*s-f*c)-y*s,z=abs(c-s*.5)-s*.5,i=n*n,l=z*z*s,d=max(n,z)<0.?" + "-min(i,l):" "(n>0.?" "i:" - "0.)+(h>0.?" - "z:" + "0.)+(z>0.?" + "l:" "0.);" - "return sign(g)*sqrt(abs(g))/s;" + "return sign(d)*sqrt(abs(d))/s;" "}" "float m(vec3 v,vec3 y)" "{" "vec3 f=abs(v)-y;" "return length(max(f,0.))+min(max(f.x,max(f.y,f.z)),0.);" "}" - "float x(vec3 v)" + "float p(vec3 v)" "{" "vec2 f=vec2(.2);" "v.xy*=n(.5);" @@ -63,154 +63,174 @@ const char *__temp_cleaned_shader_glsl = "if(v.x+y*v.y>0.)" "v.xy=vec2(v.x-y*v.y,-y*v.x-v.y)/2.;" "v.x-=clamp(v.x,-2.,0.);" - "float x=length(v.xy)*sign(-v.y)*f.x,a=abs(v.z)-f.y;" - "return length(max(vec2(x,a),0.))+min(max(x,a),0.);" + "float m=length(v.xy)*sign(-v.y)*f.x,a=abs(v.z)-f.y;" + "return length(max(vec2(m,a),0.))+min(max(m,a),0.);" "}" - "float m(float y,float x,float f)" + "float p(float y,float x,float a)" "{" - "float i=(v*f-x)/(2.*acos(-1.));" - "i=min(i,y);" - "return 2.*acos(-1.)*i;" + "float f=(v*a-x)/(2.*acos(-1.));" + "f=min(f,y);" + "return 2.*acos(-1.)*f;" "}" "vec3 t(vec3 y)" "{" - "float f=9.+9.*clamp(sin(m(2.,0.,1.)*.05),-.9,.9);" - "if(v>=2.)" - "f=9.+9.*clamp(sin(m(2.,0.,1.)*.05),-.9,.9),y.xy=n(f)*y.xy;" + "float f=9.+9.*clamp(sin(p(2.,0.,1.)*.05),-.9,.9);" + "if(v>=9.)" + "y.xy=n(f)*y.xy;" "if(v>=14.)" - "f=9.+9.*clamp(sin(m(2.,14.,1.)*.05),-.9,.9),y.xy=n(f*-1.)*y.xy;" + "f=9.+9.*clamp(sin(p(2.,14.,1.)*.05),-.9,.9),y.xy=n(f*-1.)*y.xy;" "return y;" "}" - "float s(float y,float f)" + "float p(float y,float f)" "{" "if(v>=f)" - "y+=.045*clamp(sin(m(2.4,f*10.,10.)*.4),-.9,.9);" + "y+=.045*clamp(sin(p(2.4,f*10.,10.)*.4),-.9,.9);" "return y;" "}" - "vec2 h(vec3 y)" + "vec2 a(vec3 f)" "{" - "float f=0.;" - "const float a=2.*acos(-1.)/24.;" - "float i=floor(atan(y.y,y.x)/a+.5)*a;" - "vec3 r=y;" - "r.xy=mat2(cos(i),-sin(i),sin(i),cos(i))*r.xy;" - "float c=length(max(abs(r.xy-vec2(1.8,0))-vec2(.24,.14),0.))-.02;" - "c=min(c,abs(length(y.xy)-1.8)-.2);" - "float g=abs(length(y.xy)-1.75)-.08;" - "g=n(g,abs(y.z-.1)-.04,.005);" - "c=max(-g,c);" - "c=n(c,abs(y.z)-.1,.02);" - "float h=1.;" - "for(int l=0;l<8;l++)" + "float y=0.;" + "const float x=2.*acos(-1.)/24.;" + "float a=floor(atan(f.y,f.x)/x+.5)*x;" + "vec3 i=f;" + "i.xy=mat2(cos(a),-sin(a),sin(a),cos(a))*i.xy;" + "float s=length(max(abs(i.xy-vec2(1.8,0))-vec2(.24,.14),0.))-.02;" + "s=min(s,abs(length(f.xy)-1.8)-.2);" + "float r=abs(length(f.xy)-1.75)-.08;" + "r=n(r,abs(f.z-.1)-.04,.005);" + "s=max(-r,s);" + "s=n(s,abs(f.z)-.1,.02);" + "float z=1.;" + "for(int c=0;c<8;c++)" "{" - "vec3 z=y;" - "float b=24.67/(2.*acos(-1.))+h*(2.*acos(-1.)/8.);" - "if(l==1)" - "b+=.2;" - "if(l==7)" - "b-=.2;" - "z.xy=n(b)*z.xy;" - "if(l>0)" + "vec3 d=f;" + "float l=24.67/(2.*acos(-1.))+z*(2.*acos(-1.)/8.);" + "if(c==1)" + "l+=.2;" + "if(c==7)" + "l-=.2;" + "d.xy=n(l)*d.xy;" + "if(c>0)" "{" - "z.x=z.x-1.95;" - "if(l==1)" - "z.x=s(z.x,13.);" - "if(l==2)" - "z.x=s(z.x,26.);" - "float p=x(vec3(z))-.02;" - "c=min(c,p);" + "d.x-=1.95;" + "d.x=p(d.x,float(c));" + "float h=p(vec3(d))-.02;" + "s=min(s,h);" + "if(s==h)" + "y=4.;" "}" - "h+=1.;" + "z+=1.;" "}" - "vec3 l=t(y);" - "float z=2.*acos(-1.)/32.;" - "vec3 b=l;" - "b.xy=n(floor(atan(l.y,l.x)/z+.5)*z)*b.xy;" - "float p=m(b.xyz-vec3(1.75,0,0),vec3(.04,.14,.05))-.02;" - "c=min(c,p);" - "float e=1.5,u=1e3;" - "for(int C=0;C<4;C++)" + "vec3 d=t(f);" + "float c=2.*acos(-1.)/32.;" + "vec3 l=d;" + "l.xy=n(floor(atan(d.y,d.x)/c+.5)*c)*l.xy;" + "float h=m(l.xyz-vec3(1.75,0,0),vec3(.04,.14,.05))-.02;" + "s=min(s,h);" + "if(s==h)" + "y=4.;" + "float e=1.5,g=1e3;" + "for(int u=0;u<4;u++)" "{" - "float D=m(vec3(y.x,y.y+e,y.z),vec3(2,.1,e))-.05;" - "u=min(u,D);" - "c=min(c,D);" + "float C=m(vec3(f.x,f.y+e,f.z),vec3(2,.1,e))-.05;" + "g=min(g,C);" + "s=min(s,C);" "e+=.2;" "}" - "float D=1e3;" + "float C=1e3;" "if(v>2.)" "{" - "float C=m(y,vec3(0),vec3(0,0,-.01),1.6),F=m(y,vec3(0,0,1),vec3(0,0,-1),2.-v*2.+4.),E=m(y,vec3(0,0,1),vec3(0,0,-1),1.6),d=0.;" - "if(v>5.)" - "d=m(y+4.)*min((v-5.)*.5,.25);" - "C+=d;" - "D=max(-F,C);" - "D=max(D,E);" - "c=min(c,D);" + "float u=m(f,vec3(0,0,-.01),1.6),D=m(f,vec3(0,0,-1),2.-v*2.+26.),b=0.;" + "if(v>2.)" + "b=m(f)*min((v-14.)*.5,.25);" + "u+=b;" + "C=max(-D+b,u);" + "s=min(s,C);" "}" - "if(c==min(D,.1))" - "f=1.;" - "else if(c==min(u,.1))" - "f=2.;" - "return vec2(c,f);" + "float u=f.y+4.25+n(f.xz*.04+1e2,9.);" + "s=min(s,u);" + "if(s==C)" + "y=1.;" + "else if(s==min(g,.1))" + "y=2.;" + "else if(s==u)" + "y=3.;" + "return vec2(s,y);" "}" - "float h(vec3 y,vec3 v)" + "float a(vec3 v,vec3 y)" "{" - "float f=0.,c;" - "for(int i=0;i<80;i++)" + "float f=0.,s;" + "for(int i=0;i<200;i++)" "{" - "vec3 x=y+v*f;" - "c=h(x).x;" - "f+=c;" - "if(c<.001||f>1e2)" + "vec3 m=v+y*f;" + "s=a(m).x;" + "f+=s;" + "if(abs(s)<.001||f>8e2)" "break;" "}" "return f;" "}" - "vec3 p(vec3 v)" + "vec3 h(vec3 v)" "{" - "float f=h(v).x;" - "vec2 y=vec2(.01,0);" - "vec3 c=f-vec3(h(v-y.xyy).x,h(v-y.yxy).x,h(v-y.yyx));" - "return normalize(c);" + "float m=a(v).x;" + "vec2 f=vec2(.01,0);" + "vec3 y=m-vec3(a(v-f.xyy).x,a(v-f.yxy).x,a(v-f.yyx));" + "return normalize(y);" "}" - "float h(vec3 v,vec3 y,float f)" + "float a(vec3 v,vec3 f,float y,float m)" "{" - "vec3 c=normalize(y-v),x=p(v);" - "float i=clamp(dot(x,c),0.,.75),a=h(v+x*.0025,c);" - "if(a0.)" + "vec2 f=(gl_FragCoord.xy*2.-y.xy)/y.y;" + "vec3 s=vec3(0,2,6);" + "s.yz*=n(sin(v)*.5);" + "s.xz*=n(cos(v)*.5);" + "vec3 m=h(f,s),x=vec3(0);" + "float c=a(s,m);" + "if(c<5e2)" "{" - "float l=h(x,a);" - "if(l<1e3)" - "{" - "vec3 z=x+a*l;" - "float m=h(z).y,r=h(z,vec3(3,5,4),.2);" - "i=vec3(r*vec3(1));" - "r=h(z,vec3(-3,5,-4),.1);" - "i+=vec3(r*vec3(.5,.2,.1));" - "if(m==0.)" - "i*=vec3(1);" - "else if(m==1.)" - "i*=(n(5.*(z.xy+2.)+v,-1.)*n(50.*(z.xy+2.),-.4)+.5*n(20.*(z.xy+2.)-v,-.5)*n(5.*(z.xy+2.),-.75))*smoothstep(0.,.75,(v-5.)*.1)+vec3(0,0,.5*n(10.*(z.xy+4.)-v,-.5))+vec3(0,0,.5);" - "else if(m==2.)" - "i*=vec3(.545,.27,.074)-.2*n(vec2(1e2*z.x+3e2,75.*z.z+150.),-2.2)*n(vec2(15.*z.x+2.,3.*z.z+2.),-1.)+n(vec2(15.*z.x+2.4,3.*z.z+2.),-.25);" - "}" - "gl_FragColor=vec4(i,1);" + "vec3 d=s+m*c;" + "float l=a(d).y,r=0.;" + "r=a(d,vec3(-3,5,5),1.,.2);" + "x+=vec3(r*vec3(.502,.2824,.102));" + "r=a(d,vec3(3,-2,5),.75,.8);" + "x+=vec3(r*vec3(.2784,.3647,.6588));" + "vec3 g=h(d);" + "x+=vec3(.1216,.1216,.1137)*clamp(dot(g,normalize(vec3(1,10,1))),0.,1.);" + "if(l==0.)" + "x*=vec3(.3);" + "else if(l==1.)" + "x*=(n(5.*(d.xy+2.)+v,-1.)*n(50.*(d.xy+2.),-.4)+.5*n(20.*(d.xy+2.)-v,-.5)*n(5.*(d.xy+2.),-.75))*smoothstep(0.,.75,(v-5.)*.1)+vec3(0,0,.5*n(10.*(d.xy+4.)-v,-.5))+vec3(0,0,.5);" + "else if(l==2.)" + "x*=vec3(.3608,.1765,.0471)-.2*n(vec2(1e2*d.x+3e2,75.*d.z+150.),-2.2)*n(vec2(15.*d.x+2.,3.*d.z+2.),-1.)+n(vec2(15.*d.x+2.4,3.*d.z+2.),-.25);" + "else if(l==3.)" + "x*=vec3(.8471,.8549,.4667)+n(d.yz*1e3,.1)+n(d.xy*1e3,.1);" + "else if(l==4.)" + "x*=vec3(.1);" + "x=x*exp(-c*.02)+mix(x,mix(vec3(.2667,.2941,.3451),vec3(.302,.3176,.3725),pow(max(dot(m,vec3(0,.3,-1)),0.),8.)),1.-exp(-c*.02))*(1.-exp(-c*.02));" "}" "else" - " gl_FragColor=texture2D(f,gl_FragCoord.xy/y);" + " x=vec3(.1529,.1765,.3922)+m.y*.4;" + "gl_FragColor=vec4(i(x),1);" "}"; #endif // SHADER_MINIFIED_H_ diff --git a/shader_new.glsl b/shader_new.glsl new file mode 100644 index 0000000..bd45016 --- /dev/null +++ b/shader_new.glsl @@ -0,0 +1,444 @@ +precision mediump float; +uniform vec2 u_resolution; +uniform float u_time; +uniform sampler2D texture_sampler; +uniform sampler2D texts; + +// Rotate +mat2 rot2D(float angle) { + float s = sin(angle); + float c = cos(angle); + return mat2(c, -s, s, c); +} + +// Exponential smoothing +float smin( float a, float b, float k ) +{ + k *= 1.0; + float r = exp2(-a/k) + exp2(-b/k); + return -k*log2(r); +} + +float smax( float a, float b, float k ) +{ + float h = max(k-abs(a-b),0.0); + return max(a, b) + h*h*0.25/k; +} + +float hash(vec2 p) +{ + p = 50.*fract( p*0.3183099); + return fract( p.x*p.y*(p.x+p.y) ); +} + +float noise( in vec2 p, float scale ) +{ + vec2 i = floor( p ); + vec2 f = fract( p ); + vec2 u = f*f*(3.0-2.0*f); + return -scale+scale*mix( mix( hash( i + vec2(0.0,0.0) ), + hash( i + vec2(1.0,0.0) ), u.x), + mix( hash( i + vec2(0.0,1.0) ), + hash( i + vec2(1.0,1.0) ), u.x), u.y); +} + + +float displacement( vec3 p ) +{ + return noise(10.*p.xy+u_time, 0.2) + 0.5*noise(10.*(p.xy+2.0)-u_time, 0.2); +} + +///////////////// +// GEOMETRY // +///////////////// + +float sdCylinder(vec3 p, vec3 a, vec3 b, float r) +{ + vec3 ba = b - a; + vec3 pa = p - a; + float baba = dot(ba,ba); + float paba = dot(pa,ba); + float x = length(pa*baba-ba*paba) - r*baba; + float y = abs(paba-baba*0.5)-baba*0.5; + float x2 = x*x; + float y2 = y*y*baba; + + float d = (max(x,y)<0.0)?-min(x2,y2):(((x>0.0)?x2:0.0)+((y>0.0)?y2:0.0)); + + return sign(d)*sqrt(abs(d))/baba; +} + +float sdBox( in vec2 p, in vec2 r ) +{ + return length( max(abs(p)-r,0.0) ); +} + +float sdBox2(vec3 p, vec3 b) { + vec3 q = abs(p) - b; + return length(max(q,0.0)) + min(max(q.x,max(q.y,q.z)),0.0); +} + +float sdSphere(vec3 p, float r){ + return length(p) -r; +} + +float sdTriPrism( vec3 p, vec2 h, float rot ) +{ + p.xy *= rot2D(rot); + const float k = sqrt(3.0); + h.x *= 0.5*k; + p.xy /= h.x; + p.x = abs(p.x) - 1.0; + p.y = p.y + 1.0/k; + if( p.x+k*p.y>0.0 ) p.xy=vec2(p.x-k*p.y,-k*p.x-p.y)/2.0; + p.x -= clamp( p.x, -2.0, 0.0 ); + float d1 = length(p.xy)*sign(-p.y)*h.x; + float d2 = abs(p.z)-h.y; + + return length(max(vec2(d1,d2),0.0)) + min(max(d1,d2), 0.); +} + + +////////////////// +// ANIMATION // +////////////////// +const float TWOPI = 6.28318530718; + +// Rotate ring with duration d and startTime s +float ringRotateFunc(float d, float s, float timeFact) { + float maxCycles = d; + float startTime = s; + float phase = ((u_time * timeFact) - startTime) / TWOPI; + phase = min(phase, maxCycles); + return TWOPI * phase; +} + +// Animate ring movements +vec3 ringAnim( in vec3 p) { + const float STARTDELAY = 2.0; + + float factor = 9.0+9.0*clamp(sin(ringRotateFunc(2.0, 0.0, 1.0) * 0.05), -0.9, 0.9); + + // delay start + if( u_time >= STARTDELAY ) { + factor = 9.0+9.0*clamp(sin(ringRotateFunc(2.0, 0.0, 1.0) * 0.05), -0.9, 0.9); + p.xy = rot2D(factor) * p.xy; + } + + if(u_time >= 14.0) { + factor = 9.0+9.0*clamp(sin(ringRotateFunc(2.0, 14.0, 1.0) * 0.05), -0.9, 0.9); + p.xy = rot2D(factor * -1.0) * p.xy; + } + + return p; +} + +// Animate prism movements +float prismAnim(in float x, in float delay) { + if(u_time >= delay) { + x += (0.045*clamp(sin((ringRotateFunc(2.4, delay*10.0, 10.0) * 0.4)),-0.9, 0.9)); + } + return x; +} + + +////////////// +// SCENE // +////////////// + +vec2 map(in vec3 p) +{ + float mat = 0.; + // Stargate + + // Ring boxes + const float an = TWOPI/24.0; + float sector = floor(atan(p.y,p.x)/an + 0.5); + float angrot = sector*an; + vec3 q = p; + q.xy = mat2(cos(angrot),-sin(angrot), + sin(angrot), cos(angrot))*q.xy; + float d = sdBox( q.xy - vec2(1.8,0.0), vec2(0.24,0.14) ) - 0.02; + + // Main ring + float d2 = abs(length(p.xy) - 1.8) - 0.2; + d = min(d,d2); + + // Inner ring + float d3 = abs(length(p.xy) - 1.75) - 0.08; + d3 = smax( d3, abs(p.z - 0.1)-0.04, 0.005 ); + d = max(-d3,d); + + // Depth slice rings + d = smax( d, abs(p.z)-0.1, 0.02 ); + + // Prisms + float index = 1.0; + for(int i=0; i<8; i++ ) { + + //vec3 p2 = prismAnim(p); + + float secDist = TWOPI / 8.0; // sector distance + float angle = ((24.67 / TWOPI )); // sector size + vec3 q = p; + float rotationIncrement = angle + (index * secDist); + + // Nudge first and the last prism out of the ground + if (i == 1) { + rotationIncrement = rotationIncrement + 0.2; + } + if (i == 7) { + rotationIncrement = rotationIncrement - 0.2; + } + + float prismSector = floor(atan(p.y,p.x)/(rotationIncrement) + 0.5); + q.xy = rot2D(rotationIncrement) * q.xy; + + // We can now call each prism by it's index + // draw all except the middle bottom prism + if (i > 0) { + + q.x = q.x - 1.95; + + if(i == 1) { + q.x = prismAnim(q.x, 13.0); + } + + if(i == 2) { + q.x = prismAnim(q.x, 26.0); + } + + float d4 = sdTriPrism(vec3(q.x, q.y - 0.0 , q.z - 0.0), vec2(0.2,0.2), 0.5) - 0.02; + d = min(d, d4); + } + + index += 1.0; + } + + //Rotating glyphs + vec3 p2 = ringAnim(p); + float an2 = (TWOPI/32.0); + float sector2 = floor((atan(p2.y,p2.x)/an2) + 0.5 ); + float angrot2 = sector2*an2; + vec3 q2 = p2; + q2.xy = rot2D(angrot2)*q2.xy; + float d5 = sdBox2( q2.xyz - vec3(1.75,0.0,0.0), vec3(0.04, 0.14, 0.05) ) - 0.02; + d = min(d, d5); + + + // Gate Base + const float stepHeight = 0.1; + float stepDist = 1.5; + const float stepWidth = 2.0; + float steps = 1000.; + + for(int i = 0; i < 4; i++) { + float step = sdBox2(vec3(p.x,p.y+stepDist,p.z), vec3(stepWidth,stepHeight,stepDist)) - 0.05; + steps = min(steps, step); + d = min(d, step); + stepDist += stepHeight * 2.0; + } + + float water = 1000.; + if (u_time > 2.0){ + float cylinder1 = sdCylinder ( p, vec3(0.,0.,0.0), vec3(0.,0.,-0.01), 1.6); + float cylinder2 = sdCylinder ( p, vec3(0.,0.,1.), vec3(0.,0.,-1), (2. - (u_time*2.0 - 2.0*2.0))); + float cylinder3 = sdCylinder ( p, vec3(0.,0.,1.), vec3(0.,0.,-1.), 1.6); + float disp = 0.; + if (u_time > 5.0){ + disp = displacement(p+4.)*min(((u_time-5.0)*0.5), 0.25); + } + cylinder1 = cylinder1 + disp; + water = max(-cylinder2, cylinder1); + water = max(water, cylinder3); + d = min(d, water); + } + + if (d==min(water,0.1)) + { + mat = 1.0; + } + else if (d==min(steps, 0.1)) + { + mat = 2.0; + } + return vec2( d, mat ); +} + +//////////////// +// DRAWING // +//////////////// + +float rayMarch(vec3 ro, vec3 rd) { + float t = 0.; // total distance travelled + float d; + // Raymarching + for (int i = 0; i < 50; i++) { + vec3 p = ro + rd * t; // "cast" rays + d = map(p).x; // Get distance to objects + t += d; // "march" the ray + if (abs(d) < .001 || t > 80.) break; + } + return t; +} + +vec3 getNormal(vec3 p) { + float d = map(p).x; + vec2 e = vec2(.01, 0); + + vec3 n = d - vec3( + map(p-e.xyy).x, + map(p-e.yxy).x, + map(p-e.yyx).x); + return normalize(n); +} + +float getLight(vec3 p, vec3 lightPos, float intensity, float shadow) { + vec3 l = normalize(lightPos - p); + vec3 n = getNormal(p); + float dif = clamp(dot(n, l), 0., intensity); + + // Shadows + float d = rayMarch(p+n*.0025, l); + if( d 0.0) + { + float d = rayMarch(ro, rd); + + if (d < 25.) + { + // Lighting + vec3 p = ro + rd * d; + + float mat = map(p).y; + + // Light 1 Arguments + // 1: Ray starting point + // 2: Light position + // 3: Light intensity + // 4: Shadow intensity + float dif = getLight(p, vec3( 2, 50, 2), .5, .2); + // Color for light 1 + // col = vec3(dif * vec3(0.9216, 0.9294, 0.9412)); + + // Light 2 + dif = getLight(p, vec3( -3, 5, 5), 1., 0.2); + // Color for light 2 + col += vec3(dif * vec3(0.502, 0.2824, 0.102)); + + dif = getLight(p, vec3( 3, -2, 5), 0.5, .8); + // Color for light 2 + col += vec3(dif * vec3(0.1686, 0.2784, 0.6392)); + + vec3 n = getNormal(p); + float occ = getAmbientOcc(p,n); + vec3 dir = vec3(1. , 10., 1.); + float ind = clamp( dot( n, normalize(dir )), 0.0, 1.0 ); + col += vec3(0.1255, 0.1255, 0.1137) * occ * ind; + + if(mat==0.){ + col *= vec3(.7,0.7,0.7); + } + else if(mat==1.){ + col *= (noise(5.*(p.xy+2.)+u_time, -1.0) * noise(50.*(p.xy+2.), -0.4) + 0.5*noise(20.*(p.xy+2.0)-u_time, -0.5) * noise(5.*(p.xy+2.0), -0.75))*smoothstep(0.,0.75,(u_time-5.0)*0.1) + vec3(0.,0.,0.5*noise(10.*(p.xy+4.0)-u_time, -0.5)) + vec3(0.,0.,0.5); + } + else if(mat==2.){ + col *= vec3(0.3608, 0.1765, 0.0471) - 0.2*noise((vec2(100.*p.x+300.,75.*p.z+150.0)), -2.2) * noise((vec2(15.*p.x+2.0,3.*p.z+2.)), -1.) + noise((vec2(15.*p.x+2.4,3.*p.z+2.)), -0.25); + } + + } + + + gl_FragColor = vec4(postProcess(col), 1); + } + + else { + + // ************* post-process pass ****************** + // Uncomment this to try a post-processing "effect" + + gl_FragColor = texture2D(texture_sampler, (gl_FragCoord.xy / u_resolution )); + + } +} diff --git a/shadertoy.glsl b/shadertoy.glsl index 5c34965..2787f6c 100644 --- a/shadertoy.glsl +++ b/shadertoy.glsl @@ -891,7 +891,7 @@ vec3 getCameraFov(vec2 uv, vec3 camPos, vec3 camTarget) { return normalize(uv.x * camRight + uv.y * camUp + fov * camForward + voff * fov/focusdistance); } -vec3 applyFog(vec3 col, float t, vec3 rd, vec3 lightDir, float b ) { +vec3 applyFog(vec3 col, float t, vec3 rd, vec3 lightDir, float b ) { float fogAmount = 1.0 - exp(-t*b); float sunAmount = max( dot(rd, lightDir), 0.0 ); vec3 fogColor = mix( vec3(0.3686, 0.2431, 0.4392), // blue