feat(pointLightSystem): added specular light

Author: imedina7

models/suzanne.obj

@@ -11,6 +11,7 @@ struct PointLight {
 layout (set = 0, binding = 0) uniform GlobalUbo {
   mat4 projection;
   mat4 view;
+  mat4 inverseView;
   vec4 ambientLightColor;
   PointLight pointLights[10];
   int numLights;

shaders/point_light.frag

@@ -19,6 +19,7 @@ struct PointLight {
 layout (set = 0, binding = 0) uniform GlobalUbo {
   mat4 projection;
   mat4 view;
+  mat4 inverseView;
   vec4 ambientLightColor;
   PointLight pointLights[10];
   int numLights;

shaders/point_light.vert

@@ -14,6 +14,7 @@ struct PointLight {
 layout (set = 0, binding = 0) uniform GlobalUbo {
   mat4 projection;
   mat4 view;
+  mat4 inverseView;
   vec4 ambientLightColor;
   PointLight pointLights[10];
   int numLights;
@@ -27,18 +28,33 @@ layout(push_constant) uniform Push {
 void main() {
   vec3 ambientLight = ubo.ambientLightColor.xyz * ubo.ambientLightColor.w;
   vec3 diffuseLight = ambientLight;
+
+  vec3 specularLight = vec3(0.0);
+
   vec3 surfaceNormal = normalize(fragNormalWorld);
 
+  vec3 cameraPosWorld = ubo.inverseView[3].xyz;
+  vec3 viewDirection = normalize(cameraPosWorld - fragPosWorld);
+
+
+
   for(int i = 0; i < ubo.numLights; i++) {
     PointLight light = ubo.pointLights[i];
     vec3 directionToLight = light.position.xyz - fragPosWorld;
     float attenuation = 1.0 / dot(directionToLight, directionToLight);
+    directionToLight = normalize(directionToLight);
 
-    float cosAngleIncidence = max(dot(normalize(fragNormalWorld), normalize(directionToLight)), 0);
+    float cosAngleIncidence = max(dot(normalize(fragNormalWorld), directionToLight), 0);
     vec3 intensity = light.color.xyz * light.color.w * attenuation;
 
     diffuseLight += intensity * cosAngleIncidence;
+
+    vec3 halfAngle = normalize(directionToLight + viewDirection);
+    float blinnTerm = dot(surfaceNormal, halfAngle);
+    blinnTerm = clamp(blinnTerm, 0, 1);
+    blinnTerm = pow(blinnTerm, 202.0);
+    specularLight += intensity * blinnTerm;
   }
 
-  outColor = vec4(diffuseLight * fragColor, 1.0);
+  outColor = vec4(diffuseLight * fragColor + specularLight * fragColor, 1.0);
 }

shaders/simple_shader.frag

@@ -17,6 +17,7 @@ struct PointLight {
 layout (set = 0, binding = 0) uniform GlobalUbo {
   mat4 projection;
   mat4 view;
+  mat4 inverseView;
   vec4 ambientLightColor;
   PointLight pointLights[10];
   int numLights;

shaders/simple_shader.vert

@@ -137,6 +137,7 @@ void DvmApp::run()
 
       ubo.projection = camera.getProjection();
       ubo.view = camera.getView();
+      ubo.inverseView = camera.getInverseView();
       pointLightSystem.update(frameInfo, ubo);
 
       uboBuffers[frameIndex]->writeToBuffer(&ubo);
@@ -157,13 +158,12 @@ void DvmApp::loadGameObjects()
 {
   std::shared_ptr<DvmModel> model = DvmModel::createModelFromFile(
       dvmDevice,
-      "C:\\Users\\israel.medina\\projects\\personal\\dvm-engine\\models\\flat_"
-      "vase.obj");
+      "models/flat_vase.obj");
 
   auto vase = DvmGameObject::createGameObject();
   vase.model = model;
   vase.transform.translation = {
-      0.f,
+      -0.5f,
       .5f,
       .0f,
   };
@@ -172,24 +172,35 @@ void DvmApp::loadGameObjects()
 
   std::shared_ptr<DvmModel> smoothVaseModel = DvmModel::createModelFromFile(
       dvmDevice,
-      "C:\\Users\\israel.medina\\projects\\personal\\dvm-"
-      "engine\\models\\smooth_"
-      "vase.obj");
+      "models/smooth_vase.obj");
 
   auto smoothVase = DvmGameObject::createGameObject();
   smoothVase.model = smoothVaseModel;
   smoothVase.transform.translation = {
-      1.f,
+      0.5f,
       .5f,
       .0f,
   };
   smoothVase.transform.scale = {1.5f, 1.5f, 1.5f};
   gameObjects.emplace(smoothVase.getId(), std::move(smoothVase));
+  
+  std::shared_ptr<DvmModel> suzanneModel = DvmModel::createModelFromFile(
+      dvmDevice,
+      "models/suzanne.obj");
+
+  auto suzanne = DvmGameObject::createGameObject();
+  suzanne.model = suzanneModel;
+  suzanne.transform.translation = {
+      0.f,
+      -1.5f,
+      .0f,
+  };
+  suzanne.transform.scale = {0.5f, 0.5f, 0.5f};
+  gameObjects.emplace(suzanne.getId(), std::move(suzanne));
 
   std::shared_ptr<DvmModel> floorModel = DvmModel::createModelFromFile(
       dvmDevice,
-      "C:\\Users\\israel.medina\\projects\\personal\\dvm-"
-      "engine\\models\\quad.obj");
+      "models/quad.obj");
 
   auto floorObject = DvmGameObject::createGameObject();
   floorObject.model = floorModel;

src/dvm_app.cpp

@@ -49,6 +49,20 @@ void DvmCamera::setViewDirection(glm::vec3 position,
   viewMatrix[3][0] = -glm::dot(u, position);
   viewMatrix[3][1] = -glm::dot(v, position);
   viewMatrix[3][2] = -glm::dot(w, position);
+
+  inverseViewMatrix = glm::mat4{1.f};
+  inverseViewMatrix[0][0] = u.x;
+  inverseViewMatrix[0][1] = u.y;
+  inverseViewMatrix[0][2] = u.z;
+  inverseViewMatrix[1][0] = v.x;
+  inverseViewMatrix[1][1] = v.y;
+  inverseViewMatrix[1][2] = v.z;
+  inverseViewMatrix[2][0] = w.x;
+  inverseViewMatrix[2][1] = w.y;
+  inverseViewMatrix[2][2] = w.z;
+  inverseViewMatrix[3][0] = position.x;
+  inverseViewMatrix[3][1] = position.y;
+  inverseViewMatrix[3][2] = position.z;
 }
 
 void DvmCamera::setViewTarget(glm::vec3 position,
@@ -84,5 +98,19 @@ void DvmCamera::setViewYXZ(glm::vec3 position, glm::vec3 rotation)
   viewMatrix[3][0] = -glm::dot(u, position);
   viewMatrix[3][1] = -glm::dot(v, position);
   viewMatrix[3][2] = -glm::dot(w, position);
+
+  inverseViewMatrix = glm::mat4{1.f};
+  inverseViewMatrix[0][0] = u.x;
+  inverseViewMatrix[0][1] = u.y;
+  inverseViewMatrix[0][2] = u.z;
+  inverseViewMatrix[1][0] = v.x;
+  inverseViewMatrix[1][1] = v.y;
+  inverseViewMatrix[1][2] = v.z;
+  inverseViewMatrix[2][0] = w.x;
+  inverseViewMatrix[2][1] = w.y;
+  inverseViewMatrix[2][2] = w.z;
+  inverseViewMatrix[3][0] = position.x;
+  inverseViewMatrix[3][1] = position.y;
+  inverseViewMatrix[3][2] = position.z;
 }
 }  // namespace dvm

src/dvm_camera.cpp

@@ -26,6 +26,7 @@ class DvmCamera
 
   const glm::mat4 getProjection() const { return projectionMatrix; }
   const glm::mat4 getView() const { return viewMatrix; }
+  const glm::mat4 getInverseView() const { return inverseViewMatrix; }
 
 private:
   glm::mat4 projectionMatrix {1.f};

src/dvm_camera.hpp

@@ -18,7 +18,7 @@ struct GlobalUbo
 {
   glm::mat4 projection {1.0f};
   glm::mat4 view {1.0f};
-
+  glm::mat4 inverseView {1.0f};
   glm::vec4 ambientLightColor {1.0f, 1.0f, 1.0f, .02f};  // w is intensity
   PointLight pointLights[MAX_LIGHTS];
   int numLights;

src/dvm_frame_info.hpp

@@ -112,7 +112,7 @@ std::unique_ptr<DvmModel> DvmModel::createModelFromFile(
     DvmDevice& device, const std::string& filepath)
 {
   Builder builder {};
-  builder.loadModel(filepath);
+  builder.loadModel(ENGINE_DIR + filepath);
   std::cout << "Vertex count: " << builder.vertices.size() << std::endl;
   return std::make_unique<DvmModel>(device, builder);
 }

src/dvm_model.cpp

@@ -7,6 +7,10 @@
 
 #include <memory>
 
+#ifndef ENGINE_DIR
+#  define ENGINE_DIR "../"
+#endif
+
 namespace dvm
 {
 class DvmModel