Alpha blending and Specular lights YaY

Zota0 · Zota0 · commit fc57f4b94688 · 2024-12-15T22:40:21.000+01:00
Also all lights are now sorted! YaY!
diff --git a/assets/shaders/point_light.frag b/assets/shaders/point_light.frag
@@ -12,6 +12,7 @@ struct PointLight {
 layout(set = 0, binding = 0) uniform GlobalUbo {
     mat4 projection;
     mat4 view;
+    mat4 invView;
     vec4 ambientLight;
     PointLight pointLights[32];
     int numLights;
@@ -23,8 +24,12 @@ layout(push_constant) uniform Push {
     float radius;
 } push;
 
+const float PI = 3.1415926538;
 void main() {
     float dist = sqrt(dot(fragOffset, fragOffset));
     if(dist >= 1.0) discard;
-    outColor = vec4(push.color.xyz, 1.0);
+
+    float cosDist =  0.5 * (cos(dist * PI) + 1.0); // 1 -> 0
+    
+    outColor = vec4(push.color.xyz + (cosDist * 0.75) , cosDist);
 }
diff --git a/assets/shaders/point_light.frag.spv b/assets/shaders/point_light.frag.spv
diff --git a/assets/shaders/point_light.vert b/assets/shaders/point_light.vert
@@ -19,6 +19,7 @@ struct PointLight {
 layout(set = 0, binding = 0) uniform GlobalUbo {
     mat4 projection;
     mat4 view;
+    mat4 invView;
     vec4 ambientLight;
     PointLight pointLights[32];
     int numLights;
diff --git a/assets/shaders/point_light.vert.spv b/assets/shaders/point_light.vert.spv
diff --git a/assets/shaders/simple.frag b/assets/shaders/simple.frag
@@ -15,6 +15,7 @@ struct PointLight {
 layout(set = 0, binding = 0) uniform GlobalUbo {
     mat4 projection;
     mat4 view;
+    mat4 invView;
     vec4 ambientLight;
     PointLight pointLights[32];
     int numLights;
@@ -28,17 +29,32 @@ layout(push_constant) uniform Push {
 void main() {
     
     vec3 diffuseLight = ubo.ambientLight.xyz * ubo.ambientLight.w;
+    vec3 specularLight = vec3(0.0);
     vec3 surfaceNormal = normalize(fragNormalWorld);
 
+    vec3 cameraPosInWorld = ubo.invView[3].xyz;
+    vec3 viewDir = normalize(cameraPosInWorld - fragPosWorld);
+
     for (int i = 0; i < ubo.numLights; i++) {
         PointLight light = ubo.pointLights[i];
+
         vec3 dirToLight = light.position.xyz - fragPosWorld;
         float attenuation = 1.0 / dot(dirToLight, dirToLight) /* distance squared */;
-        float cosAngleOfIncidence = max(dot(surfaceNormal, normalize(dirToLight)), 0.0);
+
+        dirToLight = normalize(dirToLight);
+        float cosAngleOfIncidence = max(dot(surfaceNormal, dirToLight), 0.0);
         vec3 power = light.color.xyz * light.color.w * attenuation;
     
         diffuseLight += power * cosAngleOfIncidence;
+    
+        // Specular Lighting
+        vec3 halfAngle = normalize(dirToLight + viewDir);
+        float blinnTerm = dot(surfaceNormal, halfAngle);
+        blinnTerm = clamp(blinnTerm, 0, 1);
+        blinnTerm = pow(blinnTerm, 128.0); // higher values -> sharper highlight
+
+        specularLight += power * blinnTerm;
     }
 
-    outColor = vec4( (diffuseLight * fragColor), 1.0);
+    outColor = vec4( (diffuseLight * fragColor + specularLight * fragColor), 1.0);
 }
diff --git a/assets/shaders/simple.frag.spv b/assets/shaders/simple.frag.spv
diff --git a/assets/shaders/simple.vert b/assets/shaders/simple.vert
@@ -17,6 +17,7 @@ struct PointLight {
 layout(set = 0, binding = 0) uniform GlobalUbo {
     mat4 projection;
     mat4 view;
+    mat4 invView;
     vec4 ambientLight;
     PointLight pointLights[32];
     int numLights;
diff --git a/assets/shaders/simple.vert.spv b/assets/shaders/simple.vert.spv
diff --git a/src/camera/camera.cpp b/src/camera/camera.cpp
@@ -53,6 +53,20 @@ namespace BlockyVulkan {
         viewMat[3][0] = -glm::dot(u, pos);
         viewMat[3][1] = -glm::dot(v, pos);
         viewMat[3][2] = -glm::dot(w, pos);
+
+        inverseViewMat = glm::mat4{ 1.f };
+        inverseViewMat[0][0] = u.x;
+        inverseViewMat[0][1] = u.y;
+        inverseViewMat[0][2] = u.z;
+        inverseViewMat[1][0] = v.x;
+        inverseViewMat[1][1] = v.y;
+        inverseViewMat[1][2] = v.z;
+        inverseViewMat[2][0] = w.x;
+        inverseViewMat[2][1] = w.y;
+        inverseViewMat[2][2] = w.z;
+        inverseViewMat[3][0] = pos.x;
+        inverseViewMat[3][1] = pos.y;
+        inverseViewMat[3][2] = pos.z;
     }
 
     void Camera::SetViewTarget(vec3 pos, vec3 target, vec3 up) {
@@ -83,5 +97,19 @@ namespace BlockyVulkan {
         viewMat[3][0] = -glm::dot(u, pos);
         viewMat[3][1] = -glm::dot(v, pos);
         viewMat[3][2] = -glm::dot(w, pos);
+
+        inverseViewMat = glm::mat4{ 1.f };
+        inverseViewMat[0][0] = u.x;
+        inverseViewMat[0][1] = u.y;
+        inverseViewMat[0][2] = u.z;
+        inverseViewMat[1][0] = v.x;
+        inverseViewMat[1][1] = v.y;
+        inverseViewMat[1][2] = v.z;
+        inverseViewMat[2][0] = w.x;
+        inverseViewMat[2][1] = w.y;
+        inverseViewMat[2][2] = w.z;
+        inverseViewMat[3][0] = pos.x;
+        inverseViewMat[3][1] = pos.y;
+        inverseViewMat[3][2] = pos.z;
     }
 }
diff --git a/src/camera/camera.hpp b/src/camera/camera.hpp
@@ -33,10 +33,13 @@ namespace BlockyVulkan {
 
         const mat4& GetProj() const { return projMat; }
         const mat4& GetView() const { return viewMat; }
+        const mat4& GetInvView() const { return inverseViewMat; };
+        const vec3 getPos() const { return vec3(inverseViewMat[3]); }
 
     private:
         mat4 projMat{ 1.f };
         mat4 viewMat{ 1.f };
+        mat4 inverseViewMat{1.f};
 
     };
 }
diff --git a/src/frame_info/frame_info.hpp b/src/frame_info/frame_info.hpp
@@ -25,6 +25,7 @@ namespace BlockyVulkan {
     struct GlobalUBO {
         mat4 projection{ 1.f };
         mat4 view{ 1.f };
+        mat4 inverseView{ 1.f };
         /*    vec3 lightDirection = glm::normalize(vec3{1.f, -3.f, -1.f});*/
         vec4 ambientLight{ 1.f, 1.f, 1.f, .03f };
         PointLight_t pointLights[MAX_LIGHTS];
diff --git a/src/pipeline/pipeline.cpp b/src/pipeline/pipeline.cpp
@@ -233,4 +233,22 @@ namespace BlockyVulkan {
         configInfo.bindingDescriptions = Model::Vertex::GetBindingDescriptions();
         configInfo.attributeDescriptions = Model::Vertex::GetAttributeDescriptions();
     }
+
+    void Pipeline::EnableAlphaBlending(PipelineConfigInfo &configInfo) {
+        configInfo.colorBlendAttachment.blendEnable = VK_TRUE;
+
+        configInfo.colorBlendAttachment.colorWriteMask =
+            VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT |
+            VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
+        configInfo.colorBlendAttachment.srcColorBlendFactor = VK_BLEND_FACTOR_SRC_ALPHA;
+        configInfo.colorBlendAttachment.dstColorBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
+        configInfo.colorBlendAttachment.colorBlendOp = VK_BLEND_OP_ADD;
+        configInfo.colorBlendAttachment.srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE;  // Optional
+        configInfo.colorBlendAttachment.dstAlphaBlendFactor = VK_BLEND_FACTOR_ZERO; // Optional
+        configInfo.colorBlendAttachment.alphaBlendOp = VK_BLEND_OP_ADD;             // Optional
+    }
+
+    void Pipeline::DisableAlphaBlending(PipelineConfigInfo &configInfo) {
+        configInfo.colorBlendAttachment.blendEnable = VK_FALSE;
+    }
 }
diff --git a/src/pipeline/pipeline.hpp b/src/pipeline/pipeline.hpp
@@ -47,6 +47,8 @@ class Pipeline {
     void Bind( VkCommandBuffer commandBuffer );
 
     static void DefaultPipelineConfigInfo(PipelineConfigInfo &configInfo);
+    static void EnableAlphaBlending(PipelineConfigInfo &configInfo);
+    static void DisableAlphaBlending(PipelineConfigInfo &configInfo);
 
   private:
     static std::vector<char> ReadFile(const std::string &filePath);
diff --git a/src/systems/point_light/point_light.cpp b/src/systems/point_light/point_light.cpp
@@ -9,6 +9,7 @@
 // std
 #include <stdexcept>
 #include <cassert>
+#include <map>
 
 namespace BlockyVulkan {
 
@@ -56,6 +57,8 @@ namespace BlockyVulkan {
 
         PipelineConfigInfo pipelineConfig{};
         Pipeline::DefaultPipelineConfigInfo(pipelineConfig);
+        Pipeline::EnableAlphaBlending(pipelineConfig);
+
 
         pipelineConfig.attributeDescriptions.clear(); // So not to trigger validation layers' warnings
         pipelineConfig.bindingDescriptions.clear();   // So not to trigger validation layers' warnings
@@ -92,6 +95,18 @@ namespace BlockyVulkan {
     }
 
     void PointLight::Render(FrameInfo &frameInfo) {
+        // Sort Lights
+        std::map<float, GameObject::id_t> sorted;
+        for (auto &kv : frameInfo.gameObjects) {
+            auto &obj = kv.second;
+            if (obj.pointLight == nullptr) continue;
+
+            // Calculate Distance
+            auto offset = frameInfo.cam.getPos() - obj.transform3D.translation;
+            float distSquared = glm::dot(offset, offset);
+            sorted[distSquared] = obj.GetId();
+        }
+
         pipeline->Bind(frameInfo.commandBuffer);
 
         vkCmdBindDescriptorSets(
@@ -105,10 +120,10 @@ namespace BlockyVulkan {
             nullptr
         );
 
-        for (auto &kv : frameInfo.gameObjects) {
-            auto &obj = kv.second;
-
-            if (obj.pointLight == nullptr) continue;
+        // Iterate through sorted lights(`sorted` map) in reverse order
+        for (auto it = sorted.rbegin(); it != sorted.rend(); ++it) {
+            // use game obj to find light object
+            auto &obj = frameInfo.gameObjects.at(it->second);
 
             PointLightPushConst push{};
             push.position = vec4(obj.transform3D.translation, 1.f);
diff --git a/src/test_1/first_test.cpp b/src/test_1/first_test.cpp
@@ -118,13 +118,14 @@ namespace BlockyVulkan {
                 GlobalUBO ubo{};
                 ubo.projection = camera.GetProj();
                 ubo.view = camera.GetView();
+                ubo.inverseView = camera.GetInvView();
                 pointLight.Update(frameInfo, ubo);
 
                 for (auto &kv : frameInfo.gameObjects) {
                     auto &obj = kv.second;
                     if(obj.pointLight == nullptr) continue;
 
-                    auto rot = glm::rotate(mat4(1.f), deltaTime, { -0.15f, -.8f, .25f });
+                    auto rot = glm::rotate(mat4(1.f), -deltaTime / 2, { -0.15f, -.8f, .25f });
                     obj.transform3D.translation = vec3(rot * vec4(obj.transform3D.translation, 1.f));
                 }
 
@@ -134,8 +135,12 @@ namespace BlockyVulkan {
 
                 // Rendering frame
                 renderer.BeginSwapChainRenderPass(commandBuffer);
+
+                
+                // Order here matters!
                 renderSystem.RenderGameObjects(frameInfo);
                 pointLight.Render(frameInfo);
+
                 // End frame
                 // (from suffering lol)
                 renderer.EndSwapChainRenderPass(commandBuffer);
@@ -187,7 +192,7 @@ namespace BlockyVulkan {
             std::shared_ptr<Model> floorModel = Model::CreateModelFromFile(device, "assets/models/quad.obj");
             auto floor = GameObject::CreateGameObject();
             floor.model = floorModel;
-            floor.transform3D.translation = { 0.f, 5.f, 0.f };
+            floor.transform3D.translation = { 0.f, 1.f, 0.f };
             floor.transform3D.scale = { 10.f, 1.f, 10.f };
 
             gameObjects.emplace(floor.GetId(), std::move(floor));
@@ -233,7 +238,7 @@ namespace BlockyVulkan {
 
             for (int i = 0; i < lights.size(); i++) {
                 float fi = (float)i;
-                auto pointLight = GameObject::MakePointLight((0.8f * fi) + 20.0f, (.01f * fi) + .05f, lights[i]);
+                auto pointLight = GameObject::MakePointLight(8.0f, 0.24f + .05f, lights[i]);
                 auto rotate = glm::rotate(
                     mat4(1.f),
                     (fi * glm::two_pi<float>()) / lights.size(),
diff --git a/x64/Debug/VulkanBlock.exe b/x64/Debug/VulkanBlock.exe
