shaders/lighting.frag

@@ -35,14 +35,12 @@ uniform float camera_cascade_distances[4]; // Размер массива дол
 
 uniform sampler2D gPosition;
 uniform sampler2D gNormal;
-uniform sampler2D gBaseColor;
+uniform sampler2D gDiffuseP;
-uniform sampler2D gRMS;
+uniform sampler2D gAmbientSpecular;
-uniform sampler2D gEmittedColor;
 uniform sampler2DArray sunShadowDepth;
 uniform samplerCubeArray pointShadowDepth;
 uniform sampler2D ssao;
 uniform usampler2D gID;
-uniform samplerCube reflections;
 
 uniform uvec3 selectedID;
 
@@ -53,68 +51,25 @@ 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 = normalize(texture(gNormal, texCoord).rgb);
+    vec3 N = texture(gNormal, texCoord).rgb;
-    vec3 base_color = texture(gBaseColor, texCoord).rgb;
+    vec3 kd = texture(gDiffuseP, texCoord).rgb;
-    float roughness = texture(gRMS, texCoord).r;
+    vec3 ka = texture(gAmbientSpecular, texCoord).rgb;
-    float metallic = texture(gRMS, texCoord).g;
+    float ks = texture(gAmbientSpecular, texCoord).a;
-    float specular = texture(gRMS, texCoord).b;
+    float p = texture(gDiffuseP, texCoord).a;
     float ssao_value = texture(ssao, texCoord).r;
     
     // Переменные используемые в цикле:
-    vec3 L_vertex; // Расположение источника относительно фрагмента
+    vec3 L_vertex; // Данные об источнике относительно фрагмента
-    float L_distance; // Расстояние от поверхности до источника
+    vec3 Cam_vertex = normalize(camera.position - fragPos); // Данные о камере относительно фрагмента
-    vec3 Cam_vertex = normalize(camera.position - fragPos); // Расположение камеры относительно фрагмента
+    float diffuse; // Диффузная составляющая
-    vec3 ks; // Интенсивность зеркального отражения
-    vec3 fd, fs; // Диффузное и зеркальное отражения
     vec3 H; // Вектор половины пути
-    float attenuation; // Угасание с учетом расстояния
+    float specular; // Зеркальная составляющая
+    float L_distance; // Расстояние от поверхности до источника
+    float attenuation; // Коэф. угасания
     float acosA; // Косинус между вектором от поверхности к источнику и обратным направлением источника
     float intensity; // Интенсивность для прожектора
     vec3 fragPosLightSpace; // Фрагмент в пространстве источника
@@ -127,8 +82,6 @@ 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++)
@@ -136,27 +89,7 @@ void main()
             break;
 
     // Фоновая освещенность
-    color = vec4(texture(gEmittedColor, texCoord).rgb, 1);
+    color = vec4(ka, 1) * ssao_value;
-    
-    // Если у модели есть нормаль
-    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)
@@ -169,7 +102,6 @@ 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)
@@ -178,28 +110,22 @@ void main()
                 shadowValue += fragPosLightSpace.z > pcfDepth  ? 1.0 : 0.0;        
             }
         }
-            shadowValue /= 9.0;
+        shadowValue /= 9;
         // Рассчитываем освещенность, если значение тени меньше 1
         if (shadowValue < 1.0)
         {
             // Данные об источнике относительно фрагмента
             L_vertex = normalize(sun.direction);
-                LDotN = dot(L_vertex,N);
+            // Диффузная составляющая
-                if (LDotN > 0)
+            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
-                    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);
+            color += (  vec4(sun.color*kd*diffuse,  1)  
-                }
+                      + vec4(sun.color*ks*specular, 1) ) * (1.0 - shadowValue);
         }
     }
 
@@ -214,7 +140,7 @@ void main()
         // Дистанция между фрагментом и источником в диапазоне [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);
+        cubemap_depth -= max(0.05 * (1.0 - dot(N, light_f.data[i].direction_angle.xyz)), 0.005);
         for(x = -1; x <= 1; ++x)
         {
             for(y = -1; y <= 1; ++y)
@@ -233,6 +159,7 @@ void main()
         {
             // Данные об источнике относительно фрагмента
             L_vertex = light_f.data[i].position - fragPos;
+
             // Расстояние от поверхности до источника
             L_distance = length(L_vertex);
             
@@ -242,44 +169,38 @@ void main()
                 // Нормирование вектора
                 L_vertex = normalize(L_vertex);
                 // арккосинус между вектором от поверхности к источнику и обратным направлением источника
-                    acosA = degrees(acos(dot(-L_vertex, normalize(light_f.data[i].direction_angle.rgb))));
+                acosA = degrees(acos(dot(-L_vertex, normalize(light_f.data[i].direction_angle.xyz))));
                 // Если угол меньше угла источника или угол источника минимален, то считаем освещенность
                 if(acosA <= light_f.data[i].direction_angle.a) 
                 {
-                        LDotN = dot(L_vertex,N);
+                    // Диффузная составляющая
-                        if (LDotN > 0)
+                    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);
 
-                            // Зеркальное отражение
-                            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;
+                        diffuse  *= intensity;
-                                fs *= intensity;
+                        specular *= intensity;
                     }
 
-                            color.rgb += (fd + fs) * light_f.data[i].color * attenuation * LDotN * (1.0 - shadowValue);
+                    color += ( vec4(light_f.data[i].color*kd*diffuse  * attenuation, 1) 
-                        }
+                              + vec4(light_f.data[i].color*ks*specular * attenuation, 1) )  * (1.0 - shadowValue);
-                    }
                 }
             }
         }
     }
 
     // Применение гамма-коррекции
-    color.rgb = pow(color.rgb * ssao_value, vec3(inv_gamma));
+    color.rgb = pow(color.rgb, vec3(inv_gamma));
 
     vec3 ID = texture(gID, texCoord).rgb;
     // Обводка выбранного объекта

src/Texture.cpp

@@ -320,14 +320,12 @@ 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_MIPMAP_LINEAR); 
+    glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_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", "reflections"};
+    const char* gtextures_shader_names[]  = {"gPosition", "gNormal", "gBaseColor", "gRMS", "sunShadowDepth", "pointShadowDepth", "ssao", "gID", "gEmittedColor"};
     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,10 +451,6 @@ int main(void)
     Scale scale;
     TRS& currentTool = transform; 
 
-    // Текстура для отражений скайбокса
-    TextureCube reflections_texture(skybox_texture);
-    reflections_texture.setType(9);
-
     // Пока не произойдет событие запроса закрытия окна
     while(!glfwWindowShouldClose(window))
     {
@@ -562,7 +558,6 @@ int main(void)
         gRMS.use();
         gID.use();
         gEmittedColor.use();
-        reflections_texture.use();
         // Идентификатор выбранного объекта для обводки
         glUniform3uiv(lightShader.getUniformLoc("selectedID"), 1, (GLuint*) &selected);
         // Подключаем текстуры теней