diff options
Diffstat (limited to 'apps/openmb/resources/shaders')
19 files changed, 487 insertions, 0 deletions
diff --git a/apps/openmb/resources/shaders/.gitkeep b/apps/openmb/resources/shaders/.gitkeep new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/apps/openmb/resources/shaders/.gitkeep diff --git a/apps/openmb/resources/shaders/cube.frag b/apps/openmb/resources/shaders/cube.frag new file mode 100644 index 0000000..cb15430 --- /dev/null +++ b/apps/openmb/resources/shaders/cube.frag @@ -0,0 +1,21 @@ +#version 330 core +out vec4 FragColor; +uniform vec3 color; +in vec3 vFragPos; +uniform vec3 cameraPos; +uniform vec3 fogColor; +uniform float fogDensity; +uniform float fogAmount; + +void main() +{ + // Basic color with fog applied + vec3 base = color; + + // vFragPos provided by vertex shader + float dist = length(vFragPos - cameraPos); + float fogFactor = 1.0 - exp(-fogDensity * dist); + fogFactor = clamp(fogFactor * fogAmount, 0.0, 1.0); + vec3 finalColor = mix(base, fogColor, fogFactor); + FragColor = vec4(finalColor, 1.0); +} diff --git a/apps/openmb/resources/shaders/cube.vert b/apps/openmb/resources/shaders/cube.vert new file mode 100644 index 0000000..805c883 --- /dev/null +++ b/apps/openmb/resources/shaders/cube.vert @@ -0,0 +1,11 @@ +#version 330 core +layout(location = 0) in vec3 aPos; +uniform mat4 model; +uniform mat4 view; +uniform mat4 proj; +out vec3 vFragPos; +void main() +{ + vFragPos = vec3(model * vec4(aPos, 1.0)); + gl_Position = proj * view * model * vec4(aPos, 1.0); +} diff --git a/apps/openmb/resources/shaders/depth.frag b/apps/openmb/resources/shaders/depth.frag new file mode 100644 index 0000000..f6ba8e2 --- /dev/null +++ b/apps/openmb/resources/shaders/depth.frag @@ -0,0 +1,5 @@ +#version 330 core +void main() +{ + +} diff --git a/apps/openmb/resources/shaders/depth.vert b/apps/openmb/resources/shaders/depth.vert new file mode 100644 index 0000000..e80ee01 --- /dev/null +++ b/apps/openmb/resources/shaders/depth.vert @@ -0,0 +1,10 @@ +#version 330 core +layout(location = 0) in vec3 aPos; + +uniform mat4 model; +uniform mat4 lightSpace; + +void main() +{ + gl_Position = lightSpace * model * vec4(aPos, 1.0); +} diff --git a/apps/openmb/resources/shaders/gbuffer.frag b/apps/openmb/resources/shaders/gbuffer.frag new file mode 100644 index 0000000..f6ddb45 --- /dev/null +++ b/apps/openmb/resources/shaders/gbuffer.frag @@ -0,0 +1,10 @@ +#version 330 core +in vec2 vUV; +in vec3 vNormalView; +layout(location = 0) out vec3 gNormal; + +void main() +{ + vec3 n = normalize(vNormalView); + gNormal = n * 0.5 + 0.5; +} diff --git a/apps/openmb/resources/shaders/gbuffer.vert b/apps/openmb/resources/shaders/gbuffer.vert new file mode 100644 index 0000000..c9e677c --- /dev/null +++ b/apps/openmb/resources/shaders/gbuffer.vert @@ -0,0 +1,19 @@ +#version 330 core +layout(location = 0) in vec3 aPos; +layout(location = 1) in vec2 aUV; +layout(location = 2) in vec3 aNormal; + +uniform mat4 model; +uniform mat4 view; +uniform mat4 proj; + +out vec2 vUV; +out vec3 vNormalView; + +void main() +{ + vUV = aUV; + vec4 viewPos = view * model * vec4(aPos, 1.0); + vNormalView = mat3(transpose(inverse(view * model))) * aNormal; + gl_Position = proj * viewPos; +} diff --git a/apps/openmb/resources/shaders/godrays_quad.vert b/apps/openmb/resources/shaders/godrays_quad.vert new file mode 100644 index 0000000..6a33825 --- /dev/null +++ b/apps/openmb/resources/shaders/godrays_quad.vert @@ -0,0 +1,11 @@ +#version 330 core +layout (location = 0) in vec3 aPos; +layout (location = 1) in vec2 aTex; + +out vec2 vTex; + +void main() +{ + vTex = aTex; + gl_Position = vec4(aPos, 1.0); +} diff --git a/apps/openmb/resources/shaders/godrays_radial.frag b/apps/openmb/resources/shaders/godrays_radial.frag new file mode 100644 index 0000000..3dfac87 --- /dev/null +++ b/apps/openmb/resources/shaders/godrays_radial.frag @@ -0,0 +1,44 @@ +#version 330 core +in vec2 vTex; +out vec4 FragColor; + +uniform sampler2D occlusionTex; +uniform vec2 lightScreenPos; // in [0,1] +uniform vec3 sunColor; +uniform float sunIntensity; +uniform float globalIntensity; +uniform int samples; +uniform float density; +uniform float weight; +uniform float decay; + +void main() +{ + vec2 texCoord = vTex; + // vector from current pixel to light + vec2 delta = lightScreenPos - texCoord; + float dist = length(delta); + vec2 stepv = delta * (1.0 / float(samples)) * density; + + vec3 illumination = vec3(0.0); + float illumDecay = 1.0; + + vec2 coord = texCoord; + for (int i = 0; i < samples; ++i) + { + coord += stepv; + vec3 sample = texture(occlusionTex, coord).rgb; + // occlusion tex stores white where geometry present + float occ = sample.r; + illumination += occ * illumDecay * weight; + illumDecay *= decay; + } + + vec3 result = illumination * sunColor * sunIntensity * globalIntensity; + // tone-map / clamp to avoid extreme brightness + result = clamp(result, vec3(0.0), vec3(1.0)); + // use luminance as alpha so we can composite less aggressively + float lum = dot(result, vec3(0.299, 0.587, 0.114)); + float alpha = clamp(lum, 0.0, 1.0); + FragColor = vec4(result, alpha); +} diff --git a/apps/openmb/resources/shaders/occlusion.frag b/apps/openmb/resources/shaders/occlusion.frag new file mode 100644 index 0000000..02a0732 --- /dev/null +++ b/apps/openmb/resources/shaders/occlusion.frag @@ -0,0 +1,8 @@ +#version 330 core +out vec4 FragColor; + +void main() +{ + // Solid white occluder + FragColor = vec4(1.0); +} diff --git a/apps/openmb/resources/shaders/occlusion.vert b/apps/openmb/resources/shaders/occlusion.vert new file mode 100644 index 0000000..9d95f3a --- /dev/null +++ b/apps/openmb/resources/shaders/occlusion.vert @@ -0,0 +1,11 @@ +#version 330 core +layout (location = 0) in vec3 aPos; + +uniform mat4 model; +uniform mat4 view; +uniform mat4 proj; + +void main() +{ + gl_Position = proj * view * model * vec4(aPos, 1.0); +} diff --git a/apps/openmb/resources/shaders/skybox.frag b/apps/openmb/resources/shaders/skybox.frag new file mode 100644 index 0000000..f9e41eb --- /dev/null +++ b/apps/openmb/resources/shaders/skybox.frag @@ -0,0 +1,8 @@ +#version 330 core +in vec3 TexCoords; +out vec4 FragColor; +uniform samplerCube skybox; +void main() +{ + FragColor = texture(skybox, TexCoords); +} diff --git a/apps/openmb/resources/shaders/skybox.vert b/apps/openmb/resources/shaders/skybox.vert new file mode 100644 index 0000000..8e66a99 --- /dev/null +++ b/apps/openmb/resources/shaders/skybox.vert @@ -0,0 +1,10 @@ +#version 330 core +layout(location = 0) in vec3 aPos; +out vec3 TexCoords; +uniform mat4 view; +uniform mat4 proj; +void main() +{ + TexCoords = aPos; + gl_Position = proj * view * vec4(aPos, 1.0); +} diff --git a/apps/openmb/resources/shaders/ssao.frag b/apps/openmb/resources/shaders/ssao.frag new file mode 100644 index 0000000..60479f2 --- /dev/null +++ b/apps/openmb/resources/shaders/ssao.frag @@ -0,0 +1,76 @@ +#version 330 core +in vec2 vUV; +out float FragColor; + +uniform sampler2D gDepth; +uniform sampler2D gNormal; +uniform sampler2D texNoise; + +uniform vec3 samples[64]; +uniform mat4 proj; +uniform mat4 invProj; +uniform float radius; +uniform float bias; +uniform float noiseScale; + +uniform int kernelSize; +uniform float power; + +vec3 getViewPos(vec2 uv) +{ + float depth = texture(gDepth, uv).r; + if (depth == 1.0) return vec3(0.0); + float z = depth * 2.0 - 1.0; + vec4 clip = vec4(uv * 2.0 - 1.0, z, 1.0); + vec4 viewPos = invProj * clip; + viewPos /= viewPos.w; + return viewPos.xyz; +} + +void main() +{ + vec3 fragPos = getViewPos(vUV); + if (fragPos == vec3(0.0)) + { + FragColor = 1.0; + return; + } + + vec3 normal = texture(gNormal, vUV).rgb; + normal = normalize(normal * 2.0 - 1.0); + + vec3 randomVec = normalize(texture(texNoise, vUV * noiseScale).xyz * 2.0 - 1.0); + + + vec3 tangent = normalize(randomVec - normal * dot(randomVec, normal)); + vec3 bitangent = cross(normal, tangent); + mat3 TBN = mat3(tangent, bitangent, normal); + + float occlusion = 0.0; + for (int i = 0; i < kernelSize; ++i) + { + vec3 sample = TBN * samples[i]; + sample = fragPos + sample * radius; + + + vec4 offset = proj * vec4(sample, 1.0); + offset.xyz /= offset.w; + vec2 sampleUV = offset.xy * 0.5 + 0.5; + + if (sampleUV.x < 0.0 || sampleUV.x > 1.0 || sampleUV.y < 0.0 || sampleUV.y > 1.0) + continue; + + vec3 samplePos = getViewPos(sampleUV); + if (samplePos == vec3(0.0)) + continue; + + float rangeCheck = smoothstep(0.0, 1.0, radius / abs(fragPos.z - samplePos.z)); + float diff = samplePos.z - sample.z; + if (diff > bias) + occlusion += rangeCheck; + } + + occlusion = 1.0 - (occlusion / float(kernelSize)); + occlusion = pow(occlusion, power); + FragColor = occlusion; +} diff --git a/apps/openmb/resources/shaders/ssao.vert b/apps/openmb/resources/shaders/ssao.vert new file mode 100644 index 0000000..5afd1d3 --- /dev/null +++ b/apps/openmb/resources/shaders/ssao.vert @@ -0,0 +1,9 @@ +#version 330 core +layout(location = 0) in vec2 aPos; +layout(location = 1) in vec2 aUV; +out vec2 vUV; +void main() +{ + vUV = aUV; + gl_Position = vec4(aPos, 0.0, 1.0); +} diff --git a/apps/openmb/resources/shaders/ssao_blur.frag b/apps/openmb/resources/shaders/ssao_blur.frag new file mode 100644 index 0000000..e093eff --- /dev/null +++ b/apps/openmb/resources/shaders/ssao_blur.frag @@ -0,0 +1,45 @@ +#version 330 core +in vec2 vUV; +out float FragColor; + +uniform sampler2D ssaoInput; +uniform vec2 texelSize; +uniform int horizontal; + + +const float w0 = 0.2270270270; +const float w1 = 0.1945945946; +const float w2 = 0.1216216216; +const float w3 = 0.0540540541; +const float w4 = 0.0162162162; + +void main() +{ + float result = 0.0; + if (horizontal == 1) + { + result += texture(ssaoInput, vUV).r * w0; + result += texture(ssaoInput, vUV + vec2(texelSize.x, 0.0)).r * w1; + result += texture(ssaoInput, vUV - vec2(texelSize.x, 0.0)).r * w1; + result += texture(ssaoInput, vUV + vec2(2.0 * texelSize.x, 0.0)).r * w2; + result += texture(ssaoInput, vUV - vec2(2.0 * texelSize.x, 0.0)).r * w2; + result += texture(ssaoInput, vUV + vec2(3.0 * texelSize.x, 0.0)).r * w3; + result += texture(ssaoInput, vUV - vec2(3.0 * texelSize.x, 0.0)).r * w3; + result += texture(ssaoInput, vUV + vec2(4.0 * texelSize.x, 0.0)).r * w4; + result += texture(ssaoInput, vUV - vec2(4.0 * texelSize.x, 0.0)).r * w4; + } + else + { + result += texture(ssaoInput, vUV).r * w0; + result += texture(ssaoInput, vUV + vec2(0.0, texelSize.y)).r * w1; + result += texture(ssaoInput, vUV - vec2(0.0, texelSize.y)).r * w1; + result += texture(ssaoInput, vUV + vec2(0.0, 2.0 * texelSize.y)).r * w2; + result += texture(ssaoInput, vUV - vec2(0.0, 2.0 * texelSize.y)).r * w2; + result += texture(ssaoInput, vUV + vec2(0.0, 3.0 * texelSize.y)).r * w3; + result += texture(ssaoInput, vUV - vec2(0.0, 3.0 * texelSize.y)).r * w3; + result += texture(ssaoInput, vUV + vec2(0.0, 4.0 * texelSize.y)).r * w4; + result += texture(ssaoInput, vUV - vec2(0.0, 4.0 * texelSize.y)).r * w4; + } + + FragColor = result; +} diff --git a/apps/openmb/resources/shaders/textured.frag b/apps/openmb/resources/shaders/textured.frag new file mode 100644 index 0000000..ea5e207 --- /dev/null +++ b/apps/openmb/resources/shaders/textured.frag @@ -0,0 +1,45 @@ +#version 330 core + +in vec2 vUV; +out vec4 FragColor; + +uniform sampler2D albedo; +uniform sampler2D normalMap; +uniform int normalEnabled; +uniform float normalStrength; +uniform vec3 tint; +uniform int radialEnabled; +uniform float radialInner; +uniform float radialOuter; + +void main() +{ + vec4 tex = texture(albedo, vUV); + vec3 color = tex.rgb * tint; + float alpha = tex.a; + vec3 finalNormal = vec3(0.0, 0.0, 1.0); + if (normalEnabled == 1) + { + vec3 n = texture(normalMap, vUV).rgb; + n = n * 2.0 - 1.0; + finalNormal = normalize(vec3(n.x * normalStrength, n.y * normalStrength, 1.0)); + } + if (radialEnabled == 1) + { + + float dist = distance(vUV, vec2(0.5, 0.5)); + + float mask = 1.0 - smoothstep(radialInner, radialOuter, dist); + alpha *= mask; + } + + if (normalEnabled == 1) + { + vec3 lightDir = normalize(vec3(0.3, 1.0, 0.5)); + float l = max(dot(normalize(finalNormal), lightDir), 0.0); + + color *= (0.4 + 0.6 * l); + } + + FragColor = vec4(color, alpha); +} diff --git a/apps/openmb/resources/shaders/textured.vert b/apps/openmb/resources/shaders/textured.vert new file mode 100644 index 0000000..f71f407 --- /dev/null +++ b/apps/openmb/resources/shaders/textured.vert @@ -0,0 +1,23 @@ +#version 330 core +layout(location = 0) in vec3 aPos; +layout(location = 1) in vec2 aUV; +layout(location = 2) in vec3 aNormal; + +uniform mat4 model; +uniform mat4 view; +uniform mat4 proj; +uniform mat4 lightSpace; + +out vec2 vUV; +out vec3 vNormal; +out vec3 vFragPos; +out vec4 vFragPosLightSpace; + +void main() +{ + vUV = aUV; + vFragPos = vec3(model * vec4(aPos, 1.0)); + vNormal = mat3(transpose(inverse(model))) * aNormal; + vFragPosLightSpace = lightSpace * vec4(vFragPos, 1.0); + gl_Position = proj * view * model * vec4(aPos, 1.0); +} diff --git a/apps/openmb/resources/shaders/textured_lit.frag b/apps/openmb/resources/shaders/textured_lit.frag new file mode 100644 index 0000000..58c71f7 --- /dev/null +++ b/apps/openmb/resources/shaders/textured_lit.frag @@ -0,0 +1,121 @@ +#version 330 core + +in vec2 vUV; +in vec3 vNormal; +in vec3 vFragPos; +in vec4 vFragPosLightSpace; +out vec4 FragColor; + +uniform sampler2D albedo; +uniform sampler2D normalMap; +uniform int normalEnabled; +uniform float normalStrength; +uniform vec3 tint; +uniform int radialEnabled; +uniform float radialInner; +uniform float radialOuter; + +struct DirectionalLight +{ + vec3 direction; + vec3 color; + float intensity; +}; + +uniform DirectionalLight dirLight; +uniform vec3 ambientColor = vec3(0.15, 0.15, 0.15); +uniform sampler2D shadowMap; +uniform float shadowBiasMin; +uniform float shadowBiasScale; +uniform int pcfRadius; +uniform sampler2D ssao; +uniform float aoStrength; +uniform float screenWidth; +uniform float screenHeight; + +// Fog +uniform vec3 cameraPos; +uniform vec3 fogColor; +uniform float fogDensity; // e.g. 0.02 +uniform float fogAmount; // 0..1 blend factor +float ShadowCalculation(vec4 fragPosLightSpace, vec3 normal, vec3 lightDir) +{ + + vec3 projCoords = fragPosLightSpace.xyz / fragPosLightSpace.w; + + projCoords = projCoords * 0.5 + 0.5; + + if (projCoords.z > 1.0) + return 0.0; + + + float currentDepth = projCoords.z; + + float bias = max(shadowBiasScale * (1.0 - max(dot(normal, lightDir), 0.0)), shadowBiasMin); + + + ivec2 texSize = textureSize(shadowMap, 0); + vec2 texelSize = 1.0 / vec2(texSize); + float vis = 0.0; + int samples = 0; + for (int x = -pcfRadius; x <= pcfRadius; ++x) + { + for (int y = -pcfRadius; y <= pcfRadius; ++y) + { + vec2 offset = vec2(x, y) * texelSize; + float depthSample = texture(shadowMap, projCoords.xy + offset).r; + // texture returns stored light-space depth. If our fragment's depth (minus bias) + // is less than or equal to the sampled depth, it's visible to the light. + vis += (currentDepth - bias <= depthSample) ? 1.0 : 0.0; + samples++; + } + } + float visibility = vis / float(samples); + float shadow = 1.0 - visibility; + return shadow; +} + +void main() +{ + vec4 tex = texture(albedo, vUV); + vec3 color = tex.rgb * tint; + float alpha = tex.a; + vec3 finalNormal = vec3(0.0, 0.0, 1.0); + if (normalEnabled == 1) + { + vec3 n = texture(normalMap, vUV).rgb; + n = n * 2.0 - 1.0; + finalNormal = normalize(vec3(n.x * normalStrength, n.y * normalStrength, 1.0)); + } + if (radialEnabled == 1) + { + float dist = distance(vUV, vec2(0.5, 0.5)); + float mask = 1.0 - smoothstep(radialInner, radialOuter, dist); + alpha *= mask; + } + + + vec3 N = normalize(finalNormal); + vec3 L = normalize(dirLight.direction); + float diff = max(dot(N, L), 0.0); + vec3 diffuse = dirLight.color * dirLight.intensity * diff; + + float shadow = ShadowCalculation(vFragPosLightSpace, N, L); + float shadowFactor = 1.0 - shadow * 0.9; + float ao = 1.0; + if (aoStrength > 0.0) + { + vec2 ssaoUV = gl_FragCoord.xy / vec2(screenWidth, screenHeight); + ao = texture(ssao, ssaoUV).r; + } + float aoFactor = mix(1.0, ao, aoStrength); + vec3 result = color * (ambientColor * aoFactor + diffuse * shadowFactor); + + // Compute fog based on distance from camera + float dist = length(vFragPos - cameraPos); + float fogFactor = 1.0 - exp(-fogDensity * dist); + fogFactor = clamp(fogFactor * fogAmount, 0.0, 1.0); + vec3 finalColor = mix(result, fogColor, fogFactor); + + FragColor = vec4(finalColor, alpha); +} |