self shadow bump mapping

void RendererLightBM(int x,int y,int r)
	{
		for(int py=y-r;py<y+r;py+=1)
		{
			for(int px=x-r;px<x+r;px+=1)
			{  
				float r2=1-sqrt( (px-x)*(px-x)+(py-y)*(py-y))/float(r);
				if(r2<0)
					r2=0;
				if(r2>1)
					r2=1;
				if(r2>0)
				{

				unsigned char red;
				unsigned char green;
				unsigned char blue;

				unsigned char leftred,leftgreen,leftblue;
				unsigned char rightred,rightgreen,rightblue;
				unsigned char upred,upgreen,upblue;
				unsigned char downred,downgreen,downblue;
				float left,right,up,down;
				float poziom,pion;
				GetPixel(px-1,py,leftred,leftgreen,leftblue);//tutaj zaczyna liczyć bump mape
				GetPixel(px+1,py,rightred,rightgreen,rightblue);
				GetPixel(px,py-1,upred,upgreen,upblue);
				GetPixel(px,py+1,downred,downgreen,downblue);

				left=float(float(leftred)/255+float(leftgreen)/255+float(leftblue)/255)/3;
				right=float(float(rightred)/255+float(rightgreen)/255+float(rightblue)/255)/3;
				up=float(float(upred)/255+float(upgreen)/255+float(upblue)/255)/3;
				down=float(float(downred)/255+float(downgreen)/255+float(downblue)/255)/3;// a tutaj konczy

				poziom=(left+right)/2;
				pion=(up+down)/2;
				float lenght=sqrt(poziom*poziom+pion*pion);
				poziom=poziom/lenght;
				pion=pion/lenght;
				float lightDirX,lightDirY;
				lightDirX=x+r;
				lightDirY=y+r;
				lightDirX=lightDirX-px;
				lightDirY=lightDirY-py;
				lenght=sqrt(lightDirX*lightDirX+lightDirY*lightDirY);
				lightDirX=lightDirX/lenght;
				lightDirY=lightDirY/lenght;
				float S=lightDirX*poziom+lightDirY*pion;
				if(S<0)
					S=0;
				if(S>1)
					S=1;
				GetPixel(px,py,red,green,blue);
				float r1,g1,b1;

				r1=float(red)/255;
				g1=float(green)/255;
				b1=float(blue)/255;
		
				float r,g,b;
				r=r1;
				g=g1;
				b=b1;
				
				
				r1=(1-r1)*S*r2*r1*2+r1;
				g1=(1-g1)*S*r2*g1*2+g1;
				b1=(1-b1)*S*r2*b1*2+b1;

				if(r1<r)
					r1=r;
				if(g1<g)
					g1=g;
				if(b1<b)
					b1=b;

				if(r1>1)
					r1=1;
				if(g1>1)
					g1=1;
				if(b1>1)
					b1=1;
				unsigned char rW=r1*255;
				unsigned char gW=g1*255;
				unsigned char bW=b1*255;
				
			
				Color3iT(rW,gW,bW);
				PutPixelT(px,py);
				}

			}
		}
	}

#version 330 core

in vec3 FragPos; // Fragment position
in vec3 Normal;  // Normal vector
in vec2 TexCoords; // Texture coordinates

uniform sampler2D bumpMap;    // Bump map texture
uniform sampler2D shadowMap;  // Shadow map texture
uniform vec3 lightPos;        // Light position
uniform vec3 viewPos;         // Camera position

out vec4 FragColor;

float ShadowCalculation(vec4 fragPosLightSpace) {
    // Transform fragment position to light space (shadow map space)
    vec3 projCoords = fragPosLightSpace.xyz / fragPosLightSpace.w;
    projCoords = projCoords * 0.5 + 0.5;  // Normalize coordinates to [0,1]

    float currentDepth = projCoords.z;  // Depth of the current fragment
    float shadow = 0.0;

    // Check if the current fragment is in shadow
    if (currentDepth > texture(shadowMap, projCoords.xy).r) {
        shadow = 1.0;  // Shadowed
    } else {
        shadow = 0.0;  // Not shadowed
    }

    return shadow;
}

void main() {
    // Sample the bump map to get the normal at this fragment
    vec3 bumpNormal = texture(bumpMap, TexCoords).rgb;
    bumpNormal = normalize(bumpNormal * 2.0 - 1.0); // Normalize normal map value [-1, 1]

    // Lighting calculations
    vec3 lightDir = normalize(lightPos - FragPos); // Light direction
    vec3 viewDir = normalize(viewPos - FragPos);   // View direction
    vec3 halfDir = normalize(lightDir + viewDir);  // Halfway vector for specular reflection

    // Phong shading
    float diffuse = max(dot(bumpNormal, lightDir), 0.0);
    float specular = pow(max(dot(bumpNormal, halfDir), 0.0), 32.0);  // Shininess = 32

    // Shadow calculation
    vec4 fragPosLightSpace = model * vec4(FragPos, 1.0);  // Model matrix to light space
    float shadow = ShadowCalculation(fragPosLightSpace);

    // Final color (ambient + diffuse + specular + shadow)
    vec3 ambient = 0.1 * vec3(1.0, 1.0, 1.0);  // Ambient light
    vec3 color = (ambient + (1.0 - shadow) * (diffuse + specular)) * vec3(1.0, 1.0, 1.0);

    FragColor = vec4(color, 1.0);
}

float3 n = tex2D(Bump, texCoord) * 2.0 - 1.0;
n = normalize(n);
float height = tex2D(Elev, texCoord) * 2.0 - 1.0;
float nh = max(min(viewVec.z * n.z * height / max( dot(viewVec, n), 0), 1), -1);
float2 newTexCoord = texCoord + viewVec.xy * nh * 0.04;