markus/4kintro
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fixes

Browse Source
This commit is contained in:
Petri Järvisalo
2024-05-29 18:47:21 +03:00
parent 9b0e678611
commit 6a098253ca
6 changed files with 1387 additions and 278 deletions
Download Patch File Download Diff File Expand all files Collapse all files

0
4k_test.zip
View File

6
base.config
View File

@ -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=\"

732
cogs.frag
View File

@ -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 <p>.
// 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 <a> and <b>, 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 <a> and <b> 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. <p.x> or <p.zx>
//
// <inout p> 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, <p> 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 <a>.
// Read like this: R(p.xz, a) rotates "x towards z".
// This is fast if <a> 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:
// <float cell = pMod1(p.x,5);> - 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 <start> to <stop> (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 <start) {
p += size*(c - start);
c = start;
}
return c;
}
// Repeat around the origin by a fixed angle.
// For easier use, num of repetitions is use to specify the angle.
float pModPolar(inout vec2 p, float repetitions) {
float angle = 2.*PI/repetitions;
float a = atan(p.y, p.x) + angle/2.;
float r = length(p);
float c = floor(a/angle);
a = mod(a,angle) - angle/2.;
p = vec2(cos(a), sin(a))*r;
// For an odd number of repetitions, fix cell index of the cell in -x direction
// (cell index would be e.g. -5 and 5 in the two halves of the cell):
if (abs(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 <dist> 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 <a> and <b> 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 <r> 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 <r>):
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_STEPS; 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 > 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 );

6
minified.config
View File

@ -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

732
shader.glsl
View File

@ -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 <p>.
// 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 <a> and <b>, 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 <a> and <b> 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. <p.x> or <p.zx>
//
// <inout p> 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, <p> 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 <a>.
// Read like this: R(p.xz, a) rotates "x towards z".
// This is fast if <a> 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:
// <float cell = pMod1(p.x,5);> - 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 <start> to <stop> (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 <start) {
p += size*(c - start);
c = start;
}
return c;
}
// Repeat around the origin by a fixed angle.
// For easier use, num of repetitions is use to specify the angle.
float pModPolar(inout vec2 p, float repetitions) {
float angle = 2.*PI/repetitions;
float a = atan(p.y, p.x) + angle/2.;
float r = length(p);
float c = floor(a/angle);
a = mod(a,angle) - angle/2.;
p = vec2(cos(a), sin(a))*r;
// For an odd number of repetitions, fix cell index of the cell in -x direction
// (cell index would be e.g. -5 and 5 in the two halves of the cell):
if (abs(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 <dist> 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 <a> and <b> 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 <r> 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 <r>):
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 );
}

189
shader_minified.h
View File

@ -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.distance<abs(.001*m))"
"vec3 x=v+y*m;"
"vec2 n=p(x);"
"m+=n.x;"
"f=n.y;"
"if(m>20.||n.x<abs(.001*m))"
"break;"
"}"
"if(m>20.)"
"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_