hexHouseHouse.glsl

hexHouseHouse.glsl

#ifdef GL_ES
precision highp float;
#endif

uniform float time;
uniform vec2 resolution;
uniform vec2 mouse;
uniform vec3 spectrum;

uniform sampler2D texture0;
uniform sampler2D texture1;
uniform sampler2D texture2;
uniform sampler2D texture3;
uniform sampler2D prevFrame;
uniform sampler2D prevPass;

varying vec3 v_normal;
varying vec2 v_texcoord;

float rand(vec2 co){
    return fract(sin(dot(co, vec2(12.9898, 78.233))) * 43758.5453);
}

// 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.);
}

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;
}
void pR(inout vec2 p, float a) {
    p = cos(a)*p + sin(a)*vec2(p.y, -p.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));
}

// 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)));
}  
// Smooth minimum function for rounding
// Smooth minimum function for rounding
float smin(float a, float b, float k) {
    float h = clamp(0.5 + 0.5 * (b - a) / k, 0.0, 1.0);
    return mix(b, a, h) - k * h * (1.0 - h);
}

// Smooth maximum function for rounding
float smax(float a, float b, float k) {
    return -smin(-a, -b, k);
}

// Rounded box function
float fBoxRound(vec3 p, vec3 b, float r) {
    vec3 q = abs(p) - b + vec3(r);
    return length(max(q, 0.0)) + min(max(q.x, max(q.y, q.z)), 0.0) - r;
}

float scene(vec3 pos) {
    float roundness = 0.3;
    float windowRoundness = 0.05;
    float topSmoothness = 1.8; // Controls the smoothness of the top transition
    
    pR(pos.xz, time);
    
    vec2 id = pModMirror2(pos.xz, vec2(40, 60));
    pos.z += 0.1;
    
    // Main building structure with rounded corners
    float cube = fBoxRound(pos + vec3(0,0,0), vec3(1,7,1), roundness);
    
    // Create a smooth top transition
    float topFade = smoothstep(6.0, 7.5, pos.y + 6.0); // Adjust these values to control where the fade starts/ends
    cube = mix(cube, cube + topFade, smoothstep(0.0, 1.0, topFade));
    
    pos.y += 7.;
    pos.z += -0.8;
    
    // Small cube detail with rounded corners
    float smallCube = fBoxRound(pos, vec3(0.5,7.,3)*0.4, roundness);
    // Smooth blend for the small cube
    cube = smax(cube, -smallCube, .1);
    
    pos.x += .2;
    pos.y -= id.y + 04.;
    pos.y *= 0.7;
    
    // Windows with slightly rounded corners
    float window = fBoxRound(pos + vec3(-0.72,0.,.0), vec3(0.5,1.3,6)*0.4, windowRoundness);
    window = smin(fBoxRound(pos + vec3(0.5,0,0), vec3(0.5,1.3,6)*0.4, windowRoundness), window, windowRoundness);
    window = smin(fBoxRound(pos - vec3(0,.9 *id.x*0.3 +0.3,0), vec3(0.5,1.3,6)*0.4, windowRoundness), window, windowRoundness);
    window = smin(fBoxRound(pos - vec3(0.4 * id.y,01.5,0), vec3(0.5,1.3,6)*0.4, windowRoundness), window, windowRoundness);
    
    // Smooth subtraction for windows
    cube = smax(cube, -window, windowRoundness);
    
    return cube;
}

 vec3 estimateNormal(vec3 p) {
    float smallNumber = 0.002;
    vec3 n = vec3(
    scene(vec3(p.x + smallNumber, p.yz)) -
    scene(vec3(p.x - smallNumber, p.yz)),
    scene(vec3(p.x, p.y + smallNumber, p.z)) -
    scene(vec3(p.x, p.y - smallNumber, p.z)),
    scene(vec3(p.xy, p.z + smallNumber)) -
    scene(vec3(p.xy, p.z - smallNumber)));
    return normalize(n);
}


vec4 lighting(vec3 ray, vec2 id){
    vec3 norm = estimateNormal(ray);
    vec3 light = vec3(1., 0., 0.);
    float dif = max(dot(norm, light), 0.0); // Add max to prevent negative values
    vec4 retCol = vec4(dif);
    // Add ambient light to prevent pure black
    float ambient = 0.9621;
    retCol += vec4(ambient);
    
    vec3 lightRayDir = normalize(light - ray);
    return retCol * vec4(norm, 1.0);
}

vec4 trace(vec3 rayO, vec3 dir){
    vec3 ray = rayO;
    float dist = 0.;
    float totalDist = 0.;
    
    for(int i = 0; i < 128; ++i){
        dist = scene(ray);
        totalDist += dist;
        ray += dist * dir;
        
        if(dist < 0.01){
            vec4 retCol = 1.0 - (vec4(totalDist) / 5.0);
            return lighting(ray, ray.xy) * retCol + rand(ray.xy ); 
        }
    }
    return vec4(0.0);
}


vec3 integrate(vec3 cur, float dt){
    float dx,dy,dz;
    dx = (cur.y - cur.x)*.01;
    dy = 3.*cur.z*(cur.x) - 8.*cur.y;
    dz = cur.y*cur.z - 10.*cur.z;
    cur.x += dx*dt;
    cur.y += dy*dt;
    cur.z += dz*dt;
    return cur;
}
vec3 getRdIsometric(inout vec3 ro, vec3 lookAt, vec2 uv){
    vec3 rd = normalize(
        lookAt -
        ro
    );
    
    vec3 right = normalize(cross(vec3(0,1,0), rd));
    vec3 up = normalize(cross(rd, right));
    
    float zoom = 9.;
    ro += right*uv.x*zoom;
    ro += up*uv.y*zoom;
    return rd;

}
void main(void)
{
    
    vec2 uv = -1. + 2. * v_texcoord;
    uv.y -=0.3;
    uv.y*= resolution.y/resolution.x;
    uv.y*= 1.2;
    vec3 cam =vec3(cos(time)*time *0.5,(cos(4.*time + 20.) + 1.)*0.3,-5.);
    
    vec3 lookAt = vec3(0,-1.,-1);
    
    
    vec3 ro = vec3(0,2,0);
   
    vec3 dir = getRdIsometric(ro, lookAt, uv); 
    //vec3 dir = ro - ro;
    
    
    vec4 col = trace(ro, dir);
    gl_FragColor =col.rrrr ;
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
}