.vscode/c_cpp_properties.json

@@ -12,7 +12,8 @@
             ],
             "compilerPath": "C:/MinGW/bin/g++.exe",
             "cStandard": "c11",
-            "cppStandard": "c++11"
+            "cppStandard": "c++11",
+            "intelliSenseMode": "gcc-x86"
         }
     ],
     "version": 4

include/Model.h

@@ -63,11 +63,8 @@ struct Material
     alignas(16) glm::vec3 kd; // коэф. диффузного отражения (цвет объекта)
     alignas(16) glm::vec3 ks; // коэф. зеркального блика
     float p; // показатель глянцевости
-    int normalmapped; // Использование карт нормалей
-    int parallaxmapped; // Использование параллакса
-    int displacementmapped; // Использование карт высот для сдвига вершин
     // Значения по умолчанию
-    Material() : ka(0.2f), kd(0.2f), ks(0.2f), p(1), normalmapped(false), parallaxmapped(false), displacementmapped(false) { };
+    Material() : ka(0.2f), kd(0.2f), ks(0.2f), p(1) { };
 };
 
 // Класс модели

shaders/bulb.frag

@@ -6,9 +6,6 @@ layout(std140, binding = 1) uniform Material
     vec3 kd;
     vec3 ks;
     float p;
-    bool normalmapped;
-    bool parallaxmapped;
-    bool displacementmapped;
 };
 
 in vec3 pos_local;

shaders/gshader.frag

@@ -6,9 +6,6 @@ layout(std140, binding = 1) uniform Material
     vec3 kd;
     vec3 ks;
     float p;
-    bool normalmapped;
-    bool parallaxmapped;
-    bool displacementmapped;
 };
 
 layout (location = 0) out vec3 gPosition;
@@ -21,7 +18,6 @@ in vec3 N; // Нормаль трансформированноая
 in vec2 texCoord; // Текстурные координаты
 in vec3 T; // Касательный вектор
 in vec3 B; // Бикасательный вектор
-in vec3 view; // Вектор от поверхности к камере
 
 uniform sampler2D tex_diffuse;
 uniform sampler2D tex_ambient;
@@ -29,78 +25,20 @@ uniform sampler2D tex_specular;
 uniform sampler2D tex_heights;
 uniform sampler2D tex_normal;
 
-uniform float parallax_heightScale = 0.1;
-
 void main()
 {    
     // Сформируем TBN матрицу
     mat3 TBN = mat3(T, B, N);
-    // Перевод вектора в касательное пространство
-    vec3 viewTBN = normalize(transpose(TBN) * view);
-    // Измененные текстурные координаты
-    vec2 new_texCoord = texCoord;
-
     // Сохранение позиции фрагмента в G-буфере
     gPosition = vertex;
-
-    if (parallaxmapped)
-    {
-        // Число слоев
-        float layersCount = 32;  
-        // Вычислим размер каждого слоя
-        float layerDepth = 1.0 / layersCount;
-        // Глубина текущего слоя
-        float currentLayerDepth = 0.0;
-        // Величина сдвига между слоями
-        vec2 deltaTexCoords = (parallax_heightScale * viewTBN.xy / viewTBN.z) / layersCount;
-    
-        // Переменные для вычислений
-        vec2  currentTexCoords     = texCoord;
-        float currentDepthMapValue = 1.0 - texture(tex_heights, currentTexCoords).r;
-        
-        // Пока глубина текущего слоя меньше текущего значения глубины из текстуры 
-        while(currentLayerDepth < currentDepthMapValue)
-        {
-            // Сдвигаем координаты
-            currentTexCoords -= deltaTexCoords;
-            // Обновляем значение глубины из текстуры
-            currentDepthMapValue = 1.0 - texture(tex_heights, currentTexCoords).r;  
-            // Сдвигаем глубину на следующий слой
-            currentLayerDepth += layerDepth;  
-        }
-        
-        // Получим значение текстурных координат с предыдущего шага
-        vec2 prevTexCoords = currentTexCoords + deltaTexCoords;
-
-        // Значения глубины до и после пересечения
-        float afterDepth  = currentDepthMapValue - currentLayerDepth;
-        float beforeDepth = 1.0 - texture(tex_heights, prevTexCoords).r - currentLayerDepth + layerDepth;
-    
-        // Интерполяция текстурных координат
-        float weight = afterDepth / (afterDepth - beforeDepth);
-        new_texCoord = prevTexCoords * weight + currentTexCoords * (1.0 - weight);
-
-        // Проверка диапазона [0;1]
-        if(new_texCoord.x > 1.0 || new_texCoord.y > 1.0 || new_texCoord.x < 0.0 || new_texCoord.y < 0.0)
-            discard;
-    }
-
     // Сохранение нормали в G-буфере
     gNormal = N;
-    // Если используется карта нормалей
-    if (normalmapped)
-    {
-        // Получим значение из карты нормалей и приведем их к диапазону [-1;1]
-        gNormal = texture(tex_normal, new_texCoord).rgb * 2 - 1.0f;  
-        gNormal = normalize(TBN * gNormal); // Из касательного пространства в мировые координаты
-    }
-
     // Сохранение диффузного цвета
-    gDiffuseP.rgb = texture(tex_diffuse, new_texCoord).rgb * kd;
+    gDiffuseP.rgb = texture(tex_diffuse, texCoord).rgb * kd;
     // Сохранение глянцевости
     gDiffuseP.a = p;
     // Сохранение фоновой составляющей
-    gAmbientSpecular.rgb = texture(tex_ambient, new_texCoord).rgb * ka;
+    gAmbientSpecular.rgb = texture(tex_ambient, texCoord).rgb * ka;
     // Сохранение зеркальной составляющей
-    gAmbientSpecular.a = texture(tex_specular, new_texCoord).r * ks.r;
+    gAmbientSpecular.a = texture(tex_specular, texCoord).r * ks.r;
 }

shaders/gshader.vert

@@ -13,20 +13,6 @@ layout(std140, binding = 0) uniform Camera
     vec3 position;
 } camera;
 
-layout(std140, binding = 1) uniform Material
-{
-    vec3 ka;
-    vec3 kd;
-    vec3 ks;
-    float p;
-    bool normalmapped;
-    bool parallaxmapped;
-    bool displacementmapped;
-};
-
-uniform sampler2D tex_heights;
-uniform float displacement_heightScale = 0.1;
-
 uniform mat4 model;
 
 out vec3 vertex; // Позиция вершины в пространстве
@@ -34,7 +20,6 @@ out vec3 N; // Нормаль трансформированноая
 out vec2 texCoord; // Текстурные координаты
 out vec3 T; // Касательный вектор
 out vec3 B; // Бикасательный вектор
-out vec3 view; // Вектор от поверхности к камере
 
 void main() 
 { 
@@ -48,13 +33,5 @@ void main()
     T = normalize(mat3(model) * tangent);
     B = normalize(mat3(model) * bitangent);
 
-    view = camera.position - vertex;
-
-    if (displacementmapped)
-    {
-        float height = texture(tex_heights, texCoord).r * displacement_heightScale;
-        P.xyz += mat3(T, B, N) * vec3(0, 0, height);
-    }
-    
     gl_Position = camera.projection * camera.view * P;
 } 

src/main.cpp

@@ -322,21 +322,61 @@ int main(void)
     ssaoBlurShader.link();
 
     // Модель прямоугольника
-    Scene rectangle = loadOBJtoScene("../resources/models/plane2.obj", "../resources/models/", "../resources/textures/"); 
-    
+    Model rectangle; 
+
+    // Вершины прямоугольника
+    glm::vec3 rectangle_verticies[] = {  {-0.5f, 0.0f, -0.5f}
+                                       , { 0.5f, 0.0f, -0.5f}
+                                       , { 0.5f, 0.0f,  0.5f}
+                                       , {-0.5f, 0.0f,  0.5f}
+                                    };
+    // Загрузка вершин модели
+    rectangle.load_verteces(rectangle_verticies, sizeof(rectangle_verticies)/sizeof(glm::vec3));
+
+    // индексы вершин
+    GLuint rectangle_indices[] = {0, 1, 2, 2, 3, 0}; 
+    // Загрузка индексов модели
+    rectangle.load_indices(rectangle_indices, sizeof(rectangle_indices)/sizeof(GLuint));
+
+    // Нормали
+    glm::vec3 rectangle_normals[] = {  {0.0f, 1.0f, 0.0f}
+                                     , {0.0f, 1.0f, 0.0f}
+                                     , {0.0f, 1.0f, 0.0f}
+                                     , {0.0f, 1.0f, 0.0f}
+                                    };
+    // Загрузка нормалей модели
+    rectangle.load_normals(rectangle_normals, sizeof(rectangle_normals)/sizeof(glm::vec3));
+
     // Зададим горизонтальное положение перед камерой
-    rectangle.root.e_position().y = -1;
-    rectangle.root.e_position().z = 2;
-    rectangle.root.e_rotation() = glm::quat(0.707f, 0.707f, 0.0f, 0.0f);
-    rectangle.root.e_scale() = glm::vec3(4);
+    rectangle.e_position().y = -1;
+    rectangle.e_position().z = 2;
+    rectangle.e_scale() = glm::vec3(4);
+
+    // Параметры материала
+    rectangle.material.ka = {0.05, 0.05, 0.05};
+    rectangle.material.kd = {1, 1, 1};
 
     // Текстуры для прямоугольника
     Texture rectangle_diffuse(TEX_DIFFUSE, "../resources/textures/rekovalev_diffusemap.png");
-    rectangle.models.begin()->set_texture(rectangle_diffuse);
+    rectangle.set_texture(rectangle_diffuse);
     Texture rectangle_normal(TEX_NORMAL, "../resources/textures/rekovalev_normalmap.png");
-    rectangle.models.begin()->set_texture(rectangle_normal);
+    rectangle.set_texture(rectangle_normal);
     Texture rectangle_heights(TEX_HEIGHTS, "../resources/textures/rekovalev_bumpmap.png");
-    rectangle.models.begin()->set_texture(rectangle_heights);
+    rectangle.set_texture(rectangle_heights);
+
+    // Текстурные координаты
+    glm::vec2 rectangle_texCoord[] = {  { 1.0f,  0.0f }
+                                      , { 1.0f,  1.0f }
+                                      , { 0.0f,  1.0f }
+                                      , { 0.0f,  0.0f }
+                                     };
+    rectangle.load_texCoords(rectangle_texCoord, sizeof(rectangle_texCoord)/sizeof(glm::vec2));
+
+    // Касательные и бикасательные векторы
+    glm::vec3 rectangle_tangent[4], rectangle_bitangent[4];
+    calc_tb(rectangle_indices, 6, rectangle_verticies, rectangle_texCoord, rectangle_tangent, rectangle_bitangent);
+    rectangle.load_tangent(rectangle_tangent, 4);
+    rectangle.load_bitangent(rectangle_bitangent, 4);
 
     // Шейдер для рисования отладочных лампочек
     ShaderProgram bulbShader;