#define R 10.
// #define Camera vec3( R * sin(iTime * 0.2), 5. ,R * cos(iTime *0.2))
vec2 fixUV(vec2 uv) {
    return  (2. * uv - iResolution.xy )/ iResolution.y;
}

float random(vec2 pos) {
vec3 p3  = fract(vec3(pos.xyx) * .1031);
    p3 += dot(p3, p3.yzx + 33.33);
    return fract((p3.x + p3.y) * p3.z);
    return fract(sin(dot(pos, vec2(12.9898, 78.233))) * 43758.5453);
}


vec3 noise(vec2 pos) {
    vec2 i = floor(pos);
    vec2 f = fract(pos);
    // 平滑计算
    vec2 u = f * f * (3.0 - 2.0 * f);
    // 阶梯导数
    vec2 du = 5. * u * (1.0 - u);

    float a = random(i);
    float b = random(i + vec2(1.0, 0.));
    float c = random(i + vec2(0.0, 1.0));
    float d = random(i + vec2(1.0, 1.0));

    // return mix(a, b, u.x) + (c - a) * u.y * (1.0 - u.x) + (d - b) * u.x * u.y;

    //变为vec3 x:噪声值 yz：阶梯值

    return vec3(mix(a, b, u.x) + (c - a) * u.y * (1.0 - u.x) + (d - b) * u.x * u.y,
        du * (vec2(b-a ,c-a) + (a-b-c + d) * u.yx)
    );
}

mat2 mat = mat2(0.6, -0.8, 0.8, 0.6);
float threeRect(vec2 p){
    float a = 0.;// 幅度
    float b = 1.;// 缩放
    vec2 d = vec2(0.);//梯度

    for(int i = 0; i < 8; i++){
        vec3 n = noise(p);
        //累加噪声
        d += n.yz;
        // 梯度越大的地方加的的幅度越小
        a += b * n.x /( 1.+ dot(d, d));
        p *= mat * 2. ;
        b *= 0.5;

    }

    // return 2. * noise(p);

    return a;
}

vec3 rectdNormal(vec3 p) {

     vec2 epsilon = vec2(1e-5, 0);
    return normalize(vec3(
        threeRect(p.xz + epsilon.xy) - threeRect(p.xz - epsilon.xy),
        2.0 * epsilon.x,
        threeRect(p.xz + epsilon.yx) - threeRect(p.xz - epsilon.yx)));
}

//相机矩阵
mat3 cameraMatrix(vec3 ro){
    vec3 target = vec3(0., 0.0, 0.);
    float cr = 0.;
    vec3 z = normalize(target - ro);
    vec3 up = normalize(vec3(sin(cr), cos(cr), 0));
    vec3 x = cross(z, up);
    vec3 y = cross(x, z);
    return mat3(x, y, z);
}


float RayMarching(vec3 rd,vec3 position) {
    // 迭代光线
    float d = 0.1;
    for(int i = 0; i < 128; i++){
        //当前迭代光线与相机的距离
        vec3 p = position + rd * d;
        
        float dist = p.y - threeRect(p.xz);
        // 判断是否在球内
        if(dist < 0.01){
            break;
        }
        d += 0.2*dist;
    }
    return d;
}

vec3 render (vec2 uv) {
   vec3 color = vec3(.0);
    float an = 0.2 * iTime;
    float r = 2.;
    vec3 ro = vec3(r * sin(an), 5, r * cos(an));
    mat3 cam = cameraMatrix(ro);
    // 相机到当前片原的向量
    vec3 rd = normalize(cam * vec3(uv, 1.));
    float t = RayMarching(rd, ro);

    if (t < 200.){
        vec3 p = ro + t * rd;

        vec3 n = rectdNormal(p);
        vec3 difColor = vec3(0.9, 0.8, 0.);
        color = difColor * dot(n, vec3(0, 1, 0));
    }

    return sqrt(color);
}


void mainImage(out vec4 fragColor, in vec2 fragCoord){
    vec2 uv = fixUV(fragCoord);
    vec3 color = render(uv);
    fragColor = vec4(color,1.0);

}