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

shaders/lighting.frag

@@ -35,12 +35,14 @@ uniform float camera_cascade_distances[4]; // Размер массива дол
 
 uniform sampler2D gPosition;
 uniform sampler2D gNormal;
-uniform sampler2D gDiffuseP;
-uniform sampler2D gAmbientSpecular;
+uniform sampler2D gBaseColor;
+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 kd = texture(gDiffuseP, texCoord).rgb;
-    vec3 ka = texture(gAmbientSpecular, texCoord).rgb;
-    float ks = texture(gAmbientSpecular, texCoord).a;
-    float p = texture(gDiffuseP, texCoord).a;
+    vec3 N = normalize(texture(gNormal, texCoord).rgb);
+    vec3 base_color = texture(gBaseColor, texCoord).rgb;
+    float roughness = texture(gRMS, texCoord).r;
+    float metallic = texture(gRMS, texCoord).g;
+    float specular = texture(gRMS, texCoord).b;
     float ssao_value = texture(ssao, texCoord).r;
     
     // Переменные используемые в цикле:
-    vec3 L_vertex; // Данные об источнике относительно фрагмента
-    vec3 Cam_vertex = normalize(camera.position - fragPos); // Данные о камере относительно фрагмента
-    float diffuse; // Диффузная составляющая
-    vec3 H; // Вектор половины пути
-    float specular; // Зеркальная составляющая
+    vec3 L_vertex; // Расположение источника относительно фрагмента
     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,118 +136,150 @@ void main()
             break;
 
     // Фоновая освещенность
-    color = vec4(ka, 1) * ssao_value;
+    color = vec4(texture(gEmittedColor, texCoord).rgb, 1);
     
-    // Расчет солнца, если его цвет не черный
-    if (length(sun.color) > 0)
+    // Если у модели есть нормаль
+    if (length(N) > 0)
     {
-        // Расположение фрагмента в координатах теневой карты
-        fragPosLightSpace = (sun.vp[cascade_index] * vec4(fragPos, 1.0)).xyz;
-        // Переход от [-1;1] к [0;1]
-        fragPosLightSpace = (fragPosLightSpace + vec3(1.0)) / 2;
-        // Сдвиг для решения проблемы акне
-        fragPosLightSpace.z -= max(0.05 * (1.0 - dot(N, sun.direction)), 0.005);
-        // Проверка PCF
-        shadowValue = 0.0;
-        for(x = -1; x <= 1; ++x)
-        {
-            for(y = -1; y <= 1; ++y)
-            {
-                pcfDepth = texture(sunShadowDepth, vec3(fragPosLightSpace.xy + vec2(x, y) * texelSize, cascade_index)).r;
-                shadowValue += fragPosLightSpace.z > pcfDepth  ? 1.0 : 0.0;        
-            }
-        }
-        shadowValue /= 9;
-        // Рассчитываем освещенность, если значение тени меньше 1
-        if (shadowValue < 1.0)
-        {
-            // Данные об источнике относительно фрагмента
-            L_vertex = normalize(sun.direction);
-            // Диффузная составляющая
-            diffuse = max(dot(L_vertex, N), 0.0); // скалярное произведение с отсеканием значений < 0
+        // Отражения на основании карт отражений
+        vec3 reflectedVec = reflect(-Cam_vertex, N);
+        vec3 reflectedColor = textureLod(reflections, reflectedVec, 6*roughness).rgb;
 
-            // Вектор половины пути
-            H = normalize(L_vertex + Cam_vertex);
-            // Зеркальная составляющая
-            specular = pow(max(dot(H, N), 0.0), p*4); // скалярное произведение с отсеканием значений < 0 в степени p
-            // Результирующий цвет с учетом солнца
-            color += (  vec4(sun.color*kd*diffuse,  1)  
-                      + vec4(sun.color*ks*specular, 1) ) * (1.0 - shadowValue);
-        }
-    }
+        LDotN = dot(reflectedVec, N);
 
-    // Цикл по источникам света
-    int i;
-    for (i = 0; i < light_f.count; i++)
-    {
-        // Обнулим значение тени
-        shadowValue = 0;
-        // Позиция фрагмента относительно источника
-        fragPosLightSpace = fragPos - light_f.data[i].position;
-        // Дистанция между фрагментом и источником в диапазоне [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);
-        for(x = -1; x <= 1; ++x)
+        // Вектор половины пути
+        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)
         {
-            for(y = -1; y <= 1; ++y)
+            // Расположение фрагмента в координатах теневой карты
+            fragPosLightSpace = (sun.vp[cascade_index] * vec4(fragPos, 1.0)).xyz;
+            // Переход от [-1;1] к [0;1]
+            fragPosLightSpace = (fragPosLightSpace + vec3(1.0)) / 2;
+            // Сдвиг для решения проблемы акне
+            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(z = -1; z <= 1; ++z)
+                for(y = -1; y <= 1; ++y)
                 {
-                    // Значение из кубической текстуры с учетом источника (i)
-                    pcfDepth = texture(pointShadowDepth, vec4(fragPosLightSpace + vec3(x, y, z)*cubemap_offset, i)).r; 
-                    if(cubemap_depth > pcfDepth)
-                        shadowValue += 1.0;
+                    pcfDepth = texture(sunShadowDepth, vec3(fragPosLightSpace.xy + vec2(x, y) * texelSize, cascade_index)).r;
+                    shadowValue += fragPosLightSpace.z > pcfDepth  ? 1.0 : 0.0;        
+                }    
+            }
+            shadowValue /= 9.0;
+            // Рассчитываем освещенность, если значение тени меньше 1
+            if (shadowValue < 1.0)
+            {
+                // Данные об источнике относительно фрагмента
+                L_vertex = normalize(sun.direction);
+                LDotN = dot(L_vertex,N);
+                if (LDotN > 0)
+                {
+                    // Вектор половины пути
+                    H = normalize(L_vertex + Cam_vertex);
+
+                    // Зеркальное отражение
+                    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.rgb += (fd + fs) * sun.color * LDotN * (1.0 - shadowValue);
                 }
             }
         } 
-        shadowValue /= (27);
-        if (shadowValue < 1.0)
+
+        // Цикл по источникам света
+        int i;
+        for (i = 0; i < light_f.count; i++)
         {
-            // Данные об источнике относительно фрагмента
-            L_vertex = light_f.data[i].position - fragPos;
-
-            // Расстояние от поверхности до источника
-            L_distance = length(L_vertex);
-            
-            // Проверка на дистанцию
-            if (L_distance < light_f.data[i].attenuation.r)
+            // Обнулим значение тени
+            shadowValue = 0;
+            // Позиция фрагмента относительно источника
+            fragPosLightSpace = fragPos - light_f.data[i].position;
+            // Дистанция между фрагментом и источником в диапазоне [0;1]
+            cubemap_depth = length(fragPosLightSpace) / light_f.data[i].attenuation.r;
+            // Сдвиг для решения проблемы акне
+            cubemap_depth -= max(0.05 * (1.0 - dot(N, sun.direction)), 0.005);
+            for(x = -1; x <= 1; ++x)
             {
-                // Нормирование вектора
-                L_vertex = normalize(L_vertex);
-                // арккосинус между вектором от поверхности к источнику и обратным направлением источника
-                acosA = degrees(acos(dot(-L_vertex, normalize(light_f.data[i].direction_angle.xyz))));
-                // Если угол меньше угла источника или угол источника минимален, то считаем освещенность
-                if(acosA <= light_f.data[i].direction_angle.a) 
+                for(y = -1; y <= 1; ++y)
                 {
-                    // Диффузная составляющая
-                    diffuse = max(dot(L_vertex, N), 0.0); // скалярное произведение с отсеканием значений < 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);
-
-                    // Если источник - прожектор, то добавим смягчение
-                    if (light_f.data[i].direction_angle.a < 180)
+                    for(z = -1; z <= 1; ++z)
                     {
-                        intensity = clamp((light_f.data[i].direction_angle.a - acosA) / 5, 0.0, 1.0);  
-                        diffuse  *= intensity;
-                        specular *= intensity;
+                        // Значение из кубической текстуры с учетом источника (i)
+                        pcfDepth = texture(pointShadowDepth, vec4(fragPosLightSpace + vec3(x, y, z)*cubemap_offset, i)).r; 
+                        if(cubemap_depth > pcfDepth)
+                            shadowValue += 1.0;
                     }
+                }
+            }
+            shadowValue /= (27);
+            if (shadowValue < 1.0)
+            {
+                // Данные об источнике относительно фрагмента
+                L_vertex = light_f.data[i].position - fragPos;
+                // Расстояние от поверхности до источника
+                L_distance = length(L_vertex);
 
-                    color += ( vec4(light_f.data[i].color*kd*diffuse  * attenuation, 1) 
-                              + vec4(light_f.data[i].color*ks*specular * attenuation, 1) )  * (1.0 - shadowValue);
+                // Проверка на дистанцию
+                if (L_distance < light_f.data[i].attenuation.r)
+                {
+                    // Нормирование вектора
+                    L_vertex = normalize(L_vertex);
+                    // арккосинус между вектором от поверхности к источнику и обратным направлением источника
+                    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);
+                        if (LDotN > 0)
+                        {
+                            // Вектор половины пути
+                            H = normalize(L_vertex + Cam_vertex);
+
+                            // Угасание с учетом расстояния
+                            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);  
+                                fd *= intensity;
+                                fs *= intensity;
+                            }
+
+                            color.rgb += (fd + fs) * light_f.data[i].color * attenuation * LDotN * (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);
         // Подключаем текстуры теней