float         fade(float t) { return t * t * t * (t * (t * 6 - 15) + 10); }
    float         linear(float start,float end,float coef){return coef*(end-start)+start;}
    float         poly(float coef){return 3.f*coef*coef - 2.f*coef*coef*coef ;}
    float         interp2(float start,float end,float coef){return linear(start, end, poly(coef));}
    float         interp3(float start,float end,float coef){return linear(start, end, fade(coef));}
         sandbox::sandbox(){
    }
    float interpsmoother(float a, float b, float x){
        return interp(a,b,fade(x));
        //    return 3*x*x-2*x*x*x;
    //    return fade(x);
    }
    float getnoise(Vec2&A, Vec2&B, Vec2&C, Vec2&D, Vec2 rel){
    //    Vec2 grad = interp(interp(A,B,rel.x),interp(C,D,rel.x),rel.y);
    //    rel=rel*.8f+Vec2(.125f,.125f);
    //    rel+=Vec2(.1,.1);
        float
        dot_a=prod(A ,Vec2((rel.x   ),rel.y)),
        dot_b=prod(B ,Vec2((rel.x-1 ),rel.y)),
        dot_c=prod(C ,Vec2((rel.x   ),rel.y-1)),
        dot_d=prod(D ,Vec2((rel.x-1 ),rel.y-1));
    //#define DATINTERP interpsmooth
    //#define DATINTERP interpsmoother
    //#define DATINTERP interp
    #define DATINTERP interp2
    //#define DATINTERP interp3
        return DATINTERP
        (DATINTERP(dot_a,dot_b,rel.x),DATINTERP(dot_c,dot_d,rel.x),rel.y);
    //    return interpsmooth
    //    (interpsmooth(dot_a,dot_b,rel.x),interpsmooth(dot_c,dot_d,rel.x),rel.y);
    }
    void diagnose(int divisions, float cellsize, vector<Vec2> & randv)
    {
        glines.clear();

        for(int jj=0;jj<=divisions;++jj){
            for(int ii=0;ii<=divisions;++ii)
            {
                Vec2
                A = randv[divisions*jj      +ii];
                glines.append(Vertex(Vec2(10,10)+cellsize*Vec2(ii,jj)));
                glines.append(Vertex(Vec2(10,10)+cellsize*Vec2(ii,jj)+A*cellsize*.5f));
                ptpls.put(Vec2(10,10)+cellsize*Vec2(ii,jj));
            }
        }
    //    lb2(getnoise(randv[0],randv[1],randv[2],randv[3],Vec2(0,0)));
    }
    Vec2 getrel(int i, int j, float cellsize){
        return Vec2
        (float
         (i // which pixel
          -(i/int(cellsize))//which cell
          *cellsize)// floor() equivalent
          /cellsize,// [0,1] range
         float(j-(j/int(cellsize))*cellsize)/cellsize
         )
    //    *.8f+Vec2(.125,.125)
        ;
    }
    void sandbox::init(){
        show_diagnose = false;
        call=cfg->getstring("noise_call");
        seed = cfg->getint("noise_seed");
    //    float maxval=-1e20,minval=1e20;

        int pixels = cfg->getint("noise_size");
        int divisions = cfg->getint("noise_divisions");
        float cellsize = float(pixels)/divisions;

        lambdas["noise_good"]=
        [this,cellsize,pixels,divisions]()
        {
            auto randv = seeded_rand_vec2(seed,(divisions+1)*(divisions+1));
            float factor=2.f;
            for(auto&a:randv)
            {
                a= a*factor-factor*.5f*Vec2(1.f,1.f);
                a=normalize(a);
            }
            glines.clear();
            ptpls.clear();
            if (show_diagnose) diagnose(divisions,cellsize,randv);
    //        Image img;
            img.create(pixels,pixels,Color(0,0,0));
            float maxval=-1e20,minval=1e20;
            float maxval2=-1e20,minval2=1e20;
            for(int j=0;j<pixels;++j)
            {
                for(int i=0;i<pixels;++i)
                {
                    int ii = int(i/cellsize);
                    int jj = int(j/cellsize);
                    Vec2
                    A = randv[divisions*jj      +ii],
                    B = randv[divisions*jj      +ii+1],
                    C = randv[divisions*(jj+1)  +ii],
                    D = randv[divisions*(jj+1)  +ii+1];

                    float val = getnoise(A,B,C,D,getrel(i,j,cellsize));
                    if(val>maxval)maxval=val;lb2(maxval);
                    if(val<minval)minval=val;lb2(minval);

    //                val+=.7f;
    //                val*=.7f;
                    val = .5f*(val+.7f);
                    if(val>maxval2)maxval2=val;lb2(maxval2);
                    if(val<minval2)minval2=val;lb2(minval2);
    //                Color c = rgb_from_hue(val);
    //                img.setPixel(i,j,c);
                    val*=255.f;
                    img.setPixel(i,j,Color(val,val,val));
                }
            }
            tx.loadFromImage(img);
            spr.setPosition(Vec2(10,10));
            spr.setTexture(tx);
            lb2(minval);
            lb2(maxval);
            lb2(minval2);
            lb2(maxval2);
            lb2(randv[0]);
            lb2(randv[1]);
            lb2(randv[2]);

        };