cozis/PBR-Demo
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

General clean up

Browse Source
This commit is contained in:
cozis
2024-10-15 18:56:25 +02:00
parent 3cc58e0b4b
commit 5e402d9077
17 changed files with 657 additions and 829 deletions
Download Patch File Download Diff File Expand all files Collapse all files
assets/shaders/background_fragment.glsl
+4 -4
View File
@@ -8,9 +8,9 @@ void main()
{
vec3 envColor = texture(environmentMap, WorldPos).rgb;
// HDR tonemap and gamma correct
envColor = envColor / (envColor + vec3(1.0));
envColor = pow(envColor, vec3(1.0/2.2));
// HDR tonemap and gamma correct
envColor = envColor / (envColor + vec3(1.0));
envColor = pow(envColor, vec3(1.0/2.2));
FragColor = vec4(envColor, 1.0);
FragColor = vec4(envColor, 1.0);
}
assets/shaders/background_vertex.glsl
+1 -1
View File
@@ -8,7 +8,7 @@ out vec3 WorldPos;
void main()
{
WorldPos = aPos;
WorldPos = aPos;
mat4 rotView = mat4(mat3(view));
vec4 clipPos = projection * rotView * vec4(WorldPos, 1.0);
assets/shaders/brdf_fragment.glsl
+57 -57
View File
@@ -3,24 +3,24 @@ out vec2 FragColor;
in vec2 TexCoords;
const float PI = 3.14159265359;
// ----------------------------------------------------------------------------
// http://holger.dammertz.org/stuff/notes_HammersleyOnHemisphere.html
// efficient VanDerCorpus calculation.
float RadicalInverse_VdC(uint bits)
{
bits = (bits << 16u) | (bits >> 16u);
bits = ((bits & 0x55555555u) << 1u) | ((bits & 0xAAAAAAAAu) >> 1u);
bits = ((bits & 0x33333333u) << 2u) | ((bits & 0xCCCCCCCCu) >> 2u);
bits = ((bits & 0x0F0F0F0Fu) << 4u) | ((bits & 0xF0F0F0F0u) >> 4u);
bits = ((bits & 0x00FF00FFu) << 8u) | ((bits & 0xFF00FF00u) >> 8u);
return float(bits) * 2.3283064365386963e-10; // / 0x100000000
bits = (bits << 16u) | (bits >> 16u);
bits = ((bits & 0x55555555u) << 1u) | ((bits & 0xAAAAAAAAu) >> 1u);
bits = ((bits & 0x33333333u) << 2u) | ((bits & 0xCCCCCCCCu) >> 2u);
bits = ((bits & 0x0F0F0F0Fu) << 4u) | ((bits & 0xF0F0F0F0u) >> 4u);
bits = ((bits & 0x00FF00FFu) << 8u) | ((bits & 0xFF00FF00u) >> 8u);
return float(bits) * 2.3283064365386963e-10; // / 0x100000000
}
// ----------------------------------------------------------------------------
vec2 Hammersley(uint i, uint N)
{
return vec2(float(i)/float(N), RadicalInverse_VdC(i));
}
// ----------------------------------------------------------------------------
vec3 ImportanceSampleGGX(vec2 Xi, vec3 N, float roughness)
{
float a = roughness*roughness;
@@ -36,78 +36,78 @@ vec3 ImportanceSampleGGX(vec2 Xi, vec3 N, float roughness)
H.z = cosTheta;
// from tangent-space H vector to world-space sample vector
vec3 up = abs(N.z) < 0.999 ? vec3(0.0, 0.0, 1.0) : vec3(1.0, 0.0, 0.0);
vec3 up = abs(N.z) < 0.999 ? vec3(0.0, 0.0, 1.0) : vec3(1.0, 0.0, 0.0);
vec3 tangent = normalize(cross(up, N));
vec3 bitangent = cross(N, tangent);
vec3 sampleVec = tangent * H.x + bitangent * H.y + N * H.z;
return normalize(sampleVec);
}
// ----------------------------------------------------------------------------
float GeometrySchlickGGX(float NdotV, float roughness)
{
// note that we use a different k for IBL
float a = roughness;
float k = (a * a) / 2.0;
// note that we use a different k for IBL
float a = roughness;
float k = (a * a) / 2.0;
float nom = NdotV;
float denom = NdotV * (1.0 - k) + k;
float nom = NdotV;
float denom = NdotV * (1.0 - k) + k;
return nom / denom;
return nom / denom;
}
// ----------------------------------------------------------------------------
float GeometrySmith(vec3 N, vec3 V, vec3 L, float roughness)
{
float NdotV = max(dot(N, V), 0.0);
float NdotL = max(dot(N, L), 0.0);
float ggx2 = GeometrySchlickGGX(NdotV, roughness);
float ggx1 = GeometrySchlickGGX(NdotL, roughness);
float NdotV = max(dot(N, V), 0.0);
float NdotL = max(dot(N, L), 0.0);
float ggx2 = GeometrySchlickGGX(NdotV, roughness);
float ggx1 = GeometrySchlickGGX(NdotL, roughness);
return ggx1 * ggx2;
return ggx1 * ggx2;
}
// ----------------------------------------------------------------------------
vec2 IntegrateBRDF(float NdotV, float roughness)
{
vec3 V;
V.x = sqrt(1.0 - NdotV*NdotV);
V.y = 0.0;
V.z = NdotV;
vec3 V;
V.x = sqrt(1.0 - NdotV*NdotV);
V.y = 0.0;
V.z = NdotV;
float A = 0.0;
float B = 0.0;
float A = 0.0;
float B = 0.0;
vec3 N = vec3(0.0, 0.0, 1.0);
vec3 N = vec3(0.0, 0.0, 1.0);
const uint SAMPLE_COUNT = 1024u;
for(uint i = 0u; i < SAMPLE_COUNT; ++i)
{
// generates a sample vector that's biased towards the
// preferred alignment direction (importance sampling).
vec2 Xi = Hammersley(i, SAMPLE_COUNT);
vec3 H = ImportanceSampleGGX(Xi, N, roughness);
vec3 L = normalize(2.0 * dot(V, H) * H - V);
const uint SAMPLE_COUNT = 1024u;
for(uint i = 0u; i < SAMPLE_COUNT; ++i) {
float NdotL = max(L.z, 0.0);
float NdotH = max(H.z, 0.0);
float VdotH = max(dot(V, H), 0.0);
// generates a sample vector that's biased towards the
// preferred alignment direction (importance sampling).
vec2 Xi = Hammersley(i, SAMPLE_COUNT);
vec3 H = ImportanceSampleGGX(Xi, N, roughness);
vec3 L = normalize(2.0 * dot(V, H) * H - V);
if(NdotL > 0.0)
{
float G = GeometrySmith(N, V, L, roughness);
float G_Vis = (G * VdotH) / (NdotH * NdotV);
float Fc = pow(1.0 - VdotH, 5.0);
float NdotL = max(L.z, 0.0);
float NdotH = max(H.z, 0.0);
float VdotH = max(dot(V, H), 0.0);
A += (1.0 - Fc) * G_Vis;
B += Fc * G_Vis;
}
}
A /= float(SAMPLE_COUNT);
B /= float(SAMPLE_COUNT);
return vec2(A, B);
if(NdotL > 0.0) {
float G = GeometrySmith(N, V, L, roughness);
float G_Vis = (G * VdotH) / (NdotH * NdotV);
float Fc = pow(1.0 - VdotH, 5.0);
A += (1.0 - Fc) * G_Vis;
B += Fc * G_Vis;
}
}
A /= float(SAMPLE_COUNT);
B /= float(SAMPLE_COUNT);
return vec2(A, B);
}
// ----------------------------------------------------------------------------
void main()
{
vec2 integratedBRDF = IntegrateBRDF(TexCoords.x, TexCoords.y);
FragColor = integratedBRDF;
vec2 integratedBRDF = IntegrateBRDF(TexCoords.x, TexCoords.y);
FragColor = integratedBRDF;
}
assets/shaders/brdf_vertex.glsl
+1
View File
@@ -1,4 +1,5 @@
#version 330 core
layout (location = 0) in vec3 aPos;
layout (location = 1) in vec2 aTexCoords;
assets/shaders/cubemap_vertex.glsl
+1
View File
@@ -1,4 +1,5 @@
#version 330 core
layout (location = 0) in vec3 aPos;
out vec3 WorldPos;
assets/shaders/equirectangular_to_cubemap_fragment.glsl
+13 -11
View File
@@ -1,31 +1,33 @@
#version 330 core
out vec4 FragColor;
in vec3 WorldPos;
in vec3 WorldPos;
uniform sampler2D equirectangularMap;
const vec2 invAtan = vec2(0.1591, 0.3183);
vec2 SampleSphericalMap(vec3 v)
{
vec2 uv = vec2(atan(v.z, v.x), asin(v.y));
uv *= invAtan;
uv += 0.5;
return uv;
vec2 uv = vec2(atan(v.z, v.x), asin(v.y));
uv *= invAtan;
uv += 0.5;
return uv;
}
void main()
{
vec2 uv = SampleSphericalMap(normalize(WorldPos));
vec3 color = texture(equirectangularMap, uv).rgb;
vec2 uv = SampleSphericalMap(normalize(WorldPos));
vec3 color = texture(equirectangularMap, uv).rgb;
// reinhard tone mapping
vec3 mapped = color / (color + vec3(1.0));
vec3 mapped = color / (color + vec3(1.0));
// gamma correction
// gamma correction
//float gamma = 2.2;
//mapped = pow(mapped, vec3(1.0 / gamma));
//mapped = pow(mapped, vec3(1.0 / gamma));
color = mapped;
FragColor = vec4(color, 1.0);
FragColor = vec4(color, 1.0);
}
assets/shaders/fragment.glsl
+52 -51
View File
@@ -29,66 +29,66 @@ uniform sampler2D brdfLUT;
float shadow_factor(vec4 frag_pos_light_space);
float distribGGX(float NoH, float a) {
float a2 = a * a;
float f = (NoH * a2 - NoH) * NoH + 1.0;
return a2 / (PI * f * f);
float a2 = a * a;
float f = (NoH * a2 - NoH) * NoH + 1.0;
return a2 / (PI * f * f);
}
vec3 fresnelSchlick(float u, vec3 f0) {
return f0 + (vec3(1.0) - f0) * pow(1.0 - u, 5.0);
return f0 + (vec3(1.0) - f0) * pow(1.0 - u, 5.0);
}
vec3 fresnelSchlickRoughness(float cosTheta, vec3 F0, float roughness)
{
return F0 + (max(vec3(1.0 - roughness), F0) - F0) * pow(clamp(1.0 - cosTheta, 0.0, 1.0), 5.0);
return F0 + (max(vec3(1.0 - roughness), F0) - F0) * pow(clamp(1.0 - cosTheta, 0.0, 1.0), 5.0);
}
float geometrySmith(float NoV, float NoL, float a) {
float a2 = a * a;
float GGXL = NoV * sqrt((-NoL * a2 + NoL) * NoL + a2);
float GGXV = NoL * sqrt((-NoV * a2 + NoV) * NoV + a2);
return 0.5 / (GGXV + GGXL);
float a2 = a * a;
float GGXL = NoV * sqrt((-NoL * a2 + NoL) * NoL + a2);
float GGXV = NoL * sqrt((-NoV * a2 + NoV) * NoV + a2);
return 0.5 / (GGXV + GGXL);
}
void main()
{
vec3 l = normalize(lightDir);
vec3 v = normalize(viewPos - fragPos);
vec3 n = frag_normal;
vec3 h = normalize(v + l);
vec3 l = normalize(lightDir);
vec3 v = normalize(viewPos - fragPos);
vec3 n = frag_normal;
vec3 h = normalize(v + l);
float light_intensity = 1;
float light_intensity = 1;
float perceptualRoughness2 = max(perceptualRoughness, 0.089);
float roughness = perceptualRoughness2 * perceptualRoughness2;
float perceptualRoughness2 = max(perceptualRoughness, 0.089);
float roughness = perceptualRoughness2 * perceptualRoughness2;
vec3 f0 = 0.16 * reflectance * reflectance * (1.0 - metallic) + baseColor * metallic;
vec3 f0 = 0.16 * reflectance * reflectance * (1.0 - metallic) + baseColor * metallic;
float NoV = abs(dot(n, v)) + 1e-5;
float NoL = clamp(dot(n, l), 0.0, 1.0);
float NoH = clamp(dot(n, h), 0.0, 1.0);
float LoH = clamp(dot(l, h), 0.0, 1.0);
float NoV = abs(dot(n, v)) + 1e-5;
float NoL = clamp(dot(n, l), 0.0, 1.0);
float NoH = clamp(dot(n, h), 0.0, 1.0);
float LoH = clamp(dot(l, h), 0.0, 1.0);
vec3 color = vec3(0);
vec3 color = vec3(0);
float shadow = shadow_factor(frag_pos_light_space);
// Direct lighting
{
float D = distribGGX(NoH, roughness);
vec3 F = fresnelSchlick(LoH, f0);
float V = geometrySmith(NoV, NoL, roughness);
// Direct lighting
{
float D = distribGGX(NoH, roughness);
vec3 F = fresnelSchlick(LoH, f0);
float V = geometrySmith(NoV, NoL, roughness);
vec3 specular = (F * D * V) / (4.0 * NoV * NoL + 0.0001);
vec3 specular = (F * D * V) / (4.0 * NoV * NoL + 0.0001);
vec3 diffuse = (1 - F) * (1 - metallic) * baseColor / PI;
vec3 diffuse = (1 - F) * (1 - metallic) * baseColor / PI;
color = (1 - shadow) * (diffuse + specular) * lightColor * light_intensity * NoL;
}
color = (1 - shadow) * (diffuse + specular) * lightColor * light_intensity * NoL;
}
// Ambient lighting with IBL
// Ambient lighting with IBL
vec3 ambient;
{
{
vec3 F = fresnelSchlickRoughness(NoV, f0, roughness);
vec3 irradiance = texture(irradianceMap, n).rgb;
@@ -105,32 +105,33 @@ void main()
float ao = 1;
ambient = ((1 - F) * (1 - metallic) * diffuse + specular) * ao;
}
}
color = color + ambient;
color = color / (color + vec3(1.0)); // HDR tonemapping
color = pow(color, vec3(1.0/2.2)); // gamma correct
color = color / (color + vec3(1.0)); // HDR tonemapping
color = pow(color, vec3(1.0/2.2)); // gamma correct
FragColor = vec4(color, 1.0);
FragColor = vec4(color, 1.0);
}
float shadow_factor(vec4 frag_pos_light_space)
{
vec3 proj_coords = frag_pos_light_space.xyz / frag_pos_light_space.w;
proj_coords = proj_coords * 0.5 + 0.5;
vec3 proj_coords = frag_pos_light_space.xyz / frag_pos_light_space.w;
proj_coords = proj_coords * 0.5 + 0.5;
float closest_depth = texture(shadow_map, proj_coords.xy).r;
float current_depth = proj_coords.z;
float closest_depth = texture(shadow_map, proj_coords.xy).r;
float current_depth = proj_coords.z;
float bias = 0.005;
float shadow = 0;
vec2 delta = 1.0 / textureSize(shadow_map, 0);
for (int i = -1; i < 2; i++)
for (int j = -1; j < 2; j++) {
float closest_depth = texture(shadow_map, proj_coords.xy + vec2(i, j) * delta).r;
shadow += (current_depth - bias > closest_depth) ? 1.0 : 0.0;
}
shadow /= 9;
return shadow;
float bias = 0.005;
float shadow = 0;
vec2 delta = 1.0 / textureSize(shadow_map, 0);
for (int i = -1; i < 2; i++)
for (int j = -1; j < 2; j++) {
float closest_depth = texture(shadow_map, proj_coords.xy + vec2(i, j) * delta).r;
shadow += (current_depth - bias > closest_depth) ? 1.0 : 0.0;
}
shadow /= 9;
return shadow;
}
assets/shaders/fragment_temp.glsl
-105
View File
@@ -1,105 +0,0 @@
#version 330 core
struct Light {
vec3 direction;
vec3 ambient;
vec3 diffuse;
vec3 specular;
};
out vec4 FragColor;
in vec3 frag_normal;
in vec3 fragPos;
in vec4 frag_pos_light_space;
uniform sampler2D shadow_map;
uniform vec3 viewPos;
uniform float perceptualRoughness; // [0, 1]
uniform float metallic; // [0, 1]
uniform float reflectance; // [0, 1]
uniform vec3 baseColor;
uniform Light light;
float shadow_factor(vec4 frag_pos_light_space)
{
vec3 proj_coords = frag_pos_light_space.xyz / frag_pos_light_space.w;
proj_coords = proj_coords * 0.5 + 0.5;
float closest_depth = texture(shadow_map, proj_coords.xy).r;
float current_depth = proj_coords.z;
float bias = 0.005;
float shadow = 0;
vec2 delta = 1.0 / textureSize(shadow_map, 0);
for (int i = -1; i < 2; i++)
for (int j = -1; j < 2; j++) {
float closest_depth = texture(shadow_map, proj_coords.xy + vec2(i, j) * delta).r;
shadow += (current_depth - bias > closest_depth) ? 1.0 : 0.0;
}
shadow /= 9;
return shadow;
}
float D_GGX(float NoH, float a) {
float a2 = a * a;
float f = (NoH * a2 - NoH) * NoH + 1.0;
return a2 / (PI * f * f);
}
vec3 F_Schlick(float u, vec3 f0) {
return f0 + (vec3(1.0) - f0) * pow(1.0 - u, 5.0);
}
float V_SmithGGXCorrelated(float NoV, float NoL, float a) {
float a2 = a * a;
float GGXL = NoV * sqrt((-NoL * a2 + NoL) * NoL + a2);
float GGXV = NoL * sqrt((-NoV * a2 + NoV) * NoV + a2);
return 0.5 / (GGXV + GGXL);
}
float Fd_Lambert() {
return 1.0 / PI;
}
void main()
{
// NOTE: frag_normal is normalized by the vertex shader
/*
vec3 l = normalize(light.direction);
vec3 v = viewDir;
vec3 n = frag_normal;
vec3 h = normalize(v + l);
vec3 diffuseColor = (1.0 - metallic) * baseColor.rgb;
vec3 f0 = 0.16 * reflectance * reflectance * (1.0 - metallic) + baseColor * metallic;
float NoV = abs(dot(n, v)) + 1e-5;
float NoL = clamp(dot(n, l), 0.0, 1.0);
float NoH = clamp(dot(n, h), 0.0, 1.0);
float LoH = clamp(dot(l, h), 0.0, 1.0);
float roughness = perceptualRoughness * perceptualRoughness;
float D = D_GGX(NoH, roughness);
vec3 F = F_Schlick(LoH, f0);
float V = V_SmithGGXCorrelated(NoV, NoL, roughness);
// specular BRDF
vec3 Fr = (D * V) * F;
//vec3 energyCompensation = 1.0 + f0 * (1.0 / dfg.y - 1.0);
//// Scale the specular lobe to account for multiscattering
//Fr *= pixel.energyCompensation;
// diffuse BRDF
vec3 Fd = diffuseColor * Fd_Lambert();
// apply lighting...
float shadow = shadow_factor(frag_pos_light_space);
*/
vec3 result = vec3(1, 0, 0); // Fd + Fr * (1 - shadow);
FragColor = vec4(result, 1.0);
}
assets/shaders/fragment_temp_2.glsl
-113
View File
@@ -1,113 +0,0 @@
#version 330 core
// https://github.com/Nadrin/PBR/blob/master/data/shaders/glsl/pbr_fs.glsl
#define PI 3.1415926538
out vec4 FragColor;
in vec3 frag_normal;
in vec3 fragPos;
in vec4 frag_pos_light_space;
uniform sampler2D shadow_map;
uniform vec3 viewPos;
uniform float perceptualRoughness; // [0, 1]
uniform float metallic; // [0, 1]
uniform float reflectance; // [0, 1]
uniform vec3 baseColor;
uniform vec3 lightDir;
uniform vec3 lightColor;
float shadow_factor(vec4 frag_pos_light_space);
float D_GGX(float NoH, float a) {
float a2 = a * a;
float f = (NoH * a2 - NoH) * NoH + 1.0;
return a2 / (PI * f * f);
}
vec3 F_Schlick(float u, vec3 f0) {
return f0 + (vec3(1.0) - f0) * pow(1.0 - u, 5.0);
}
float V_SmithGGXCorrelated(float NoV, float NoL, float a) {
float a2 = a * a;
float GGXL = NoV * sqrt((-NoL * a2 + NoL) * NoL + a2);
float GGXV = NoL * sqrt((-NoV * a2 + NoV) * NoV + a2);
return 0.5 / (GGXV + GGXL);
}
float Fd_Lambert()
{
return 1.0 / PI;
}
void main()
{
vec3 l = normalize(lightDir);
vec3 v = normalize(viewPos - fragPos);
vec3 n = frag_normal;
vec3 h = normalize(v + l);
float light_intensity = 1;
vec3 albedo = baseColor;
vec3 diffuseColor = (1.0 - metallic) * baseColor;
vec3 f0 = 0.16 * reflectance * reflectance * (1.0 - metallic)
+ baseColor * metallic;
float NoV = abs(dot(n, v)) + 1e-5;
float NoL = clamp(dot(n, l), 0.0, 1.0);
float NoH = clamp(dot(n, h), 0.0, 1.0);
float LoH = clamp(dot(l, h), 0.0, 1.0);
float roughness = perceptualRoughness * perceptualRoughness;
float D = D_GGX(NoH, roughness);
vec3 F = F_Schlick(LoH, f0);
float V = V_SmithGGXCorrelated(NoV, NoL, roughness);
// specular BRDF
float denominator = 4.0 * max(dot(n, v), 0.0) * max(dot(n, l), 0.0) + 0.0001; // + 0.0001 to prevent divide by zero
vec3 Fr = (D * V) * F / denominator;
vec3 radiance = lightColor;
vec3 light = ((vec3(1.0) - F) * (1.0 - metallic) * albedo / PI + Fr) * radiance * NoL;
float shadow = shadow_factor(frag_pos_light_space);
vec3 ambient = vec3(0.03) * albedo;
vec3 color = (ambient + light) * (1 - shadow);
/*
// HDR tonemapping
color = color / (color + vec3(1.0));
// gamma correct
color = pow(color, vec3(1.0/2.2));
*/
FragColor = vec4(color, 1.0);
}
float shadow_factor(vec4 frag_pos_light_space)
{
vec3 proj_coords = frag_pos_light_space.xyz / frag_pos_light_space.w;
proj_coords = proj_coords * 0.5 + 0.5;
float closest_depth = texture(shadow_map, proj_coords.xy).r;
float current_depth = proj_coords.z;
float bias = 0.005;
float shadow = 0;
vec2 delta = 1.0 / textureSize(shadow_map, 0);
for (int i = -1; i < 2; i++)
for (int j = -1; j < 2; j++) {
float closest_depth = texture(shadow_map, proj_coords.xy + vec2(i, j) * delta).r;
shadow += (current_depth - bias > closest_depth) ? 1.0 : 0.0;
}
shadow /= 9;
return shadow;
}
assets/shaders/irradiance_convolution_fragment.glsl
+26 -26
View File
@@ -9,35 +9,35 @@ const float PI = 3.14159265359;
void main()
{
// The world vector acts as the normal of a tangent surface
// from the origin, aligned to WorldPos. Given this normal, calculate all
// incoming radiance of the environment. The result of this radiance
// is the radiance of light coming from -Normal direction, which is what
// we use in the PBR shader to sample irradiance.
vec3 N = normalize(WorldPos);
// from the origin, aligned to WorldPos. Given this normal, calculate all
// incoming radiance of the environment. The result of this radiance
// is the radiance of light coming from -Normal direction, which is what
// we use in the PBR shader to sample irradiance.
vec3 N = normalize(WorldPos);
vec3 irradiance = vec3(0.0);
vec3 irradiance = vec3(0.0);
// tangent space calculation from origin point
vec3 up = vec3(0.0, 1.0, 0.0);
vec3 right = normalize(cross(up, N));
up = normalize(cross(N, right));
// tangent space calculation from origin point
vec3 up = vec3(0.0, 1.0, 0.0);
vec3 right = normalize(cross(up, N));
up = normalize(cross(N, right));
float sampleDelta = 0.025;
float nrSamples = 0.0;
for(float phi = 0.0; phi < 2.0 * PI; phi += sampleDelta)
{
for(float theta = 0.0; theta < 0.5 * PI; theta += sampleDelta)
{
// spherical to cartesian (in tangent space)
vec3 tangentSample = vec3(sin(theta) * cos(phi), sin(theta) * sin(phi), cos(theta));
// tangent space to world
vec3 sampleVec = tangentSample.x * right + tangentSample.y * up + tangentSample.z * N;
float sampleDelta = 0.025;
float nrSamples = 0.0;
for(float phi = 0.0; phi < 2.0 * PI; phi += sampleDelta)
{
for(float theta = 0.0; theta < 0.5 * PI; theta += sampleDelta)
{
// spherical to cartesian (in tangent space)
vec3 tangentSample = vec3(sin(theta) * cos(phi), sin(theta) * sin(phi), cos(theta));
// tangent space to world
vec3 sampleVec = tangentSample.x * right + tangentSample.y * up + tangentSample.z * N;
irradiance += texture(environmentMap, sampleVec).rgb * cos(theta) * sin(theta);
nrSamples++;
}
}
irradiance = PI * irradiance * (1.0 / float(nrSamples));
irradiance += texture(environmentMap, sampleVec).rgb * cos(theta) * sin(theta);
nrSamples++;
}
}
irradiance = PI * irradiance * (1.0 / float(nrSamples));
FragColor = vec4(irradiance, 1.0);
FragColor = vec4(irradiance, 1.0);
}
assets/shaders/prefilter_fragment.glsl
+50 -50
View File
@@ -6,38 +6,38 @@ uniform samplerCube environmentMap;
uniform float roughness;
const float PI = 3.14159265359;
// ----------------------------------------------------------------------------
float DistributionGGX(vec3 N, vec3 H, float roughness)
{
float a = roughness*roughness;
float a2 = a*a;
float NdotH = max(dot(N, H), 0.0);
float NdotH2 = NdotH*NdotH;
float a = roughness*roughness;
float a2 = a*a;
float NdotH = max(dot(N, H), 0.0);
float NdotH2 = NdotH*NdotH;
float nom = a2;
float denom = (NdotH2 * (a2 - 1.0) + 1.0);
denom = PI * denom * denom;
float nom = a2;
float denom = (NdotH2 * (a2 - 1.0) + 1.0);
denom = PI * denom * denom;
return nom / denom;
return nom / denom;
}
// ----------------------------------------------------------------------------
// http://holger.dammertz.org/stuff/notes_HammersleyOnHemisphere.html
// efficient VanDerCorpus calculation.
float RadicalInverse_VdC(uint bits)
{
bits = (bits << 16u) | (bits >> 16u);
bits = ((bits & 0x55555555u) << 1u) | ((bits & 0xAAAAAAAAu) >> 1u);
bits = ((bits & 0x33333333u) << 2u) | ((bits & 0xCCCCCCCCu) >> 2u);
bits = ((bits & 0x0F0F0F0Fu) << 4u) | ((bits & 0xF0F0F0F0u) >> 4u);
bits = ((bits & 0x00FF00FFu) << 8u) | ((bits & 0xFF00FF00u) >> 8u);
return float(bits) * 2.3283064365386963e-10; // / 0x100000000
bits = (bits << 16u) | (bits >> 16u);
bits = ((bits & 0x55555555u) << 1u) | ((bits & 0xAAAAAAAAu) >> 1u);
bits = ((bits & 0x33333333u) << 2u) | ((bits & 0xCCCCCCCCu) >> 2u);
bits = ((bits & 0x0F0F0F0Fu) << 4u) | ((bits & 0xF0F0F0F0u) >> 4u);
bits = ((bits & 0x00FF00FFu) << 8u) | ((bits & 0xFF00FF00u) >> 8u);
return float(bits) * 2.3283064365386963e-10; // / 0x100000000
}
// ----------------------------------------------------------------------------
vec2 Hammersley(uint i, uint N)
{
return vec2(float(i)/float(N), RadicalInverse_VdC(i));
}
// ----------------------------------------------------------------------------
vec3 ImportanceSampleGGX(vec2 Xi, vec3 N, float roughness)
{
float a = roughness*roughness;
@@ -60,47 +60,47 @@ vec3 ImportanceSampleGGX(vec2 Xi, vec3 N, float roughness)
vec3 sampleVec = tangent * H.x + bitangent * H.y + N * H.z;
return normalize(sampleVec);
}
// ----------------------------------------------------------------------------
void main()
{
vec3 N = normalize(WorldPos);
vec3 N = normalize(WorldPos);
// make the simplifying assumption that V equals R equals the normal
vec3 R = N;
vec3 V = R;
// make the simplifying assumption that V equals R equals the normal
vec3 R = N;
vec3 V = R;
const uint SAMPLE_COUNT = 1024u;
vec3 prefilteredColor = vec3(0.0);
float totalWeight = 0.0;
const uint SAMPLE_COUNT = 1024u;
vec3 prefilteredColor = vec3(0.0);
float totalWeight = 0.0;
for(uint i = 0u; i < SAMPLE_COUNT; ++i)
{
// generates a sample vector that's biased towards the preferred alignment direction (importance sampling).
vec2 Xi = Hammersley(i, SAMPLE_COUNT);
vec3 H = ImportanceSampleGGX(Xi, N, roughness);
vec3 L = normalize(2.0 * dot(V, H) * H - V);
for(uint i = 0u; i < SAMPLE_COUNT; ++i)
{
// generates a sample vector that's biased towards the preferred alignment direction (importance sampling).
vec2 Xi = Hammersley(i, SAMPLE_COUNT);
vec3 H = ImportanceSampleGGX(Xi, N, roughness);
vec3 L = normalize(2.0 * dot(V, H) * H - V);
float NdotL = max(dot(N, L), 0.0);
if(NdotL > 0.0)
{
// sample from the environment's mip level based on roughness/pdf
float D = DistributionGGX(N, H, roughness);
float NdotH = max(dot(N, H), 0.0);
float HdotV = max(dot(H, V), 0.0);
float pdf = D * NdotH / (4.0 * HdotV) + 0.0001;
float NdotL = max(dot(N, L), 0.0);
if(NdotL > 0.0)
{
// sample from the environment's mip level based on roughness/pdf
float D = DistributionGGX(N, H, roughness);
float NdotH = max(dot(N, H), 0.0);
float HdotV = max(dot(H, V), 0.0);
float pdf = D * NdotH / (4.0 * HdotV) + 0.0001;
float resolution = 512.0; // resolution of source cubemap (per face)
float saTexel = 4.0 * PI / (6.0 * resolution * resolution);
float saSample = 1.0 / (float(SAMPLE_COUNT) * pdf + 0.0001);
float resolution = 512.0; // resolution of source cubemap (per face)
float saTexel = 4.0 * PI / (6.0 * resolution * resolution);
float saSample = 1.0 / (float(SAMPLE_COUNT) * pdf + 0.0001);
float mipLevel = roughness == 0.0 ? 0.0 : 0.5 * log2(saSample / saTexel);
float mipLevel = roughness == 0.0 ? 0.0 : 0.5 * log2(saSample / saTexel);
prefilteredColor += textureLod(environmentMap, L, mipLevel).rgb * NdotL;
totalWeight += NdotL;
}
}
prefilteredColor += textureLod(environmentMap, L, mipLevel).rgb * NdotL;
totalWeight += NdotL;
}
}
prefilteredColor = prefilteredColor / totalWeight;
prefilteredColor = prefilteredColor / totalWeight;
FragColor = vec4(prefilteredColor, 1.0);
FragColor = vec4(prefilteredColor, 1.0);
}
assets/shaders/rect_fragment.glsl
+3 -2
View File
@@ -1,11 +1,12 @@
#version 330 core
out vec4 FragColor;
in vec2 TexCoords;
in vec2 TexCoords;
uniform sampler2D tex;
void main()
{
vec3 color = texture(tex, TexCoords).rgb;
FragColor = vec4(color, 1.0);
FragColor = vec4(color, 1.0);
}
assets/shaders/shadow_fragment.glsl
+2 -2
View File
@@ -2,6 +2,6 @@
void main()
{
// This is implicit:
// gl_FragDepth = gl_FragCoord.z;
// This is implicit:
// gl_FragDepth = gl_FragCoord.z;
}
assets/shaders/shadow_vertex.glsl
+1 -1
View File
@@ -6,5 +6,5 @@ uniform mat4 model;
void main()
{
gl_Position = light_space_matrix * model * vec4(aPos, 1.0);
gl_Position = light_space_matrix * model * vec4(aPos, 1.0);
}
assets/shaders/vertex.glsl
+5 -4
View File
@@ -1,4 +1,5 @@
#version 330 core
layout (location=0) in vec3 aPos;
layout (location=1) in vec3 aNormal;
layout (location=2) in vec2 aTexCoords;
@@ -17,8 +18,8 @@ out vec4 frag_pos_light_space;
void main()
{
gl_Position = projection * view * model * vec4(aPos, 1.0);
fragPos = vec3(model * vec4(aPos, 1.0));
frag_normal = normalize(mat3(norm) * aNormal);
frag_pos_light_space = light_space_matrix * model * vec4(aPos, 1);
gl_Position = projection * view * model * vec4(aPos, 1.0);
fragPos = vec3(model * vec4(aPos, 1.0));
frag_normal = normalize(mat3(norm) * aNormal);
frag_pos_light_space = light_space_matrix * model * vec4(aPos, 1);
}
src/graphics.c
+342 -315
View File
@@ -13,9 +13,9 @@
#include "graphics.h"
typedef struct {
unsigned int vao;
unsigned int vbo;
int num_vertices;
unsigned int vao;
unsigned int vbo;
int num_vertices;
} GPUMeshBuffer;
#define MAX_MESH_BUFFERS 128
@@ -34,9 +34,7 @@ static unsigned int irradianceMap;
static unsigned int prefilterMap;
static unsigned int brdfLUTTexture;
/*
* Shader program handles
*/
// Shader program handles
static unsigned int background_program;
static unsigned int shader_program;
static unsigned int shadow_program;
@@ -45,70 +43,69 @@ static unsigned int skybox_program;
static GLFWwindow *window_;
static unsigned int
compile_shader(const char *vertex_file,
const char *fragment_file)
compile_shader(const char *vertex_file, const char *fragment_file)
{
int success;
char infolog[512];
int success;
char infolog[512];
char *vertex_str = load_file(vertex_file, NULL);
if (vertex_str == NULL) {
fprintf(stderr, "Couldn't load file '%s'\n", vertex_file);
return 0;
}
char *vertex_str = load_file(vertex_file, NULL);
if (vertex_str == NULL) {
fprintf(stderr, "Couldn't load file '%s'\n", vertex_file);
return 0;
}
char *fragment_str = load_file(fragment_file, NULL);
if (fragment_str == NULL) {
fprintf(stderr, "Couldn't load file '%s'\n", fragment_file);
free(vertex_str);
return 0;
}
char *fragment_str = load_file(fragment_file, NULL);
if (fragment_str == NULL) {
fprintf(stderr, "Couldn't load file '%s'\n", fragment_file);
free(vertex_str);
return 0;
}
unsigned int vertex_shader = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(vertex_shader, 1, &vertex_str, NULL);
glCompileShader(vertex_shader);
unsigned int vertex_shader = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(vertex_shader, 1, &vertex_str, NULL);
glCompileShader(vertex_shader);
glGetShaderiv(vertex_shader, GL_COMPILE_STATUS, &success);
if(!success) {
glGetShaderInfoLog(vertex_shader, sizeof(infolog), NULL, infolog);
fprintf(stderr, "Couldn't compile vertex shader '%s' (%s)\n", vertex_file, infolog);
free(vertex_str);
free(fragment_str);
return 0;
}
glGetShaderiv(vertex_shader, GL_COMPILE_STATUS, &success);
if(!success) {
glGetShaderInfoLog(vertex_shader, sizeof(infolog), NULL, infolog);
fprintf(stderr, "Couldn't compile vertex shader '%s' (%s)\n", vertex_file, infolog);
free(vertex_str);
free(fragment_str);
return 0;
}
unsigned int fragment_shader = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(fragment_shader, 1, &fragment_str, NULL);
glCompileShader(fragment_shader);
unsigned int fragment_shader = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(fragment_shader, 1, &fragment_str, NULL);
glCompileShader(fragment_shader);
glGetShaderiv(fragment_shader, GL_COMPILE_STATUS, &success);
if(!success) {
glGetShaderInfoLog(fragment_shader, sizeof(infolog), NULL, infolog);
fprintf(stderr, "Couldn't compile fragment shader '%s' (%s)\n", fragment_file, infolog);
free(vertex_str);
free(fragment_str);
return 0;
}
glGetShaderiv(fragment_shader, GL_COMPILE_STATUS, &success);
if(!success) {
glGetShaderInfoLog(fragment_shader, sizeof(infolog), NULL, infolog);
fprintf(stderr, "Couldn't compile fragment shader '%s' (%s)\n", fragment_file, infolog);
free(vertex_str);
free(fragment_str);
return 0;
}
unsigned int shader_program = glCreateProgram();
glAttachShader(shader_program, vertex_shader);
glAttachShader(shader_program, fragment_shader);
glLinkProgram(shader_program);
unsigned int shader_program = glCreateProgram();
glAttachShader(shader_program, vertex_shader);
glAttachShader(shader_program, fragment_shader);
glLinkProgram(shader_program);
glGetProgramiv(shader_program, GL_LINK_STATUS, &success);
if(!success) {
glGetProgramInfoLog(shader_program, sizeof(infolog), NULL, infolog);
fprintf(stderr, "Couldn't link shader program (%s)\n", infolog);
free(vertex_str);
free(fragment_str);
return 0;
}
glGetProgramiv(shader_program, GL_LINK_STATUS, &success);
if(!success) {
glGetProgramInfoLog(shader_program, sizeof(infolog), NULL, infolog);
fprintf(stderr, "Couldn't link shader program (%s)\n", infolog);
free(vertex_str);
free(fragment_str);
return 0;
}
glDeleteShader(vertex_shader);
glDeleteShader(fragment_shader);
free(vertex_str);
free(fragment_str);
return shader_program;
glDeleteShader(vertex_shader);
glDeleteShader(fragment_shader);
free(vertex_str);
free(fragment_str);
return shader_program;
}
static void set_uniform_m4(unsigned int program, const char *name, Matrix4 value)
@@ -153,31 +150,31 @@ static void set_uniform_f(unsigned int program, const char *name, float value)
static GPUMeshBuffer create_gpu_mesh_buffer(VertexArray vertices)
{
GPUMeshBuffer buffer;
GPUMeshBuffer buffer;
glGenVertexArrays(1, &buffer.vao);
glGenBuffers(1, &buffer.vbo);
glGenVertexArrays(1, &buffer.vao);
glGenBuffers(1, &buffer.vbo);
glBindVertexArray(buffer.vao);
glBindVertexArray(buffer.vao);
glBindBuffer(GL_ARRAY_BUFFER, buffer.vbo);
glBufferData(GL_ARRAY_BUFFER, sizeof(Vertex) * vertices.size, vertices.data, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, buffer.vbo);
glBufferData(GL_ARRAY_BUFFER, sizeof(Vertex) * vertices.size, vertices.data, GL_STATIC_DRAW);
// positions
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)0);
glEnableVertexAttribArray(0);
// positions
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)0);
glEnableVertexAttribArray(0);
// normals
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*) (offsetof(Vertex, nx)));
glEnableVertexAttribArray(1);
// normals
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*) (offsetof(Vertex, nx)));
glEnableVertexAttribArray(1);
// texture coordinates
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*) (offsetof(Vertex, tx)));
glEnableVertexAttribArray(2);
// texture coordinates
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*) (offsetof(Vertex, tx)));
glEnableVertexAttribArray(2);
buffer.num_vertices = vertices.size;
buffer.num_vertices = vertices.size;
return buffer;
return buffer;
}
ModelID load_3d_model(const char *file)
@@ -209,26 +206,26 @@ void free_3d_model(ModelID id)
static void draw_mesh_for_shadow_map(GPUMeshBuffer buffer, Matrix4 model)
{
glUseProgram(shadow_program);
glUseProgram(shadow_program);
set_uniform_m4(shadow_program, "model", model);
glBindVertexArray(buffer.vao);
glDrawArrays(GL_TRIANGLES, 0, buffer.num_vertices);
glDrawArrays(GL_TRIANGLES, 0, buffer.num_vertices);
}
static void draw_mesh(GPUMeshBuffer buffer, Matrix4 model, Material material)
{
Matrix4 temp;
assert(invert(model, &temp));
Matrix4 normal = transpose(temp);
Matrix4 normal = transpose(temp);
glUseProgram(shader_program);
glUseProgram(shader_program);
set_uniform_f(shader_program, "perceptualRoughness", material.perceptualRoughness);
set_uniform_f(shader_program, "metallic", material.metallic);
set_uniform_f(shader_program, "reflectance", material.reflectance);
set_uniform_v3(shader_program, "baseColor", material.baseColor);
set_uniform_f(shader_program, "perceptualRoughness", material.perceptualRoughness);
set_uniform_f(shader_program, "metallic", material.metallic);
set_uniform_f(shader_program, "reflectance", material.reflectance);
set_uniform_v3(shader_program, "baseColor", material.baseColor);
set_uniform_m4(shader_program, "model", model);
set_uniform_m4(shader_program, "norm", normal);
set_uniform_m4(shader_program, "norm", normal);
glBindVertexArray(buffer.vao);
glDrawArrays(GL_TRIANGLES, 0, buffer.num_vertices);
@@ -238,73 +235,82 @@ unsigned int cubeVAO = 0;
unsigned int cubeVBO = 0;
void renderCube()
{
// initialize (if necessary)
if (cubeVAO == 0)
{
float vertices[] = {
// back face
-1.0f, -1.0f, -1.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f, // bottom-left
1.0f, 1.0f, -1.0f, 0.0f, 0.0f, -1.0f, 1.0f, 1.0f, // top-right
1.0f, -1.0f, -1.0f, 0.0f, 0.0f, -1.0f, 1.0f, 0.0f, // bottom-right
1.0f, 1.0f, -1.0f, 0.0f, 0.0f, -1.0f, 1.0f, 1.0f, // top-right
-1.0f, -1.0f, -1.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f, // bottom-left
-1.0f, 1.0f, -1.0f, 0.0f, 0.0f, -1.0f, 0.0f, 1.0f, // top-left
// front face
-1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, // bottom-left
1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, // bottom-right
1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, // top-right
1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, // top-right
-1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, // top-left
-1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, // bottom-left
// left face
-1.0f, 1.0f, 1.0f, -1.0f, 0.0f, 0.0f, 1.0f, 0.0f, // top-right
-1.0f, 1.0f, -1.0f, -1.0f, 0.0f, 0.0f, 1.0f, 1.0f, // top-left
-1.0f, -1.0f, -1.0f, -1.0f, 0.0f, 0.0f, 0.0f, 1.0f, // bottom-left
-1.0f, -1.0f, -1.0f, -1.0f, 0.0f, 0.0f, 0.0f, 1.0f, // bottom-left
-1.0f, -1.0f, 1.0f, -1.0f, 0.0f, 0.0f, 0.0f, 0.0f, // bottom-right
-1.0f, 1.0f, 1.0f, -1.0f, 0.0f, 0.0f, 1.0f, 0.0f, // top-right
// right face
1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, // top-left
1.0f, -1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, // bottom-right
1.0f, 1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, // top-right
1.0f, -1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, // bottom-right
1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, // top-left
1.0f, -1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, // bottom-left
// bottom face
-1.0f, -1.0f, -1.0f, 0.0f, -1.0f, 0.0f, 0.0f, 1.0f, // top-right
1.0f, -1.0f, -1.0f, 0.0f, -1.0f, 0.0f, 1.0f, 1.0f, // top-left
1.0f, -1.0f, 1.0f, 0.0f, -1.0f, 0.0f, 1.0f, 0.0f, // bottom-left
1.0f, -1.0f, 1.0f, 0.0f, -1.0f, 0.0f, 1.0f, 0.0f, // bottom-left
-1.0f, -1.0f, 1.0f, 0.0f, -1.0f, 0.0f, 0.0f, 0.0f, // bottom-right
-1.0f, -1.0f, -1.0f, 0.0f, -1.0f, 0.0f, 0.0f, 1.0f, // top-right
// top face
-1.0f, 1.0f, -1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, // top-left
1.0f, 1.0f , 1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, // bottom-right
1.0f, 1.0f, -1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f, // top-right
1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, // bottom-right
-1.0f, 1.0f, -1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, // top-left
-1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f // bottom-left
};
glGenVertexArrays(1, &cubeVAO);
glGenBuffers(1, &cubeVBO);
// fill buffer
glBindBuffer(GL_ARRAY_BUFFER, cubeVBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
// link vertex attributes
glBindVertexArray(cubeVAO);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)0);
glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)(3 * sizeof(float)));
glEnableVertexAttribArray(2);
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)(6 * sizeof(float)));
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindVertexArray(0);
}
// render Cube
glBindVertexArray(cubeVAO);
glDrawArrays(GL_TRIANGLES, 0, 36);
glBindVertexArray(0);
// initialize (if necessary)
if (cubeVAO == 0) {
float vertices[] = {
// back face
-1.0f, -1.0f, -1.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f, // bottom-left
1.0f, 1.0f, -1.0f, 0.0f, 0.0f, -1.0f, 1.0f, 1.0f, // top-right
1.0f, -1.0f, -1.0f, 0.0f, 0.0f, -1.0f, 1.0f, 0.0f, // bottom-right
1.0f, 1.0f, -1.0f, 0.0f, 0.0f, -1.0f, 1.0f, 1.0f, // top-right
-1.0f, -1.0f, -1.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f, // bottom-left
-1.0f, 1.0f, -1.0f, 0.0f, 0.0f, -1.0f, 0.0f, 1.0f, // top-left
// front face
-1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, // bottom-left
1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, // bottom-right
1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, // top-right
1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, // top-right
-1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, // top-left
-1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, // bottom-left
// left face
-1.0f, 1.0f, 1.0f, -1.0f, 0.0f, 0.0f, 1.0f, 0.0f, // top-right
-1.0f, 1.0f, -1.0f, -1.0f, 0.0f, 0.0f, 1.0f, 1.0f, // top-left
-1.0f, -1.0f, -1.0f, -1.0f, 0.0f, 0.0f, 0.0f, 1.0f, // bottom-left
-1.0f, -1.0f, -1.0f, -1.0f, 0.0f, 0.0f, 0.0f, 1.0f, // bottom-left
-1.0f, -1.0f, 1.0f, -1.0f, 0.0f, 0.0f, 0.0f, 0.0f, // bottom-right
-1.0f, 1.0f, 1.0f, -1.0f, 0.0f, 0.0f, 1.0f, 0.0f, // top-right
// right face
1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, // top-left
1.0f, -1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, // bottom-right
1.0f, 1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, // top-right
1.0f, -1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, // bottom-right
1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, // top-left
1.0f, -1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, // bottom-left
// bottom face
-1.0f, -1.0f, -1.0f, 0.0f, -1.0f, 0.0f, 0.0f, 1.0f, // top-right
1.0f, -1.0f, -1.0f, 0.0f, -1.0f, 0.0f, 1.0f, 1.0f, // top-left
1.0f, -1.0f, 1.0f, 0.0f, -1.0f, 0.0f, 1.0f, 0.0f, // bottom-left
1.0f, -1.0f, 1.0f, 0.0f, -1.0f, 0.0f, 1.0f, 0.0f, // bottom-left
-1.0f, -1.0f, 1.0f, 0.0f, -1.0f, 0.0f, 0.0f, 0.0f, // bottom-right
-1.0f, -1.0f, -1.0f, 0.0f, -1.0f, 0.0f, 0.0f, 1.0f, // top-right
// top face
-1.0f, 1.0f, -1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, // top-left
1.0f, 1.0f , 1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, // bottom-right
1.0f, 1.0f, -1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f, // top-right
1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, // bottom-right
-1.0f, 1.0f, -1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, // top-left
-1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f // bottom-left
};
glGenVertexArrays(1, &cubeVAO);
glGenBuffers(1, &cubeVBO);
// fill buffer
glBindBuffer(GL_ARRAY_BUFFER, cubeVBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
// link vertex attributes
glBindVertexArray(cubeVAO);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)0);
glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)(3 * sizeof(float)));
glEnableVertexAttribArray(2);
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)(6 * sizeof(float)));
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindVertexArray(0);
}
// render Cube
glBindVertexArray(cubeVAO);
glDrawArrays(GL_TRIANGLES, 0, 36);
glBindVertexArray(0);
}
// renderQuad() renders a 1x1 XY quad in NDC
@@ -313,195 +319,220 @@ unsigned int quadVAO = 0;
unsigned int quadVBO;
void renderQuad()
{
if (quadVAO == 0)
{
float quadVertices[] = {
// positions // texture Coords
-1.0f, 1.0f, 0.0f, 0.0f, 1.0f,
-1.0f, -1.0f, 0.0f, 0.0f, 0.0f,
1.0f, 1.0f, 0.0f, 1.0f, 1.0f,
1.0f, -1.0f, 0.0f, 1.0f, 0.0f,
};
// setup plane VAO
glGenVertexArrays(1, &quadVAO);
glGenBuffers(1, &quadVBO);
glBindVertexArray(quadVAO);
glBindBuffer(GL_ARRAY_BUFFER, quadVBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(quadVertices), &quadVertices, GL_STATIC_DRAW);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)0);
glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)(3 * sizeof(float)));
}
glBindVertexArray(quadVAO);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
glBindVertexArray(0);
if (quadVAO == 0) {
float quadVertices[] = {
// positions // texture Coords
-1.0f, 1.0f, 0.0f, 0.0f, 1.0f,
-1.0f, -1.0f, 0.0f, 0.0f, 0.0f,
1.0f, 1.0f, 0.0f, 1.0f, 1.0f,
1.0f, -1.0f, 0.0f, 1.0f, 0.0f,
};
// setup plane VAO
glGenVertexArrays(1, &quadVAO);
glGenBuffers(1, &quadVBO);
glBindVertexArray(quadVAO);
glBindBuffer(GL_ARRAY_BUFFER, quadVBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(quadVertices), &quadVertices, GL_STATIC_DRAW);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)0);
glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)(3 * sizeof(float)));
}
glBindVertexArray(quadVAO);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
glBindVertexArray(0);
}
void init_graphics(void *window)
{
window_ = window;
shader_program = compile_shader("assets/shaders/vertex.glsl", "assets/shaders/fragment.glsl");
shadow_program = compile_shader("assets/shaders/shadow_vertex.glsl", "assets/shaders/shadow_fragment.glsl");
// Compile the main shaders
shader_program = compile_shader(
"assets/shaders/vertex.glsl",
"assets/shaders/fragment.glsl");
unsigned int equirectangular_to_cubemap_program = compile_shader("assets/shaders/cubemap_vertex.glsl", "assets/shaders/equirectangular_to_cubemap_fragment.glsl");
unsigned int irradiance_convolution_program = compile_shader("assets/shaders/cubemap_vertex.glsl", "assets/shaders/irradiance_convolution_fragment.glsl");
background_program = compile_shader("assets/shaders/background_vertex.glsl", "assets/shaders/background_fragment.glsl");
// The program which calculates the shadow map
shadow_program = compile_shader(
"assets/shaders/shadow_vertex.glsl",
"assets/shaders/shadow_fragment.glsl");
{
VertexArray vertices = make_sphere_mesh(0.5);
mesh_buffers[MODEL_SPHERE-1] = create_gpu_mesh_buffer(vertices);
// Program to compute a cubemap from an image (only necessary at startup)
unsigned int equirectangular_to_cubemap_program = compile_shader(
"assets/shaders/cubemap_vertex.glsl",
"assets/shaders/equirectangular_to_cubemap_fragment.glsl");
// Apply a low pass filter on the cubemap based on the roughness
// parameter (only necessary at startup)
unsigned int irradiance_convolution_program = compile_shader(
"assets/shaders/cubemap_vertex.glsl",
"assets/shaders/irradiance_convolution_fragment.glsl");
// Render the high resolution cubemap
background_program = compile_shader(
"assets/shaders/background_vertex.glsl",
"assets/shaders/background_fragment.glsl");
// Load the sphere mesh from memory
{
VertexArray vertices = make_sphere_mesh(0.5);
mesh_buffers[MODEL_SPHERE-1] = create_gpu_mesh_buffer(vertices);
free(vertices.data);
}
}
// Load the cube mesh from memory
{
VertexArray vertices = make_cube_mesh();
mesh_buffers[MODEL_CUBE-1] = create_gpu_mesh_buffer(vertices);
free(vertices.data);
}
{
VertexArray vertices = make_cube_mesh();
mesh_buffers[MODEL_CUBE-1] = create_gpu_mesh_buffer(vertices);
free(vertices.data);
}
glGenFramebuffers(1, &captureFBO);
glGenRenderbuffers(1, &captureRBO);
{
glGenFramebuffers(1, &captureFBO);
glGenRenderbuffers(1, &captureRBO);
glBindFramebuffer(GL_FRAMEBUFFER, captureFBO);
glBindRenderbuffer(GL_RENDERBUFFER, captureRBO);
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT24, 512, 512);
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, captureRBO);
}
glBindFramebuffer(GL_FRAMEBUFFER, captureFBO);
glBindRenderbuffer(GL_RENDERBUFFER, captureRBO);
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT24, 512, 512);
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, captureRBO);
}
{
stbi_set_flip_vertically_on_load(true);
int width, height, nrComponents;
float *data = stbi_loadf("assets/spruit_sunrise_4k.hdr", &width, &height, &nrComponents, 0);
if (!data) {
fprintf(stderr, "Couldn't load map\n");
abort();
}
{
stbi_set_flip_vertically_on_load(true);
int width, height, nrComponents;
float *data = stbi_loadf("assets/spruit_sunrise_4k.hdr", &width, &height, &nrComponents, 0);
if (!data) {
fprintf(stderr, "Couldn't load map\n");
abort();
}
glGenTextures(1, &hdrTexture);
glBindTexture(GL_TEXTURE_2D, hdrTexture);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB16F, width, height, 0, GL_RGB, GL_FLOAT, data); // note how we specify the texture's data value to be float
glGenTextures(1, &hdrTexture);
glBindTexture(GL_TEXTURE_2D, hdrTexture);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB16F, width, height, 0, GL_RGB, GL_FLOAT, data); // note how we specify the texture's data value to be float
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
stbi_image_free(data);
}
stbi_image_free(data);
}
// Set up projection and view matrices for capturing data onto the 6 cubemap face directions
Matrix4 captureProjection = perspective_matrix(deg2rad(90.0f), 1.0f, 0.1f, 10.0f);
Matrix4 captureViews[] = {
lookat_matrix((Vector3) {0.0f, 0.0f, 0.0f}, (Vector3) {1.0f, 0.0f, 0.0f}, (Vector3) {0.0f, -1.0f, 0.0f}),
lookat_matrix((Vector3) {0.0f, 0.0f, 0.0f}, (Vector3) {-1.0f, 0.0f, 0.0f}, (Vector3) {0.0f, -1.0f, 0.0f}),
lookat_matrix((Vector3) {0.0f, 0.0f, 0.0f}, (Vector3) {0.0f, 1.0f, 0.0f}, (Vector3) {0.0f, 0.0f, 1.0f}),
lookat_matrix((Vector3) {0.0f, 0.0f, 0.0f}, (Vector3) {0.0f, -1.0f, 0.0f}, (Vector3) {0.0f, 0.0f, -1.0f}),
lookat_matrix((Vector3) {0.0f, 0.0f, 0.0f}, (Vector3) {0.0f, 0.0f, 1.0f}, (Vector3) {0.0f, -1.0f, 0.0f}),
lookat_matrix((Vector3) {0.0f, 0.0f, 0.0f}, (Vector3) {0.0f, 0.0f, -1.0f}, (Vector3) {0.0f, -1.0f, 0.0f})
};
{
glGenTextures(1, &envCubemap);
glBindTexture(GL_TEXTURE_CUBE_MAP, envCubemap);
for (unsigned int i = 0; i < 6; ++i)
glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, GL_RGB16F, 512, 512, 0, GL_RGB, GL_FLOAT, NULL);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
// pbr: set up projection and view matrices for capturing data onto the 6 cubemap face directions
// ----------------------------------------------------------------------------------------------
Matrix4 captureProjection = perspective_matrix(deg2rad(90.0f), 1.0f, 0.1f, 10.0f);
Matrix4 captureViews[] = {
lookat_matrix((Vector3) {0.0f, 0.0f, 0.0f}, (Vector3) {1.0f, 0.0f, 0.0f}, (Vector3) {0.0f, -1.0f, 0.0f}),
lookat_matrix((Vector3) {0.0f, 0.0f, 0.0f}, (Vector3) {-1.0f, 0.0f, 0.0f}, (Vector3) {0.0f, -1.0f, 0.0f}),
lookat_matrix((Vector3) {0.0f, 0.0f, 0.0f}, (Vector3) {0.0f, 1.0f, 0.0f}, (Vector3) {0.0f, 0.0f, 1.0f}),
lookat_matrix((Vector3) {0.0f, 0.0f, 0.0f}, (Vector3) {0.0f, -1.0f, 0.0f}, (Vector3) {0.0f, 0.0f, -1.0f}),
lookat_matrix((Vector3) {0.0f, 0.0f, 0.0f}, (Vector3) {0.0f, 0.0f, 1.0f}, (Vector3) {0.0f, -1.0f, 0.0f}),
lookat_matrix((Vector3) {0.0f, 0.0f, 0.0f}, (Vector3) {0.0f, 0.0f, -1.0f}, (Vector3) {0.0f, -1.0f, 0.0f})
};
{
glGenTextures(1, &envCubemap);
glBindTexture(GL_TEXTURE_CUBE_MAP, envCubemap);
for (unsigned int i = 0; i < 6; ++i)
glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, GL_RGB16F, 512, 512, 0, GL_RGB, GL_FLOAT, NULL);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
// pbr: convert HDR equirectangular environment map to cubemap equivalent
// ----------------------------------------------------------------------
glUseProgram(equirectangular_to_cubemap_program);
glUniform1i(glGetUniformLocation(equirectangular_to_cubemap_program, "equirectangularMap"), 0);
glUniformMatrix4fv(glGetUniformLocation(equirectangular_to_cubemap_program, "projection"), 1, false, (float*) &captureProjection);
// pbr: convert HDR equirectangular environment map to cubemap equivalent
// ----------------------------------------------------------------------
glUseProgram(equirectangular_to_cubemap_program);
glUniform1i(glGetUniformLocation(equirectangular_to_cubemap_program, "equirectangularMap"), 0);
glUniformMatrix4fv(glGetUniformLocation(equirectangular_to_cubemap_program, "projection"), 1, false, (float*) &captureProjection);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, hdrTexture);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, hdrTexture);
glViewport(0, 0, 512, 512); // don't forget to configure the viewport to the capture dimensions.
glBindFramebuffer(GL_FRAMEBUFFER, captureFBO);
for (unsigned int i = 0; i < 6; i++) {
glUniformMatrix4fv(glGetUniformLocation(equirectangular_to_cubemap_program, "view"), 1, false, (float*) &captureViews[i]);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, envCubemap, 0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glViewport(0, 0, 512, 512); // don't forget to configure the viewport to the capture dimensions.
glBindFramebuffer(GL_FRAMEBUFFER, captureFBO);
for (unsigned int i = 0; i < 6; ++i) {
glUniformMatrix4fv(glGetUniformLocation(equirectangular_to_cubemap_program, "view"), 1, false, (float*) &captureViews[i]);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, envCubemap, 0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
renderCube();
}
glBindFramebuffer(GL_FRAMEBUFFER, 0);
}
renderCube();
}
glBindFramebuffer(GL_FRAMEBUFFER, 0);
}
{
// pbr: create an irradiance cubemap, and re-scale capture FBO to irradiance scale.
glGenTextures(1, &irradianceMap);
glBindTexture(GL_TEXTURE_CUBE_MAP, irradianceMap);
for (unsigned int i = 0; i < 6; ++i)
glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, GL_RGB16F, 32, 32, 0, GL_RGB, GL_FLOAT, NULL);
{
// pbr: create an irradiance cubemap, and re-scale capture FBO to irradiance scale.
// --------------------------------------------------------------------------------
glGenTextures(1, &irradianceMap);
glBindTexture(GL_TEXTURE_CUBE_MAP, irradianceMap);
for (unsigned int i = 0; i < 6; ++i)
{
glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, GL_RGB16F, 32, 32, 0, GL_RGB, GL_FLOAT, NULL);
}
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glBindFramebuffer(GL_FRAMEBUFFER, captureFBO);
glBindRenderbuffer(GL_RENDERBUFFER, captureRBO);
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT24, 32, 32);
}
glBindFramebuffer(GL_FRAMEBUFFER, captureFBO);
glBindRenderbuffer(GL_RENDERBUFFER, captureRBO);
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT24, 32, 32);
}
{
glUseProgram(irradiance_convolution_program);
glUniform1i(glGetUniformLocation(irradiance_convolution_program, "environmentMap"), 0);
glUniformMatrix4fv(glGetUniformLocation(irradiance_convolution_program, "projection"), 1, GL_FALSE, (float*) &captureProjection);
{
glUseProgram(irradiance_convolution_program);
glUniform1i(glGetUniformLocation(irradiance_convolution_program, "environmentMap"), 0);
glUniformMatrix4fv(glGetUniformLocation(irradiance_convolution_program, "projection"), 1, GL_FALSE, (float*) &captureProjection);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_CUBE_MAP, envCubemap);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_CUBE_MAP, envCubemap);
glViewport(0, 0, 32, 32); // don't forget to configure the viewport to the capture dimensions.
glBindFramebuffer(GL_FRAMEBUFFER, captureFBO);
for (unsigned int i = 0; i < 6; ++i)
{
glUniformMatrix4fv(glGetUniformLocation(irradiance_convolution_program, "view"), 1, GL_FALSE, (float*) &captureViews[i]);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, irradianceMap, 0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glViewport(0, 0, 32, 32); // don't forget to configure the viewport to the capture dimensions.
glBindFramebuffer(GL_FRAMEBUFFER, captureFBO);
for (unsigned int i = 0; i < 6; ++i)
{
glUniformMatrix4fv(glGetUniformLocation(irradiance_convolution_program, "view"), 1, GL_FALSE, (float*) &captureViews[i]);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, irradianceMap, 0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
renderCube();
}
glBindFramebuffer(GL_FRAMEBUFFER, 0);
}
renderCube();
}
glBindFramebuffer(GL_FRAMEBUFFER, 0);
}
{
int w, h;
glfwGetWindowSize(window, &w, &h);
{
int w, h;
glfwGetWindowSize(window, &w, &h);
Matrix4 projection = perspective_matrix(deg2rad(30.0f), (float) w / (float) h, 0.1f, 100.0f);
glUseProgram(background_program);
glUniformMatrix4fv(glGetUniformLocation(background_program, "projection"), 1, false, (float*) &projection);
}
Matrix4 projection = perspective_matrix(deg2rad(30.0f), (float) w / (float) h, 0.1f, 100.0f);
glUseProgram(background_program);
glUniformMatrix4fv(glGetUniformLocation(background_program, "projection"), 1, false, (float*) &projection);
}
{
glGenFramebuffers(1, &depth_map_fbo);
{
glGenFramebuffers(1, &depth_map_fbo);
glGenTextures(1, &depth_map);
glBindTexture(GL_TEXTURE_2D, depth_map);
glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, SHADOW_WIDTH, SHADOW_HEIGHT, 0, GL_DEPTH_COMPONENT, GL_FLOAT, NULL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
glGenTextures(1, &depth_map);
glBindTexture(GL_TEXTURE_2D, depth_map);
glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, SHADOW_WIDTH, SHADOW_HEIGHT, 0, GL_DEPTH_COMPONENT, GL_FLOAT, NULL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
glBindFramebuffer(GL_FRAMEBUFFER, depth_map_fbo);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, depth_map, 0);
glDrawBuffer(GL_NONE);
glReadBuffer(GL_NONE);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
}
glBindFramebuffer(GL_FRAMEBUFFER, depth_map_fbo);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, depth_map, 0);
glDrawBuffer(GL_NONE);
glReadBuffer(GL_NONE);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
}
{
glGenTextures(1, &prefilterMap);
@@ -586,14 +617,10 @@ void init_graphics(void *window)
unsigned int rect_program = compile_shader("assets/shaders/brdf_vertex.glsl", "assets/shaders/rect_fragment.glsl");
unsigned int depth_render_buffer;
unsigned int depth_render_buffer;
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
//glEnable(GL_DEPTH_TEST);
//glEnable(GL_CULL_FACE);
//glCullFace(GL_BACK);
glDepthFunc(GL_LEQUAL);
}
typedef struct {
src/main.c
+77 -65
View File
@@ -11,23 +11,23 @@
static void error_callback(int error, const char* description)
{
fprintf(stderr, "Error: %s\n", description);
fprintf(stderr, "Error: %s\n", description);
}
static void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods)
{
if (key == GLFW_KEY_ESCAPE && action == GLFW_PRESS)
glfwSetWindowShouldClose(window, GLFW_TRUE);
if (key == GLFW_KEY_ESCAPE && action == GLFW_PRESS)
glfwSetWindowShouldClose(window, GLFW_TRUE);
}
void framebuffer_size_callback(GLFWwindow* window, int width, int height)
{
glViewport(0, 0, width, height);
glViewport(0, 0, width, height);
}
void cursor_pos_callback(GLFWwindow *window, double x, double y)
{
rotate_camera(x, y);
rotate_camera(x, y);
}
typedef enum {
@@ -41,85 +41,85 @@ typedef enum {
} PieceType;
typedef struct {
bool is_black;
PieceType type;
bool is_black;
PieceType type;
} Piece;
typedef struct {
Piece pieces[8][8];
Piece pieces[8][8];
} Board;
void init_board(Board *board)
{
for (int i = 0; i < 8; i++)
for (int j = 0; j < 8; j++) {
board->pieces[i][j] = (Piece) {false, PIECE_VOID};
}
for (int i = 0; i < 8; i++) {
board->pieces[i][1] = (Piece) {true, PIECE_PAWN};
board->pieces[i][6] = (Piece) {false, PIECE_PAWN};
}
for (int i = 0; i < 8; i++)
for (int j = 0; j < 8; j++) {
board->pieces[i][j] = (Piece) {false, PIECE_VOID};
}
for (int i = 0; i < 8; i++) {
board->pieces[i][1] = (Piece) {true, PIECE_PAWN};
board->pieces[i][6] = (Piece) {false, PIECE_PAWN};
}
board->pieces[3][0] = (Piece) {true, PIECE_KING};
board->pieces[3][7] = (Piece) {false, PIECE_KING};
board->pieces[4][0] = (Piece) {true, PIECE_QUEEN};
board->pieces[4][7] = (Piece) {false, PIECE_QUEEN};
board->pieces[3][0] = (Piece) {true, PIECE_KING};
board->pieces[3][7] = (Piece) {false, PIECE_KING};
board->pieces[4][0] = (Piece) {true, PIECE_QUEEN};
board->pieces[4][7] = (Piece) {false, PIECE_QUEEN};
board->pieces[2][7] = (Piece) {false, PIECE_BISHOP};
board->pieces[5][7] = (Piece) {false, PIECE_BISHOP};
board->pieces[2][7] = (Piece) {false, PIECE_BISHOP};
board->pieces[5][7] = (Piece) {false, PIECE_BISHOP};
board->pieces[2][0] = (Piece) {true, PIECE_BISHOP};
board->pieces[5][0] = (Piece) {true, PIECE_BISHOP};
board->pieces[2][0] = (Piece) {true, PIECE_BISHOP};
board->pieces[5][0] = (Piece) {true, PIECE_BISHOP};
board->pieces[1][7] = (Piece) {false, PIECE_KNIGHT};
board->pieces[6][7] = (Piece) {false, PIECE_KNIGHT};
board->pieces[1][7] = (Piece) {false, PIECE_KNIGHT};
board->pieces[6][7] = (Piece) {false, PIECE_KNIGHT};
board->pieces[1][0] = (Piece) {true, PIECE_KNIGHT};
board->pieces[6][0] = (Piece) {true, PIECE_KNIGHT};
board->pieces[1][0] = (Piece) {true, PIECE_KNIGHT};
board->pieces[6][0] = (Piece) {true, PIECE_KNIGHT};
board->pieces[0][0] = (Piece) {true, PIECE_ROOK};
board->pieces[7][0] = (Piece) {true, PIECE_ROOK};
board->pieces[0][0] = (Piece) {true, PIECE_ROOK};
board->pieces[7][0] = (Piece) {true, PIECE_ROOK};
board->pieces[0][7] = (Piece) {false, PIECE_ROOK};
board->pieces[7][7] = (Piece) {false, PIECE_ROOK};
board->pieces[0][7] = (Piece) {false, PIECE_ROOK};
board->pieces[7][7] = (Piece) {false, PIECE_ROOK};
/*
board->pieces[3][4] = {false, PIECE_KING};
board->pieces[4][5] = {false, PIECE_PAWN};
board->pieces[4][6] = {false, PIECE_PAWN};
*/
/*
board->pieces[3][4] = {false, PIECE_KING};
board->pieces[4][5] = {false, PIECE_PAWN};
board->pieces[4][6] = {false, PIECE_PAWN};
*/
}
int main(void)
{
glfwSetErrorCallback(error_callback);
glfwSetErrorCallback(error_callback);
if (!glfwInit())
return -1;
if (!glfwInit())
return -1;
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
GLFWwindow *window = glfwCreateWindow(2*640, 2*480, "3D Chess", NULL, NULL);
if (!window) {
glfwTerminate();
return -1;
}
GLFWwindow *window = glfwCreateWindow(2*640, 2*480, "3D Chess", NULL, NULL);
if (!window) {
glfwTerminate();
return -1;
}
glfwSetKeyCallback(window, key_callback);
glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
glfwSetCursorPosCallback(window, cursor_pos_callback);
glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
glfwSetKeyCallback(window, key_callback);
glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
glfwSetCursorPosCallback(window, cursor_pos_callback);
glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
glfwMakeContextCurrent(window);
glfwMakeContextCurrent(window);
if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) {
printf("Failed to initialize GLAD\n");
return -1;
}
if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) {
printf("Failed to initialize GLAD\n");
return -1;
}
glfwSwapInterval(1);
glfwSwapInterval(1);
init_graphics(window);
@@ -174,12 +174,24 @@ int main(void)
draw_model(piece_models[board.pieces[i][j].type], (Vector3) {cell_w * (i + 0.5), 0, cell_d * (j + 0.5)}, (Vector3) {1, 1, 1}, (Vector3) {0, rotation, 0}, piece_material);
}
update_graphics();
glfwSwapBuffers(window);
glfwPollEvents();
}
{
Material material = {.baseColor={1, 1, 1}, .metallic=1.0, .perceptualRoughness=0, .reflectance=0};
Vector3 pos = {cell_w * (4 + 0.5), 0, cell_d * (4 + 0.5)};
draw_model(piece_models[PIECE_KING], pos, (Vector3) {1, 1, 1}, (Vector3) {0, 0, 0}, material);
}
glfwDestroyWindow(window);
glfwTerminate();
return 0;
{
Material material = {.baseColor={0, 0, 0}, .metallic=1.0, .perceptualRoughness=0, .reflectance=0};
Vector3 pos = {cell_w * (5 + 0.5), 0, cell_d * (4 + 0.5)};
draw_model(piece_models[PIECE_KING], pos, (Vector3) {1, 1, 1}, (Vector3) {0, 0, 0}, material);
}
update_graphics();
glfwSwapBuffers(window);
glfwPollEvents();
}
glfwDestroyWindow(window);
glfwTerminate();
return 0;
}