Merge branch 'pbr'

Author: benjamaan476

assets/materials/roof.emt

@@ -1,10 +1,38 @@
 # roof
 # auto generated material
 version = 0.1
+type=pbr
 name=roof
-diffuse_colour=0.588 0.588 0.588 1.000
-diffuse_map_name=sponza_roof_diff
-specular_map_name=sponza_roof_spec
-normal_map_name=sponza_roof_ddn
-shader=Shader.Material
-shininess=1.500000
+shader=Shader.PBR
+diffuse_colour = 0.5 0 0 1
+
+[map]
+name = albedo
+filter_min = linear
+filter_mag = linear
+repeat_u = repeat
+repeat_v = repeat
+repeat_w = repeat
+texture_name = orange_lines_512
+[/map]
+
+
+[map]
+name = normal
+filter_min = linear
+filter_mag = linear
+repeat_u = repeat
+repeat_v = repeat
+repeat_w = repeat
+texture_name = sponza_roof_ddn
+[/map]
+
+[map]
+name = metallic
+filter_min = linear
+filter_mag = linear
+repeat_u = repeat
+repeat_v = repeat
+repeat_w = repeat
+texture_name = sponza_roof_spec
+[/map]

assets/shaders/PBRShader.frag

@@ -0,0 +1,184 @@
+#version 450
+
+layout(location = 0) out vec4 out_colour;
+
+struct directional_light {
+    vec4 direction;
+    vec4 colour;
+};
+
+const int MAX_POINT_LIGHTS = 10;
+
+struct point_light {
+    vec4 position;
+    vec4 colour;
+    // Usually 1, make sure denominator never gets smaller than 1
+    float constant;
+    // Reduces light intensity linearly
+    float linear;
+    // Makes the light fall off slower at longer distances.
+    float quadratic;
+
+    float pad;
+};
+
+struct pbr_properties {
+    vec4 diffuse;
+    vec3 pad;
+    float shininess;
+};
+
+layout(set = 1, binding = 0) uniform local_uniform_object {
+    directional_light dir_light;
+    point_light point_lights[MAX_POINT_LIGHTS];
+    int num_point_lights;
+    pbr_properties props;
+} object_ubo;
+
+// Samplers, diffuse, spec
+const int SAMP_ALBEDO = 0;
+const int SAMP_NORMAL = 1;
+const int SAMP_METALLIC = 2;
+const int SAMP_ROUGHNESS = 3;
+const int SAMP_AO = 4;
+const int SAMP_IBL = 5;
+
+layout(set = 1, binding = 1) uniform sampler2D samplers[6];
+layout(set = 1, binding = 1) uniform samplerCube samplersCube[6];
+
+const float PI = 3.14159265359;
+
+layout(location = 0) flat in int in_mode;
+layout(location = 1) in struct dto {
+    vec4 ambient;
+    vec2 tex_coord;
+    vec3 normal;
+    vec3 view_position;
+    vec3 frag_position;
+    vec4 colour;
+    vec4 tangent;
+} in_dto;
+
+mat3 TBN;
+
+float geometry_ggx(float normal_dot_direction, float roughness)
+{
+    roughness += 1;
+    float k = (roughness * roughness) / 8;
+    return normal_dot_direction / (normal_dot_direction * (1 - k) + k);
+}
+
+vec3 calculate_point_light_radiance(point_light light, vec3 view_direction, vec3 frag_position)
+{
+    float distance = length(light.position.xyz - frag_position);
+    float attenuation = 1 / (light.constant + light.linear * distance + light.quadratic * distance * distance);
+
+    return light.colour.rgb * attenuation;
+}
+
+vec3 calculate_directional_light_radiance(directional_light light)
+{
+    return light.colour.rgb;
+}
+
+vec3 calculate_reflectance(vec3 albedo, vec3 normal, vec3 view_direction, vec3 light_direction, float metallic, float roughness, vec3 base_reflectivity, vec3 radiance)
+{
+    vec3 halfway = normalize(view_direction + light_direction);
+    float rough_sq = roughness * roughness;
+    float rough_sq_sq = rough_sq * rough_sq;
+
+    float normal_dot_halfway = max(dot(normal, halfway), 0);
+    float normal_dot_halfway_sq = normal_dot_halfway * normal_dot_halfway;
+
+    float denom = normal_dot_halfway_sq * (rough_sq_sq - 1) + 1;
+    denom = PI * denom * denom;
+
+    float normal_distribution = (rough_sq_sq / denom);
+
+    float normal_dot_view_dir = max(dot(normal, view_direction), 0);
+    float normal_dot_light_dir = max(dot(normal, light_direction), 0);
+
+    float ggx_0 = geometry_ggx(normal_dot_view_dir, roughness);
+    float ggx_1 = geometry_ggx(normal_dot_light_dir, roughness);
+
+    float geo = ggx_0 * ggx_1;
+
+    float cos_theta = max(dot(halfway, view_direction), 0);
+    vec3 fresnel = base_reflectivity + (1 - base_reflectivity) * pow(clamp(1 - cos_theta, 0, 1), 5);
+
+    vec3 numerator = normal_distribution * geo * fresnel;
+    float denominator = 4 * max(dot(normal, view_direction), 0) + 0.0001;
+
+    vec3 specular = numerator / denominator;
+    vec3 refraction_diffuse = vec3(1) - fresnel;
+    refraction_diffuse *= 1 - metallic;
+
+    return (refraction_diffuse * albedo / PI + specular) * radiance * normal_distribution;
+}
+
+void main() {
+    vec3 normal = in_dto.normal;
+    vec3 tangent = in_dto.tangent.xyz;
+    tangent = (tangent - dot(tangent, normal) * normal);
+
+    vec3 bitangent = cross(in_dto.normal, in_dto.tangent.xyz);
+    TBN = mat3(tangent, bitangent, normal);
+
+    vec3 local_normal = 2 * texture(samplers[SAMP_NORMAL], in_dto.tex_coord).rgb - 1;
+    normal = normalize(TBN * local_normal);
+
+    vec4 albedo_samp = texture(samplers[SAMP_ALBEDO], in_dto.tex_coord);
+
+    //Gamma correction
+    vec3 albedo = pow(albedo_samp.rgb, vec3(2.2));
+
+    float metallic = texture(samplers[SAMP_METALLIC], in_dto.tex_coord).r;
+    float roughness = texture(samplers[SAMP_ROUGHNESS], in_dto.tex_coord).r;
+    float ao = texture(samplers[SAMP_AO], in_dto.tex_coord).r;
+
+    vec3 base_reflectivity = vec3(0.04);
+    base_reflectivity = mix(base_reflectivity, albedo, metallic);
+
+    if (in_mode == 0 || in_mode == 1)
+    {
+        vec3 view_direction = in_dto.view_position - in_dto.frag_position;
+        albedo += vec3(1) * in_mode;
+
+        albedo = clamp(albedo, vec3(0), vec3(1));
+
+        vec3 total_reflectance = vec3(0);
+
+        {
+            directional_light light = object_ubo.dir_light;
+            vec3 light_dir = normalize(-light.direction.xyz);
+            vec3 radiance = calculate_directional_light_radiance(light);
+
+            total_reflectance += calculate_reflectance(albedo, normal, view_direction, light_dir, metallic, roughness, base_reflectivity, radiance);
+        }
+
+        for (int i = 0; i < object_ubo.num_point_lights; i++)
+        {
+            point_light light = object_ubo.point_lights[i];
+
+            vec3 light_dir = normalize(light.position.xyz - in_dto.frag_position.xyz);
+
+            vec3 radiance = calculate_point_light_radiance(light, in_dto.view_position, in_dto.frag_position);
+
+            total_reflectance += calculate_reflectance(albedo, normal, view_direction, light_dir, metallic, roughness, base_reflectivity, radiance);
+        }
+
+        vec3 irradiance = texture(samplersCube[SAMP_IBL], normal).rgb;
+
+        vec3 ambient = irradiance * albedo * ao;
+        vec3 colour = ambient + total_reflectance;
+        colour = colour / (colour + vec3(1));
+        colour = pow(colour, vec3(1 / 2.2));
+
+        out_colour = vec4(colour, albedo_samp.a);
+    }
+    else if (in_mode == 2)
+    {
+        out_colour = vec4(abs(normal), 1);
+    }
+}
+

assets/shaders/PBRShader.vert

@@ -0,0 +1,50 @@
+#version 450
+
+layout(location = 0) in vec3 in_position;
+layout(location = 1) in vec3 in_normal;
+layout(location = 2) in vec2 in_texcoord;
+layout(location = 3) in vec4 in_colour;
+layout(location = 4) in vec4 in_tangent;
+
+layout(set = 0, binding = 0) uniform global_uniform_object {
+    mat4 projection;
+	mat4 view;
+	vec4 ambient_colour;
+	vec3 view_position;
+	int mode;
+} global_ubo;
+
+layout(push_constant) uniform push_constants {
+	
+	// Only guaranteed a total of 128 bytes.
+	mat4 model; // 64 bytes
+} u_push_constants;
+
+layout(location = 0) out int out_mode;
+
+// Data Transfer Object
+layout(location = 1) out struct dto {
+	vec4 ambient;
+	vec2 tex_coord;
+	vec3 normal;
+	vec3 view_position;
+	vec3 frag_position;
+	vec4 colour;
+	vec4 tangent;
+} out_dto;
+
+void main() {
+	out_dto.tex_coord = in_texcoord;
+	out_dto.colour = in_colour;
+	// Fragment position in world space.
+	out_dto.frag_position = vec3(u_push_constants.model * vec4(in_position, 1.0));
+	// Copy the normal over.
+	mat3 m3_model = mat3(u_push_constants.model);
+	out_dto.normal = normalize(m3_model * in_normal);
+	out_dto.tangent = vec4(normalize(m3_model * in_tangent.xyz), in_tangent.w);
+	out_dto.ambient = global_ubo.ambient_colour;
+	out_dto.view_position = global_ubo.view_position;
+    gl_Position = global_ubo.projection * global_ubo.view * u_push_constants.model * vec4(in_position, 1.0);
+
+	out_mode = global_ubo.mode;
+}

assets/shaders/Shader.PBR.shadercfg

@@ -0,0 +1,32 @@
+#Physically Based Rendering
+version=1.0
+
+name = Shader.PBR
+stages = vertex,fragment
+stagefiles = shaders/PBRShader.vert.spv,shaders/PBRShader.frag.spv
+depth_test = 1
+depth_write = 1
+
+attribute=vec3,in_position
+attribute=vec3,in_normal
+attribute=vec2,in_texcoord
+attribute=vec4,in_colour
+attribute=vec4,in_tangent
+
+# NOTE: For scope: 0=global, 1=instance, 2=local
+uniform=mat4,0,projection
+uniform=mat4,0,view
+uniform=vec4,0,ambient_colour
+uniform=vec3,0,view_position
+uniform=u32,0,mode
+uniform=samp,1,albedo_texture
+uniform=samp,1,normal_texture
+uniform=samp,1,metallic_texture
+uniform=samp,1,roughness_texture
+uniform=samp,1,ao_texture
+uniform=samp,1,cube_texture
+uniform=struct32,1,dir_light
+uniform=struct480,1,point_lights
+uniform=struct32,1,properties
+uniform=i32,1,num_point_lights
+uniform=mat4,2,model