Отражения на основании скайбокса

shaders/lighting.frag

@@ -35,12 +35,14 @@ uniform float camera_cascade_distances[4]; // Размер массива дол
 
 uniform sampler2D gPosition;
 uniform sampler2D gNormal;
-uniform sampler2D gDiffuseP;
+uniform sampler2D gBaseColor;
-uniform sampler2D gAmbientSpecular;
+uniform sampler2D gRMS;
+uniform sampler2D gEmittedColor;
 uniform sampler2DArray sunShadowDepth;
 uniform samplerCubeArray pointShadowDepth;
 uniform sampler2D ssao;
 uniform usampler2D gID;
+uniform samplerCube reflections;
 
 uniform uvec3 selectedID;
 
@@ -51,25 +53,68 @@ layout(std140, binding = 4) uniform gamma
 
 out vec4 color; 
 
+const float PI = 3.14159265359;
+
+float D(vec3 H, vec3 N, float a)
+{
+    float tmp = max(dot(N, H), 0);
+    tmp = tmp*tmp*(a*a-1)+1;
+    return a*a/(PI * tmp*tmp);
+}
+
+float G_Sclick_Beckmann(float NDotDir, float a)
+{
+    float tmp = (a+1)*(a+1) / 8;
+    return 1 / (NDotDir * (1 - tmp) + tmp);
+}
+
+float G_Smith(float LDotN, float CamDotN, float a)
+{
+    return G_Sclick_Beckmann(LDotN, a) * G_Sclick_Beckmann(CamDotN, a);
+}
+
+vec3 F(vec3 H, vec3 Cam_vertex, float metallic, float specular, vec3 base_color)
+{
+    vec3 F0 = mix(vec3(0.08 * specular), base_color, metallic);
+    return F0 + (1 - F0) * pow(1 - max(dot(H, Cam_vertex),0), 5);
+}
+
+float G_Sclick_Beckmann_HS(float NDotDir, float a)
+{
+    float tmp = (a+1)*(a+1) / 2;
+    return 1 / (NDotDir * (1 - tmp) + tmp);
+}
+
+float G_Smith_HS(float LDotN, float CamDotN, float a)
+{
+    return G_Sclick_Beckmann_HS(LDotN, a) * G_Sclick_Beckmann_HS(CamDotN, a);
+}
+
+vec3 F_roughness(vec3 H, vec3 Cam_vertex, float metallic, float roughness, float specular, vec3 base_color)
+{
+    vec3 F0 = mix(vec3(0.08 * specular), base_color, metallic);
+    return F0 + (max(vec3(1.0 - roughness), F0) - F0) * pow(1 - max(dot(H, Cam_vertex),0), 5);
+}
+
 void main() 
 { 
     // Получим данные из текстур буфера
     vec3 fragPos = texture(gPosition, texCoord).rgb;
-    vec3 N = texture(gNormal, texCoord).rgb;
+    vec3 N = normalize(texture(gNormal, texCoord).rgb);
-    vec3 kd = texture(gDiffuseP, texCoord).rgb;
+    vec3 base_color = texture(gBaseColor, texCoord).rgb;
-    vec3 ka = texture(gAmbientSpecular, texCoord).rgb;
+    float roughness = texture(gRMS, texCoord).r;
-    float ks = texture(gAmbientSpecular, texCoord).a;
+    float metallic = texture(gRMS, texCoord).g;
-    float p = texture(gDiffuseP, texCoord).a;
+    float specular = texture(gRMS, texCoord).b;
     float ssao_value = texture(ssao, texCoord).r;
     
     // Переменные используемые в цикле:
-    vec3 L_vertex; // Данные об источнике относительно фрагмента
+    vec3 L_vertex; // Расположение источника относительно фрагмента
-    vec3 Cam_vertex = normalize(camera.position - fragPos); // Данные о камере относительно фрагмента
-    float diffuse; // Диффузная составляющая
-    vec3 H; // Вектор половины пути
-    float specular; // Зеркальная составляющая
     float L_distance; // Расстояние от поверхности до источника
-    float attenuation; // Коэф. угасания
+    vec3 Cam_vertex = normalize(camera.position - fragPos); // Расположение камеры относительно фрагмента
+    vec3 ks; // Интенсивность зеркального отражения
+    vec3 fd, fs; // Диффузное и зеркальное отражения
+    vec3 H; // Вектор половины пути
+    float attenuation; // Угасание с учетом расстояния
     float acosA; // Косинус между вектором от поверхности к источнику и обратным направлением источника
     float intensity; // Интенсивность для прожектора
     vec3 fragPosLightSpace; // Фрагмент в пространстве источника
@@ -82,6 +127,8 @@ void main()
 
     vec4 fragPosCamSpace = camera.view * vec4(fragPos, 1); // Фрагмент в пространстве камеры
     int cascade_index; // Индекс текущего каскада для вычисления теней
+    float CamDotN = dot(Cam_vertex,N); // Скалярное произведение вектора на камеру и нормали
+    float LDotN; // Скалярное произведение вектора на источник и нормали
 
     // Определение индекса каскада в который попадает фрагмент (цикл на 1 меньше чем кол-во каскадов)
     for (cascade_index = 0; cascade_index < 3; cascade_index++)
@@ -89,7 +136,27 @@ void main()
             break;
 
     // Фоновая освещенность
-    color = vec4(ka, 1) * ssao_value;
+    color = vec4(texture(gEmittedColor, texCoord).rgb, 1);
+    
+    // Если у модели есть нормаль
+    if (length(N) > 0)
+    {
+        // Отражения на основании карт отражений
+        vec3 reflectedVec = reflect(-Cam_vertex, N);
+        vec3 reflectedColor = textureLod(reflections, reflectedVec, 6*roughness).rgb;
+
+        LDotN = dot(reflectedVec, N);
+
+        // Вектор половины пути
+        H = normalize(reflectedVec + Cam_vertex);
+
+        // Зеркальное отражение
+        ks = F_roughness(N, Cam_vertex, metallic, roughness, specular, base_color);
+        fs = ks * min(D(H, N, roughness*roughness) / 4, 1) * G_Smith_HS(LDotN, CamDotN, roughness*roughness);
+
+        // Результирующий цвет с учетом солнца
+        color.rgb += fs * reflectedColor * LDotN;
+
         
         // Расчет солнца, если его цвет не черный
         if (length(sun.color) > 0)
@@ -102,6 +169,7 @@ void main()
             fragPosLightSpace.z -= max(0.05 * (1.0 - dot(N, sun.direction)), 0.005);
             // Проверка PCF
             shadowValue = 0.0;
+            texelSize = 1.0 / textureSize(sunShadowDepth, 0).xy; // Размер текселя текстуры теней
             for(x = -1; x <= 1; ++x)
             {
                 for(y = -1; y <= 1; ++y)
@@ -110,22 +178,28 @@ void main()
                     shadowValue += fragPosLightSpace.z > pcfDepth  ? 1.0 : 0.0;        
                 }    
             }
-        shadowValue /= 9;
+            shadowValue /= 9.0;
             // Рассчитываем освещенность, если значение тени меньше 1
             if (shadowValue < 1.0)
             {
                 // Данные об источнике относительно фрагмента
                 L_vertex = normalize(sun.direction);
-            // Диффузная составляющая
+                LDotN = dot(L_vertex,N);
-            diffuse = max(dot(L_vertex, N), 0.0); // скалярное произведение с отсеканием значений < 0
+                if (LDotN > 0)
-            
+                {
                     // Вектор половины пути
                     H = normalize(L_vertex + Cam_vertex);
-            // Зеркальная составляющая
+
-            specular = pow(max(dot(H, N), 0.0), p*4); // скалярное произведение с отсеканием значений < 0 в степени p
+                    // Зеркальное отражение
+                    ks = F(H, Cam_vertex, metallic, specular, base_color);
+                    fs = ks * min(D(H, N, roughness*roughness) / 4, 1) * G_Smith(LDotN, CamDotN, roughness*roughness);
+
+                    // Диффузное отражение
+                    fd = (1 - length(ks)/length(base_color)) * base_color;
+
                     // Результирующий цвет с учетом солнца
-            color += (  vec4(sun.color*kd*diffuse,  1)  
+                    color.rgb += (fd + fs) * sun.color * LDotN * (1.0 - shadowValue);
-                      + vec4(sun.color*ks*specular, 1) ) * (1.0 - shadowValue);
+                }
             }
         } 
 
@@ -140,7 +214,7 @@ void main()
             // Дистанция между фрагментом и источником в диапазоне [0;1]
             cubemap_depth = length(fragPosLightSpace) / light_f.data[i].attenuation.r;
             // Сдвиг для решения проблемы акне
-        cubemap_depth -= max(0.05 * (1.0 - dot(N, light_f.data[i].direction_angle.xyz)), 0.005);
+            cubemap_depth -= max(0.05 * (1.0 - dot(N, sun.direction)), 0.005);
             for(x = -1; x <= 1; ++x)
             {
                 for(y = -1; y <= 1; ++y)
@@ -159,7 +233,6 @@ void main()
             {
                 // Данные об источнике относительно фрагмента
                 L_vertex = light_f.data[i].position - fragPos;
-
                 // Расстояние от поверхности до источника
                 L_distance = length(L_vertex);
 
@@ -169,38 +242,44 @@ void main()
                     // Нормирование вектора
                     L_vertex = normalize(L_vertex);
                     // арккосинус между вектором от поверхности к источнику и обратным направлением источника
-                acosA = degrees(acos(dot(-L_vertex, normalize(light_f.data[i].direction_angle.xyz))));
+                    acosA = degrees(acos(dot(-L_vertex, normalize(light_f.data[i].direction_angle.rgb))));
                     // Если угол меньше угла источника или угол источника минимален, то считаем освещенность
                     if(acosA <= light_f.data[i].direction_angle.a) 
                     {
-                    // Диффузная составляющая
+                        LDotN = dot(L_vertex,N);
-                    diffuse = max(dot(L_vertex, N), 0.0); // скалярное произведение с отсеканием значений < 0
+                        if (LDotN > 0)
-                    
+                        {
                             // Вектор половины пути
                             H = normalize(L_vertex + Cam_vertex);
-                    // Зеркальная составляющая
-                    specular = pow(max(dot(H, N), 0.0), p*4); // скалярное произведение с отсеканием значений < 0 в степени p
 
                             // Угасание с учетом расстояния
                             attenuation = 1 / (1 + light_f.data[i].attenuation[1] * L_distance + light_f.data[i].attenuation[2] * L_distance * L_distance);
 
+                            // Зеркальное отражение
+                            ks = F(H, Cam_vertex, metallic, specular, base_color);
+                            fs = ks * min(D(H, N, roughness*roughness) / 4, 1) * G_Smith(LDotN, CamDotN, roughness*roughness);
+
+                            // Диффузное отражение
+                            fd = (1 - length(ks)/length(base_color)) * base_color;
+
                             // Если источник - прожектор, то добавим смягчение
                             if (light_f.data[i].direction_angle.a < 180)
                             {
                                 intensity = clamp((light_f.data[i].direction_angle.a - acosA) / 5, 0.0, 1.0);  
-                        diffuse  *= intensity;
+                                fd *= intensity;
-                        specular *= intensity;
+                                fs *= intensity;
                             }
 
-                    color += ( vec4(light_f.data[i].color*kd*diffuse  * attenuation, 1) 
+                            color.rgb += (fd + fs) * light_f.data[i].color * attenuation * LDotN * (1.0 - shadowValue);
-                              + vec4(light_f.data[i].color*ks*specular * attenuation, 1) )  * (1.0 - shadowValue);
+                        }
+                    }
                 }
             }
         }
     }
 
     // Применение гамма-коррекции
-    color.rgb = pow(color.rgb, vec3(inv_gamma));
+    color.rgb = pow(color.rgb * ssao_value, vec3(inv_gamma));
 
     vec3 ID = texture(gID, texCoord).rgb;
     // Обводка выбранного объекта

src/Texture.cpp

@@ -320,12 +320,14 @@ TextureCube::TextureCube(GLuint t, const std::string (&filename)[6])
     else
         handler = filename_handler[complex_name];
 
-    glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+    glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_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);
 
+    glGenerateMipmap(GL_TEXTURE_CUBE_MAP);
+
     handler_count[handler]++;
 }
 

src/main.cpp

@@ -214,7 +214,7 @@ int main(void)
     lightShader.load(GL_FRAGMENT_SHADER, "shaders/lighting.frag");
     lightShader.link();
     // Привязка текстур
-    const char* gtextures_shader_names[]  = {"gPosition", "gNormal", "gBaseColor", "gRMS", "sunShadowDepth", "pointShadowDepth", "ssao", "gID", "gEmittedColor"};
+    const char* gtextures_shader_names[]  = {"gPosition", "gNormal", "gBaseColor", "gRMS", "sunShadowDepth", "pointShadowDepth", "ssao", "gID", "gEmittedColor", "reflections"};
     lightShader.bindTextures(gtextures_shader_names, sizeof(gtextures_shader_names)/sizeof(const char*));
     // Загрузка данных о границах каскадов
     glUniform1fv(lightShader.getUniformLoc("camera_cascade_distances"), CAMERA_CASCADE_COUNT, &camera_cascade_distances[1]);
@@ -451,6 +451,10 @@ int main(void)
     Scale scale;
     TRS& currentTool = transform; 
 
+    // Текстура для отражений скайбокса
+    TextureCube reflections_texture(skybox_texture);
+    reflections_texture.setType(9);
+
     // Пока не произойдет событие запроса закрытия окна
     while(!glfwWindowShouldClose(window))
     {
@@ -558,6 +562,7 @@ int main(void)
         gRMS.use();
         gID.use();
         gEmittedColor.use();
+        reflections_texture.use();
         // Идентификатор выбранного объекта для обводки
         glUniform3uiv(lightShader.getUniformLoc("selectedID"), 1, (GLuint*) &selected);
         // Подключаем текстуры теней