diff --git a/4k_test.zip b/4k_test.zip deleted file mode 100644 index e69de29..0000000 diff --git a/base.config b/base.config index 1bb12cc..2a7bff4 100644 --- a/base.config +++ b/base.config @@ -12,9 +12,9 @@ RESOLUTION_X=1280 RESOLUTION_Y=720 USE_TIME_UNIFORM=1 -TIME_UNIFORM_NAME='time' +TIME_UNIFORM_NAME='u_time' USE_RESOLUTION_UNIFORM=1 -RESOLUTION_UNIFORM_NAME='resolution' +RESOLUTION_UNIFORM_NAME='u_resolution' # Frame-to-texture, mipmaps @@ -55,7 +55,7 @@ PROD_END_TIME=5257472 OUTPUT_EXE_NAME=4k_test.exe # this is just the name/text of the GUI option, not the name of the linker executable -EXE_LINKER_PROGRAM=Crinkler +EXE_LINKER_PROGRAM=GNU ld QUOTE=\" diff --git a/cogs.frag b/cogs.frag index e69cd5b..1e37f64 100644 --- a/cogs.frag +++ b/cogs.frag @@ -1,22 +1,582 @@ -#ifdef GL_ES - precision mediump float; +#ifdef GL_ES + precision mediump float; #endif -#define MAX_STEPS 100 -#define MAX_DIST 20. -#define SURF_DIST .001 -#define TAU 6.283185 -#define PI 3.141592 - -#define FOG_DENSITY 0.01 - uniform vec2 u_resolution; uniform float u_time; +uniform sampler2D texture_sampler; +uniform sampler2D texts; -struct Obj { - float distance; // distance map - int material; // material Id -}; +//////////////////////////////////////////////////////////////// +// +// HG_SDF +// +// GLSL LIBRARY FOR BUILDING SIGNED DISTANCE BOUNDS +// +// version 2021-07-28 +// +// Check https://mercury.sexy/hg_sdf for updates +// and usage examples. Send feedback to spheretracing@mercury.sexy. +// +// Brought to you by MERCURY https://mercury.sexy/ +// +// +// +// Released dual-licensed under +// Creative Commons Attribution-NonCommercial (CC BY-NC) +// or +// MIT License +// at your choice. +// +// SPDX-License-Identifier: MIT OR CC-BY-NC-4.0 +// +// ///// + + +//////////////////////////////////////////////////////////////// +// +// HELPER FUNCTIONS/MACROS +// +//////////////////////////////////////////////////////////////// + +#define PI 3.14159265 +#define TAU (2*PI) +#define PHI (sqrt(5)*0.5 + 0.5) + +// Sign function that doesn't return 0 +float sgn(float x) { + return (x < 0. )? -1. : 1.; +} + +vec2 sgn(vec2 v) { + return vec2((v.x<0.)?-1.:1., (v.y<0.)?-1.:1.); +} + +float square (float x) { + return x*x; +} + +vec2 square (vec2 x) { + return x*x; +} + +vec3 square (vec3 x) { + return x*x; +} + +float lengthSqr(vec3 x) { + return dot(x, x); +} + + +// Maximum/minumum elements of a vector +float vmax(vec2 v) { + return max(v.x, v.y); +} + +float vmax(vec3 v) { + return max(max(v.x, v.y), v.z); +} + +float vmax(vec4 v) { + return max(max(v.x, v.y), max(v.z, v.w)); +} + +float vmin(vec2 v) { + return min(v.x, v.y); +} + +float vmin(vec3 v) { + return min(min(v.x, v.y), v.z); +} + +float vmin(vec4 v) { + return min(min(v.x, v.y), min(v.z, v.w)); +} + +//////////////////////////////////////////////////////////////// +// +// PRIMITIVE DISTANCE FUNCTIONS +// +//////////////////////////////////////////////////////////////// +// +// Conventions: +// +// Everything that is a distance function is called fSomething. +// The first argument is always a point in 2 or 3-space called

. +// 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)); +} + +////// End of library mat2 Rot(float a) { @@ -24,9 +584,8 @@ mat2 Rot(float a) { return mat2(c, -s, s, c); } -vec3 applyFog(in vec3 color, in float distance) { - - float fogAmount = 1.0 - exp(-distance*FOG_DENSITY); +vec3 applyFog(in vec3 color, in float distance) { + float fogAmount = 1.0 - exp(-distance * 0.01); vec3 fogColor = vec3(0.17, 0.16, 0.24); return mix( color, fogColor, fogAmount ); } @@ -45,73 +604,58 @@ float sdCog2d(vec2 pos) { return f; } -float opSmoothSubtraction( float d1, float d2, float k ) -{ - float h = max(k-abs(-d1-d2),0.0); - return max(-d1, d2) + h*h*0.25/k; -} - -float sdCapsule( vec3 p, vec3 a, vec3 b, float r ) -{ - vec3 pa = p - a, ba = b - a; - float h = clamp( dot(pa,ba)/dot(ba,ba), 0.0, 1.0 ); - return length( pa - ba*h ) - r; -} - float sdCog(vec3 pos, float angle) { pos.xy *= Rot(angle); float d1 = opExtrusion(pos, sdCog2d(pos.xy), 0.15); - float d2 = sdCapsule(pos - vec3(0.,0., -0.5), vec3(0., 0.0, 0.), vec3(0., 0., 1.), 0.2); - return 0.8 * opSmoothSubtraction(d2,d1,0.02)-0.001; -} + float d2 = fCapsule(pos - vec3(0.,0., -0.5), vec3(0., 0.0, 0.), vec3(0., 0., 1.), 0.2); + return 0.8 * fOpDifferenceRound(d1,d2,0.1)-0.02;} // Scene -Obj mapScene(in vec3 p) { - float d = 1e10; +vec2 mapScene(in vec3 p) { + float d = 1e10; - float dGround = p.y +1.5 + sin(p.z*0.6)*.2 + sin(p.x*1.3)*.1; - Obj ground = Obj(dGround, 0); + float dGround = p.y + 1.5; + d = min(d, dGround); - { - float d1 = sdCog(p+vec3(1., 0., 0.), u_time); - d = min(d, d1); - } - { - float d1 = sdCog(p+vec3(0.5, -.87, 0.), -u_time); - d = min(d, d1); - } - { - float d1 = sdCog(p+vec3(0.5, .87, 0.), -u_time); - d = min(d, d1); - } - Obj ob1 = Obj(d, 1); + float c1 = sdCog(p+vec3(1., 0., 0.), u_time); + d = min(d, c1); - if (ground.distance > ob1.distance) return ob1; - return ground; + float c2 = sdCog(p+vec3(0.5, -.87, 0.), -u_time); + d = min(d, c2); + + float c3 = sdCog(p+vec3(0.5, .87, 0.), -u_time); + d = min(d, c3); + + float mat = 0.; + + if ( d == c1) mat = 1.; + if ( d == c2) mat = 2.; + if ( d == c3) mat = 3.; + + return vec2(d, mat); } -Obj castRay(vec3 ro, vec3 rd) { - float t = 0.0; - - Obj res = Obj(-1., -1); - for(int i=0; i MAX_DIST || res.distance < abs(SURF_DIST*t) ) break; + vec2 res = mapScene(p); + t += res.x; + mat = res.y; + if (t > 20. || res.x < abs(0.0001*t) ) break; } - if (t > MAX_DIST) t = -1.0; - res.distance = t; - return res; + if (t > 20.) t = -1.0; + return vec2(t, mat); } float castShadow(vec3 ro, vec3 rd) { float res = 1.0; float t = 0.001; - for(int i = 0; i < MAX_STEPS; i++) { + for(int i = 0; i < 100; i++) { vec3 pos = ro + t* rd; - float h = mapScene(pos).distance; + float h = mapScene(pos).x; res = min(res, 10.0*h/t); if (abs(h) < (0.001*t) ) break; t += h; @@ -122,9 +666,9 @@ float castShadow(vec3 ro, vec3 rd) { vec3 calcNormal(vec3 pos) { vec2 e = vec2(.001, 0.); - vec3 n = vec3( mapScene(pos+e.xyy).distance - mapScene(pos-e.xyy).distance, - mapScene(pos+e.yxy).distance - mapScene(pos-e.yxy).distance, - mapScene(pos+e.yyx).distance - mapScene(pos-e.yyx).distance + 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); } @@ -134,22 +678,28 @@ vec3 fresnel( vec3 F0, vec3 h, vec3 l ) { } -vec3 shading(vec3 v, vec3 n, vec3 dir, int material) { +vec3 shading(vec3 v, vec3 n, vec3 dir, float material) { float shininess = 1.; vec3 final = vec3( 0.0 ); vec3 ref = reflect( dir, n ); vec3 Ks = vec3( 0.5 ); vec3 Kd = vec3( 1.0 ); - vec3 outMaterial = vec3(0.1255, 0.1255, 0.1255); + vec3 outMaterial = vec3(0.1686, 0.1686, 0.1686); + + if (material == 0.) { + outMaterial = vec3(0.1412, 0.1412, 0.1412); + shininess = 11.1; + } else if (material == 1.) { + outMaterial = vec3(0.1765, 1.1961, 0.2275); + shininess = 31.; + } else if (material == 2.) { + outMaterial = vec3(1.1765, 0.1961, 0.2275); + shininess = 21.; + } else if (material == 3.) { + outMaterial = vec3(0.1765, 0.1961, 1.2275); + shininess = 21.; + } - if (material == 0) { - outMaterial = vec3(0.1412, 0.1412, 0.1412); - shininess = 3.1; - } else if (material == 1) { - outMaterial = vec3(0.1765, 0.1961, 0.2275); - shininess = 21.; - } - // light 0 { vec3 light_pos = vec3( -2.,.3, 10. ); @@ -204,29 +754,25 @@ void main() { vec2 p = (2.0 * gl_FragCoord.xy - u_resolution.xy) / u_resolution.y; float angle = u_time*0.4; - // angle = 2.0; // comment to rotate - // gl_FragColor = vec4(vec3(sdCog2d(p)), 1.); - // return; // camera - vec3 ta = vec3(0.0, 0., 0.0); - vec3 ro = ta + vec3(4.*sin(angle), cos(angle), 4.*cos(angle)); // *cos(angle)) + vec3 ta = vec3(0.0, 0., 1.0); + vec3 ro = ta + vec3(2., 0., 4.); // + vec3(4.*sin(angle), cos(angle), 4.*cos(angle)); // *cos(angle)) - vec3 ww = normalize(ta-ro); - vec3 uu = normalize(cross(ww, vec3(0,1,0))); + vec3 ww = normalize(ta-ro); + vec3 uu = normalize(cross(ww, vec3(0.,1.0, 0.))); // vec3 = pitch, yaw, pan vec3 vv = normalize(cross(uu,ww)); - - vec3 rd = normalize(p.x * uu + p.y*vv + 1.4*ww); // camera + vec3 rd = normalize(p.x * uu + p.y*vv + ww * 2.0); // camera // global light - vec3 col = vec3(0.1451, 0.1098, 0.1608) - vec3(0.9725, 0.5176, 0.0) *rd.y; - Obj t = castRay(ro, rd); + vec3 col = vec3(0.1451, 0.1098, 0.1608) - vec3(0.9725, 0.5176, 0.0) *rd.y; + vec2 t = castRay(ro, rd); - if (t.distance > 0.) { - vec3 pos = ro + rd * t.distance; + if (t.x > 0.) { + vec3 pos = ro + rd * t.x; vec3 nor = calcNormal(pos); - col = shading(pos, nor, rd , t.material); + col = shading(pos, nor, rd , t.y); // apply fog - col = applyFog(col, t.distance); + col = applyFog(col, t.x); } gl_FragColor = vec4( pow( col, vec3(1.0/1.3) ), 1.0 ); diff --git a/minified.config b/minified.config index d136c9c..ff751d2 100644 --- a/minified.config +++ b/minified.config @@ -7,11 +7,11 @@ include $(PARENT_CONFIG) # Visuals -EXE_LINKER_PROGRAM=Crinkler +EXE_LINKER_PROGRAM=GNU ld CRINKLER_ORDERTRIES=400 SHADER_FILE=shader_minified.h -TIME_UNIFORM_NAME='v' -RESOLUTION_UNIFORM_NAME='m' +TIME_UNIFORM_NAME='y' +RESOLUTION_UNIFORM_NAME='v' TEXTS_UNIFORM_NAME='d' USE_WIDECHAR_TEXTS=1 TIME_DIVIDER=72993.102 diff --git a/shader.glsl b/shader.glsl index 3c3a14f..60e8220 100644 --- a/shader.glsl +++ b/shader.glsl @@ -1,12 +1,579 @@ -uniform float time; -uniform vec2 resolution; +precision mediump float; +uniform vec2 u_resolution; +uniform float u_time; uniform sampler2D texture_sampler; uniform sampler2D texts; -struct Obj { - float distance; // distance map - int material; // material Id -}; +//////////////////////////////////////////////////////////////// +// +// HG_SDF +// +// GLSL LIBRARY FOR BUILDING SIGNED DISTANCE BOUNDS +// +// version 2021-07-28 +// +// Check https://mercury.sexy/hg_sdf for updates +// and usage examples. Send feedback to spheretracing@mercury.sexy. +// +// Brought to you by MERCURY https://mercury.sexy/ +// +// +// +// Released dual-licensed under +// Creative Commons Attribution-NonCommercial (CC BY-NC) +// or +// MIT License +// at your choice. +// +// SPDX-License-Identifier: MIT OR CC-BY-NC-4.0 +// +// ///// + + +//////////////////////////////////////////////////////////////// +// +// HELPER FUNCTIONS/MACROS +// +//////////////////////////////////////////////////////////////// + +const float PI = 3.14159265; +const float TAU = (2.*PI); +const float PHI = sqrt(5.)*0.5 + 0.5; + +// Sign function that doesn't return 0 +float sgn(float x) { + return (x < 0. )? -1. : 1.; +} + +vec2 sgn(vec2 v) { + return vec2((v.x<0.)?-1.:1., (v.y<0.)?-1.:1.); +} + +float square (float x) { + return x*x; +} + +vec2 square (vec2 x) { + return x*x; +} + +vec3 square (vec3 x) { + return x*x; +} + +float lengthSqr(vec3 x) { + return dot(x, x); +} + + +// Maximum/minumum elements of a vector +float vmax(vec2 v) { + return max(v.x, v.y); +} + +float vmax(vec3 v) { + return max(max(v.x, v.y), v.z); +} + +float vmax(vec4 v) { + return max(max(v.x, v.y), max(v.z, v.w)); +} + +float vmin(vec2 v) { + return min(v.x, v.y); +} + +float vmin(vec3 v) { + return min(min(v.x, v.y), v.z); +} + +float vmin(vec4 v) { + return min(min(v.x, v.y), min(v.z, v.w)); +} + +//////////////////////////////////////////////////////////////// +// +// PRIMITIVE DISTANCE FUNCTIONS +// +//////////////////////////////////////////////////////////////// +// +// Conventions: +// +// Everything that is a distance function is called fSomething. +// The first argument is always a point in 2 or 3-space called

. +// 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 mat2 Rot(float a) { @@ -14,8 +581,8 @@ mat2 Rot(float a) { return mat2(c, -s, s, c); } -vec3 applyFog(in vec3 color, in float distance) { - float fogAmount = 1.0 - exp(-distance *0.01); +vec3 applyFog(in vec3 color, in float distance) { + float fogAmount = 1.0 - exp(-distance * 0.01); vec3 fogColor = vec3(0.17, 0.16, 0.24); return mix( color, fogColor, fogAmount ); } @@ -34,65 +601,50 @@ float sdCog2d(vec2 pos) { return f; } -float opSmoothSubtraction( float d1, float d2, float k ) -{ - float h = max(k-abs(-d1-d2),0.0); - return max(-d1, d2) + h*h*0.25/k; -} - -float sdCapsule( vec3 p, vec3 a, vec3 b, float r ) -{ - vec3 pa = p - a, ba = b - a; - float h = clamp( dot(pa,ba)/dot(ba,ba), 0.0, 1.0 ); - return length( pa - ba*h ) - r; -} - float sdCog(vec3 pos, float angle) { pos.xy *= Rot(angle); float d1 = opExtrusion(pos, sdCog2d(pos.xy), 0.15); - float d2 = sdCapsule(pos - vec3(0.,0., -0.5), vec3(0., 0.0, 0.), vec3(0., 0., 1.), 0.2); - return 0.8 * opSmoothSubtraction(d2,d1,0.02)-0.001; -} + float d2 = fCapsule(pos - vec3(0.,0., -0.5), vec3(0., 0.0, 0.), vec3(0., 0., 1.), 0.2); + return 0.8 * fOpDifferenceRound(d1,d2,0.1)-0.02;} // Scene -Obj mapScene(in vec3 p) { - float d = 1e10; +vec2 mapScene(in vec3 p) { + float d = 1e10; - float dGround = p.y +1.5 + sin(p.z*0.6)*.2 + sin(p.x*1.3)*.1; - Obj ground = Obj(dGround, 0); + float dGround = p.y + 1.5; + d = min(d, dGround); - { - float d1 = sdCog(p+vec3(1., 0., 0.), time); - d = min(d, d1); - } - { - float d1 = sdCog(p+vec3(0.5, -.87, 0.), -time); - d = min(d, d1); - } - { - float d1 = sdCog(p+vec3(0.5, .87, 0.), -time); - d = min(d, d1); - } - Obj ob1 = Obj(d, 1); + float c1 = sdCog(p+vec3(1., 0., 0.), u_time); + d = min(d, c1); - if (ground.distance > ob1.distance) return ob1; - return ground; + float c2 = sdCog(p+vec3(0.5, -.87, 0.), -u_time); + d = min(d, c2); + + float c3 = sdCog(p+vec3(0.5, .87, 0.), -u_time); + d = min(d, c3); + + float mat = 0.; + + if ( d == c1) mat = 1.; + if ( d == c2) mat = 2.; + if ( d == c3) mat = 3.; + + return vec2(d, mat); } -Obj castRay(vec3 ro, vec3 rd) { - float t = 0.0; - - Obj res = Obj(-1., -1); - for(int i=0; i<100; i++) { +vec2 castRay(vec3 ro, vec3 rd) { + float t = 0.0; + float mat = 0.; + for(int i=0; i < 100; i++) { vec3 p = ro + rd * t; - res = mapScene(p); - t += res.distance; - if (t > 20.0 || res.distance < abs(0.001*t) ) break; + vec2 res = mapScene(p); + t += res.x; + mat = res.y; + if (t > 20. || res.x < abs(0.001*t) ) break; } - if (t > 20.0) t = -1.0; - res.distance = t; - return res; + if (t > 20.) t = -1.0; + return vec2(t, mat); } float castShadow(vec3 ro, vec3 rd) { @@ -100,7 +652,7 @@ float castShadow(vec3 ro, vec3 rd) { float t = 0.001; for(int i = 0; i < 100; i++) { vec3 pos = ro + t* rd; - float h = mapScene(pos).distance; + float h = mapScene(pos).x; res = min(res, 10.0*h/t); if (abs(h) < (0.001*t) ) break; t += h; @@ -111,9 +663,9 @@ float castShadow(vec3 ro, vec3 rd) { vec3 calcNormal(vec3 pos) { vec2 e = vec2(.001, 0.); - vec3 n = vec3( mapScene(pos+e.xyy).distance - mapScene(pos-e.xyy).distance, - mapScene(pos+e.yxy).distance - mapScene(pos-e.yxy).distance, - mapScene(pos+e.yyx).distance - mapScene(pos-e.yyx).distance + 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); } @@ -123,22 +675,28 @@ vec3 fresnel( vec3 F0, vec3 h, vec3 l ) { } -vec3 shading(vec3 v, vec3 n, vec3 dir, int material) { +vec3 shading(vec3 v, vec3 n, vec3 dir, float material) { float shininess = 1.; vec3 final = vec3( 0.0 ); vec3 ref = reflect( dir, n ); vec3 Ks = vec3( 0.5 ); vec3 Kd = vec3( 1.0 ); - vec3 outMaterial = vec3(0.1255, 0.1255, 0.1255); + vec3 outMaterial = vec3(0.1686, 0.1686, 0.1686); + + if (material == 0.) { + outMaterial = vec3(0.1412, 0.1412, 0.1412); + shininess = 11.1; + } else if (material == 1.) { + outMaterial = vec3(0.1765, 1.1961, 0.2275); + shininess = 31.; + } else if (material == 2.) { + outMaterial = vec3(1.1765, 0.1961, 0.2275); + shininess = 21.; + } else if (material == 3.) { + outMaterial = vec3(0.1765, 0.1961, 1.2275); + shininess = 21.; + } - if (material == 0) { - outMaterial = vec3(0.1412, 0.1412, 0.1412); - shininess = 3.1; - } else if (material == 1) { - outMaterial = vec3(0.1765, 0.1961, 0.2275); - shininess = 21.; - } - // light 0 { vec3 light_pos = vec3( -2.,.3, 10. ); @@ -180,35 +738,39 @@ vec3 shading(vec3 v, vec3 n, vec3 dir, int material) { float sun_dif = clamp(dot(n, SUN_DIR), 0., 1.); final += outMaterial * vec3(0.0353, 0.2667, 0.4784) * sun_dif; } + // final += texture( iChannel0, ref ).rgb * fresnel( Ks, n, -dir ); + // vec3 col = vec3(0.4)* ref.x; + //vec3 col = vec3(0.0588, 0.0588, 0.1216);// - vec3(0.149, 0.0863, 0.2314) * v.x; + //final += col * fresnel( vec3(.5), ref, -dir ); - return final; + return final; } void main() { - vec2 p = (gl_FragCoord.xy * 2. - resolution.xy) / min(resolution.x, resolution.y); - // vec2 p = (2.0 * gl_FragCoord.xy - resolution.xy) / resolution.y; - float angle = time*0.4; - vec3 ta = vec3(0.0, 0., 0.0); + vec2 p = (2.0 * gl_FragCoord.xy - u_resolution.xy) / u_resolution.y; + float angle = u_time*0.4; + // camera + vec3 ta = vec3(0.0, 0., 1.0); vec3 ro = ta + vec3(4.*sin(angle), cos(angle), 4.*cos(angle)); // *cos(angle)) - vec3 ww = normalize(ta-ro); - vec3 uu = normalize(cross(ww, vec3(0,1,0))); + vec3 ww = normalize(ta-ro); + vec3 uu = normalize(cross(ww, vec3(0.,1.0, 0.))); // vec3 = pitch, yaw, pan vec3 vv = normalize(cross(uu,ww)); - - vec3 rd = normalize(p.x * uu + p.y*vv + 1.4*ww); // camera + vec3 rd = normalize(p.x * uu + p.y*vv + ww * 2.0); // camera // global light - vec3 col = vec3(0.1451, 0.1098, 0.1608) - vec3(0.9725, 0.5176, 0.0) *rd.y; - Obj t = castRay(ro, rd); + vec3 col = vec3(0.1451, 0.1098, 0.1608) - vec3(0.9725, 0.5176, 0.0) *rd.y; + vec2 t = castRay(ro, rd); - if (t.distance > 0.) { - vec3 pos = ro + rd * t.distance; + if (t.x > 0.) { + vec3 pos = ro + rd * t.x; vec3 nor = calcNormal(pos); - col = shading(pos, nor, rd , t.material); + col = shading(pos, nor, rd , t.y); // apply fog - col = applyFog(col, t.distance); - } - gl_FragColor = vec4( pow(col, vec3(1.0/1.3) ), 1.0 ); + col = applyFog(col, t.x); + } + + gl_FragColor = vec4( pow( col, vec3(1.0/1.3) ), 1.0 ); } \ No newline at end of file diff --git a/shader_minified.h b/shader_minified.h index f2d7e3b..72275ca 100644 --- a/shader_minified.h +++ b/shader_minified.h @@ -1,149 +1,150 @@ // Generated with Shader Minifier 1.3.6 (https://github.com/laurentlb/Shader_Minifier/) #ifndef SHADER_MINIFIED_H_ # define SHADER_MINIFIED_H_ -# define VAR_resolution "m" # define VAR_texts "d" -# define VAR_texture_sampler "e" -# define VAR_time "v" +# define VAR_texture_sampler "m" +# define VAR_u_resolution "v" +# define VAR_u_time "y" const char *__temp_cleaned_shader_glsl = - "uniform float v;" - "uniform vec2 m;" - "uniform sampler2D e,d;struct Obj{float distance;int material;};" - "mat2 n(float v)" + "uniform vec2 v;" + "uniform float y;" + "uniform sampler2D m,d;" + "const float i=2.*acos(-1.),f=sqrt(5.)*.5+.5;" + "float n(vec3 v)" "{" - "float f=sin(v),y=cos(v);" - "return mat2(y,-f,f,y);" + "vec3 x=vec3(0),y=vec3(0,0,1)-x;" + "return length(y*clamp(dot(v-x,y)/dot(y,y),0.,1.)+x-v);" "}" - "float n(vec3 v,float m)" + "float n(float v,float y)" "{" - "vec2 f=vec2(m,abs(v.z)-.15);" - "return min(max(f.x,f.y),0.)+length(max(f,0.));" + "return min(-.1,max(v,y))+length(max(vec2(.1+v,.1+y),vec2(0)));" "}" - "float s(vec2 v)" + "mat2 s(float v)" "{" - "float f=1.-smoothstep(-.2,.8,sin(atan(v.y,v.x)*12.))*.14;" - "return smoothstep(f,f+2.,length(v)*2.);" + "float y=sin(v),x=cos(v);" + "return mat2(x,-y,y,x);" "}" - "float s(float f,float v)" + "float s(vec3 v,float y)" "{" - "float m=max(.02-abs(-f-v),0.);" - "return max(-f,v)+m*m*.25/.02;" + "vec2 m=vec2(y,abs(v.z)-.15);" + "return min(max(m.x,m.y),0.)+length(max(m,0.));" "}" - "float x(vec3 v)" + "float t(vec2 v)" "{" - "vec3 f=vec3(0),m=v-f,y=vec3(0,0,1)-f;" - "return length(m-y*clamp(dot(m,y)/dot(y,y),0.,1.))-.2;" + "float y=1.-smoothstep(-.2,.8,sin(atan(v.y,v.x)*12.))*.14;" + "return smoothstep(y,y+2.,length(v)*2.);" "}" - "float x(vec3 v,float m)" + "float t(vec3 v,float y)" "{" - "v.xy*=n(m);" - "float f=n(v,s(v.xy)),y=x(v-vec3(0,0,-.5));" - "return.8*s(y,f)-.001;" + "v.xy*=s(y);" + "float m=s(v,t(v.xy)),x=n(v-vec3(0,0,-.5))-.2;" + "return.8*n(m,-x)-.02;" "}" - "Obj f(vec3 m)" + "vec2 p(vec3 v)" "{" - "float f=1e10;" - "Obj e=Obj(m.y+1.5+sin(m.z*.6)*.2+sin(m.x*1.3)*.1,0);" - "{" - "float y=x(m+vec3(1,0,0),v);" - "f=min(f,y);" - "}" - "{" - "float y=x(m+vec3(.5,-.87,0),-v);" - "f=min(f,y);" - "}" - "{" - "float y=x(m+vec3(.5,.87,0),-v);" - "f=min(f,y);" - "}" - "Obj y=Obj(f,1);" - "return e.distance>y.distance?" - "y:" - "e;" + "float m=1e10;" + "m=min(m,v.y+1.5);" + "float x=t(v+vec3(1,0,0),y);" + "m=min(m,x);" + "float n=t(v+vec3(.5,-.87,0),-y);" + "m=min(m,n);" + "float f=t(v+vec3(.5,.87,0),-y);" + "m=min(m,f);" + "float d=0.;" + "if(m==x)" + "d=1.;" + "if(m==n)" + "d=2.;" + "if(m==f)" + "d=3.;" + "return vec2(m,d);" "}" - "Obj f(vec3 v,vec3 y)" + "vec2 p(vec3 v,vec3 y)" "{" - "float m=0.;" - "Obj r=Obj(-1.,-1);" - "for(int e=0;e<100;e++)" + "float m=0.,f=0.;" + "for(int i=0;i<100;i++)" "{" - "vec3 c=v+y*m;" - "r=f(c);" - "m+=r.distance;" - "if(m>20.||r.distance20.||n.x20.)" "m=-1.;" - "r.distance=m;" - "return r;" + "return vec2(m,f);" "}" - "float p(vec3 v,vec3 m)" + "float x(vec3 v,vec3 y)" "{" - "float y=1.,r=.001;" - "for(int e=0;e<100;e++)" + "float m=1.,f=.001;" + "for(int i=0;i<100;i++)" "{" - "vec3 c=v+r*m;" - "float n=f(c).distance;" - "y=min(y,10.*n/r);" - "if(abs(n)<.001*r)" + "vec3 x=v+f*y;" + "float n=p(x).x;" + "m=min(m,10.*n/f);" + "if(abs(n)<.001*f)" "break;" - "r+=n;" - "if(r>20.)" + "f+=n;" + "if(f>20.)" "break;" "}" - "return clamp(y,0.,1.);" + "return clamp(m,0.,1.);" "}" - "vec3 p(vec3 v)" + "vec3 x(vec3 v)" "{" "vec2 m=vec2(.001,0);" - "vec3 y=vec3(f(v+m.xyy).distance-f(v-m.xyy).distance,f(v+m.yxy).distance-f(v-m.yxy).distance,f(v+m.yyx).distance-f(v-m.yyx).distance);" + "vec3 y=vec3(p(v+m.xyy).x-p(v-m.xyy).x,p(v+m.yxy).x-p(v-m.yxy).x,p(v+m.yyx).x-p(v-m.yyx).x);" "return normalize(y);" "}" - "vec3 f(vec3 v,vec3 m,vec3 y)" + "vec3 n(vec3 v,vec3 m,vec3 y)" "{" "return v+(1.-v)*pow(clamp(1.-dot(m,y),0.,1.),5.);" "}" - "vec3 f(vec3 v,vec3 y,vec3 m,int c)" + "vec3 n(vec3 v,vec3 y,vec3 m,float f)" "{" - "float e=1.;" - "vec3 r=vec3(0),d=reflect(m,y),n=vec3(.5),a=vec3(1),O=vec3(.1255);" - "if(c==0)" - "O=vec3(.1412),e=3.1;" - "else if(c==1)" - "O=vec3(.1765,.1961,.2275),e=21.;" + "float d=1.;" + "vec3 i=vec3(0),p=reflect(m,y),c=vec3(.5),a=vec3(1),s=vec3(.1686);" + "if(f==0.)" + "s=vec3(.1412),d=11.1;" + "else if(f==1.)" + "s=vec3(.1765,1.1961,.2275),d=31.;" + "else if(f==2.)" + "s=vec3(1.1765,.1961,.2275),d=21.;" + "else if(f==3.)" + "s=vec3(.1765,.1961,1.2275),d=21.;" "{" - "vec3 x=normalize(vec3(-2,.3,10)-v),i=vec3(max(0.,dot(x,d))),l=f(n,normalize(x-m),x);" - "i=pow(i,vec3(e));" - "r+=O*i*(vec3(.71,.51,.72)*5.)*mix(a*vec3(max(0.,dot(x,y))),i,l);" + "vec3 l=normalize(vec3(-2,.3,10)-v),r=vec3(max(0.,dot(l,p))),t=n(c,normalize(l-m),l);" + "r=pow(r,vec3(d));" + "i+=s*r*(vec3(.71,.51,.72)*5.)*mix(a*vec3(max(0.,dot(l,y))),r,t);" "}" "{" - "vec3 x=normalize(vec3(5,5,-20)-v),i=vec3(max(0.,dot(x,d))),l=f(n,normalize(x-m),x);" - "i=pow(i,vec3(e));" - "r+=O*i*(vec3(.14,.36,.83)*7.)*mix(a*vec3(max(0.,dot(x,y))),i,l);" + "vec3 l=normalize(vec3(5,5,-20)-v),r=vec3(max(0.,dot(l,p))),t=n(c,normalize(l-m),l);" + "r=pow(r,vec3(d));" + "i+=s*r*(vec3(.14,.36,.83)*7.)*mix(a*vec3(max(0.,dot(l,y))),r,t);" "}" "{" - "vec3 x=vec3(0,.4,1);" - "float i=clamp(dot(y,x),0.,1.),l=p(v+y*.02,x);" - "r+=O*vec3(1.1,1.2,1.5)*i*i*l;" + "vec3 l=vec3(0,.4,1);" + "float r=clamp(dot(y,l),0.,1.),t=x(v+y*.02,l);" + "i+=s*vec3(1.1,1.2,1.5)*r*r*t;" "}" - "r+=O*vec3(.0353,.2667,.4784)*clamp(dot(y,vec3(0,.6,-1)),0.,1.);" - "return r;" + "i+=s*vec3(.0353,.2667,.4784)*clamp(dot(y,vec3(0,.6,-1)),0.,1.);" + "return i;" "}" "void main()" "{" - "vec2 y=(gl_FragCoord.xy*2.-m.xy)/min(m.x,m.y);" - "float x=v*.4;" - "vec3 e=vec3(0),i=e+vec3(4.*sin(x),cos(x),4.*cos(x)),c=normalize(e-i),r=normalize(cross(c,vec3(0,1,0))),l=normalize(y.x*r+y.y*normalize(cross(r,c))+1.4*c),d=vec3(.1451,.1098,.1608)-vec3(.9725,.5176,0)*l.y;" - "Obj n=f(i,l);" - "if(n.distance>0.)" + "vec2 m=(2.*gl_FragCoord.xy-v.xy)/v.y;" + "float f=y*.4;" + "vec3 i=vec3(0,0,1),d=i+vec3(4.*sin(f),cos(f),4.*cos(f)),l=normalize(i-d),r=normalize(cross(l,vec3(0,1,0))),s=normalize(m.x*r+m.y*normalize(cross(r,l))+l*2.),c=vec3(.1451,.1098,.1608)-vec3(.9725,.5176,0)*s.y;" + "vec2 t=p(d,s);" + "if(t.x>0.)" "{" - "vec3 a=i+l*n.distance,O=p(a);" - "d=f(a,O,l,n.material);" - "d=mix(d,vec3(.17,.16,.24),1.-exp(-n.distance*.01));" + "vec3 a=d+s*t.x,C=x(a);" + "c=n(a,C,s,t.y);" + "c=mix(c,vec3(.17,.16,.24),1.-exp(-t.x*.01));" "}" - "gl_FragColor=vec4(pow(d,vec3(1./1.3)),1);" + "gl_FragColor=vec4(pow(c,vec3(1./1.3)),1);" "}"; #endif // SHADER_MINIFIED_H_