src/shaders/advectWaterShader.comp

Go to the documentation of this file.

#version 430

layout(local_size_x = 16, local_size_y = 16) in; 

layout  (std430,binding = 4) readonly buffer height0 
{
    float water0[];
    
};

layout (std430, binding = 5) writeonly buffer height1 
{
    float water1[]; 
};

layout (std430,binding = 6) readonly buffer velocityX 
{
    float vxin[];
    
};

layout (std430,binding = 7) readonly buffer velocityXout 
{
    float vxout[];
    
};


layout (std430,binding = 8) readonly buffer velocityY 
{   
    float vyin[];
    
};


layout (std430,binding = 9) readonly buffer velocityYout 
{   
    float vyout[];
    
};

layout (std430,binding = 10) readonly buffer Terrain 
{   
    float terr[];
    
};


uniform ivec2 size; 
uniform float dt; 



float average(int i, int j){ 
    i = clamp(i,0,size.x-1);
    j = clamp(j,0,size.y-1);
    int ipos = clamp(i+1,0,size.x-1);
    int jpos = clamp(j+1,0,size.y-1);
    int imin = clamp(i-1,0,size.x-1);
    int jmin = clamp(j-1,0,size.y-1);
        
    int offset = i+ j*size.x;
    int offsete = ipos+j*size.x;
    int offsetw = imin+j*size.x;
    int offsetn = i+jpos*size.x;
    int offsets = i+jmin*size.x;

    return 0.2f*(water0[offset] +water0[offsete] +water0[offsetw] +water0[offsetn] +water0[offsets]); 

}
float bilinjearInterpolation(float point_x, float point_y)
{
    //picking out the nearby points
    int x = int(point_x);
    int y = int(point_y);

    //picking out the distances to the point from nearby points
    float s1 = point_x - float(x);
    float s0 = 1.0f - s1;

    float t1 = point_y - float(y);
    float t0 = 1.0f - t1;
    
    int ypos = clamp(y+1,0,size.y-1);
    int xpos = clamp(x+1,0,size.x-1);
    
    int offset0 = x +y*size.x;
    int offset1 = x +(ypos)*size.x;
    int offset2 = xpos +y*size.x;
    int offset3 = xpos +(ypos)*size.x;
    float totalWater0 = water0[offset0];// + terr[offset0];
    float totalWater1 = water0[offset1];// + terr[offset1];
    float totalWater2 = water0[offset2];// + terr[offset2];
    float totalWater3 = water0[offset3];// + terr[offset3];
     

    return s0*(t0*totalWater0 + t1*totalWater1) +
        s1*(t0*totalWater2 + t1*totalWater3);
    
}


void main(){
    //determine where to sample
    ivec2 storePos = ivec2(gl_GlobalInvocationID.xy);
    int i = storePos.x;
    int j = storePos.y;
    int offset = (i + j*size.x);

    //Change these to clamps.
    if(i < size.x && j < size.y ) {
        int ipos = clamp(i+1,0,size.x-1);
        int jpos = clamp(j+1,0,size.y-1);
        int imin = clamp(i-1,0,size.x-1);
        int jmin = clamp(j-1,0,size.y-1);
        
        float u = 0.0f; // Temporary velocity in x
        float v = 0.0f; // Temporary velocity in y 

        //Coordinate system HERE! <  is to the right and up.

        int offsetright = ipos+j*size.x;
        int offsetleft = imin+j*size.x;
        int offsetup = i+jpos*size.x;
        int offsetdown = i+jmin*size.x;
        int offsettopright = ipos+jpos*size.x;
        int sampX,sampY;
        
        u = (vxin[offsetleft]+ vxin[offset] +vxin[offsetright])*0.33f;
        v = (vyin[offsetdown] + vyin[offset] +vyin[offsetup])*0.33f;
        
        float source_point_x = clamp(float(i)-u*dt,0.0f,float(size.x)-1.0f);//   clamp(float(i)-u*dt, float(i)-1.0f,float(i)+1.0f); // 
        float source_point_y =clamp(float(j)-v*dt,0.0f,float(size.y)-1.0f); // clamp(float(j)-v*dt, float(j)-1.0f,float(j)+1.0f); //
        
        water1[offset] =bilinjearInterpolation(source_point_x, source_point_y);
        //water1[offset] =average(int(source_point_x), int(source_point_y));
    }
}