first attempt at pbr shading

Author: wsmind

src/blender-addon/leaf/__init__.py

@@ -38,7 +38,6 @@ def view_update(self, context):
     def view_draw(self, context):
         vm = context.region_data.view_matrix.copy()
         vm.transpose()
-        print(vm)
         view_matrix = (ctypes.c_float * 16)(
             vm[0][0], vm[0][1], vm[0][2], vm[0][3],
             vm[1][0], vm[1][1], vm[1][2], vm[1][3],

src/blender-addon/leaf/export.py

@@ -52,8 +52,11 @@ def export_light(obj):
     return {}
 
 def export_material(mtl):
+    lmtl = mtl.leaf
     return {
-        "diffuse": [mtl.diffuse_color.r, mtl.diffuse_color.g, mtl.diffuse_color.b]
+        "albedo": [mtl.diffuse_color.r, mtl.diffuse_color.g, mtl.diffuse_color.b],
+        "metalness": lmtl.metalness,
+        "roughness": lmtl.roughness
     }
 
 def export_mesh(sourceMesh):

src/blender-addon/leaf/material.py

@@ -1,6 +1,36 @@
 import bpy
 
 from bpy.types import Panel, Menu, Operator
+from bpy.props import (BoolProperty,
+                       EnumProperty,
+                       FloatProperty,
+                       IntProperty,
+                       PointerProperty)
+
+class LeafMaterialSettings(bpy.types.PropertyGroup):
+    @classmethod
+    def register(cls):
+        bpy.types.Material.leaf = PointerProperty(
+            name="Leaf Material Settings",
+            description="Leaf material settings",
+            type=cls,
+        )
+        cls.metalness = FloatProperty(
+            name="Metalness",
+            description="0: dielectric, 1: metal",
+            min=0.0, max=1.0,
+            default=0.0,
+        )
+        cls.roughness = FloatProperty(
+            name="Roughness",
+            description="0: smooth, 1: rough",
+            min=0.0, max=1.0,
+            default=0.5,
+        )
+
+    @classmethod
+    def unregister(cls):
+        del bpy.types.Material.leaf
 
 class LeafMaterialButtonsPanel():
     bl_space_type = "PROPERTIES"
@@ -23,5 +53,8 @@ def poll(cls, context):
     def draw(self, context):
         layout = self.layout
         mat = context.material
+        lmat = context.material.leaf
 
-        layout.prop(mat, "diffuse_color")
+        layout.prop(mat, "diffuse_color", text="Albedo")
+        layout.prop(lmat, "metalness")
+        layout.prop(lmat, "roughness")

src/engine/Material.cpp

@@ -3,12 +3,17 @@
 #include <engine/ResourceManager.h>
 
 const std::string Material::resourceClassName = "Material";
-const std::string Material::defaultResourceData = "{\"diffuse\": [1.0, 0.0, 1.0]}";
+const std::string Material::defaultResourceData = "{\"albedo\": [1.0, 0.0, 1.0], \"metalness\": 0.5, \"roughness\": 0.5}";
 
 void Material::load(const cJSON *json)
 {
-    cJSON *diffuse = cJSON_GetObjectItem(json, "diffuse");
-    this->data.diffuse = glm::vec3(cJSON_GetArrayItem(diffuse, 0)->valuedouble, cJSON_GetArrayItem(diffuse, 1)->valuedouble, cJSON_GetArrayItem(diffuse, 2)->valuedouble);
+    cJSON *diffuse = cJSON_GetObjectItem(json, "albedo");
+    this->data.albedo = glm::vec3(cJSON_GetArrayItem(diffuse, 0)->valuedouble, cJSON_GetArrayItem(diffuse, 1)->valuedouble, cJSON_GetArrayItem(diffuse, 2)->valuedouble);
+    this->data.metalness = (float)cJSON_GetObjectItem(json, "metalness")->valuedouble;
+    this->data.roughness = (float)cJSON_GetObjectItem(json, "roughness")->valuedouble;
+
+    // normalize diffuse BRDF
+    this->data.albedo /= 3.1415926535f;
 }
 
 void Material::unload()

src/engine/Material.h

@@ -13,8 +13,10 @@ class Material: public Resource
         #pragma pack(16)
         struct MaterialData
         {
-            glm::vec3 diffuse;
-            float _padding[1];
+            glm::vec3 albedo;
+            float metalness;
+            float roughness;
+            float _padding[3];
         };
         #pragma pack(pop)
 

src/engine/shaders/basic.ps.hlsl

@@ -5,6 +5,11 @@ struct PS_OUTPUT
 	float4 color: SV_TARGET;
 };
 
+float g1v(float dotNV, float k)
+{
+    return 1.0 / (dotNV * (1.0 - k) + 1.0);
+}
+
 PS_OUTPUT main(BASIC_PS_INPUT input)
 {
 	PS_OUTPUT output;
@@ -14,10 +19,42 @@ PS_OUTPUT main(BASIC_PS_INPUT input)
     const float3 normal = normalize(input.normal);
     const float3 h = normalize(eye + light);
 
-    float d = saturate(dot(normal, light));
+    /*float d = saturate(dot(normal, light));
     float s = saturate(pow(dot(normal, h), 80.0));
+    float3 blinn_phong = diffuse * d + s;*/
+
+    // blend between dielectric and metal
+    const float f0 = 0.03;
+    float3 specularColor = lerp(float3(1.0, 1.0, 1.0), albedo, metalness);
+    float3 finalAlbedo = albedo * (1.0 - metalness);
+
+    // precompute all cosines
+    float dotLH = saturate(dot(light, h));
+    float dotNH = saturate(dot(normal, h));
+    float dotNL = saturate(dot(normal, light));
+    float dotNV = saturate(dot(normal, eye));
+
+    // simple lambert for diffuse
+    float3 diffuse = dotNL * finalAlbedo;
+
+    // schlick fresnel approximation
+    float fresnel = f0 + (1.0 - f0) * pow(1.0 - dotNV, 5.0);
+
+    float alpha = roughness * roughness;
+    float alphaSquared = alpha * alpha;
+
+    // GGX normal distribution
+    float denominator = dotNH * dotNH * (alphaSquared - 1.0) + 1.0;
+    float normalDistribution = alphaSquared / (3.141592 * denominator * denominator);
+
+    // schlick approximation for geometry factor
+    float k = alpha * 0.5;
+    float geometryFactor = g1v(dotNL, k) * g1v(dotNV, k);
+
+    // cook-torrance microfacet model
+    float3 specular = specularColor * dotNL * fresnel * normalDistribution * geometryFactor;
 
-	output.color = float4(diffuse * d + s, 1.0);
+	output.color = float4((diffuse + specular) * 10.0, 1.0);
 
 	return output;
 }

src/engine/shaders/shared.h

@@ -23,7 +23,9 @@ cbuffer SceneData: register(b0)
 
 cbuffer MaterialData: register(b1)
 {
-    float3 diffuse;
+    float3 albedo; // already divided by Pi
+    float metalness;
+    float roughness;
 };
 
 cbuffer InstanceData: register(b2)