Копия с 18

2023-06-26 08:53:07 +03:00
parent 260475a8e7
commit ba539b39d8
37 changed files with 4722 additions and 0 deletions
--- a/include/Buffers.h
+++ b/include/Buffers.h
@@ -0,0 +1,90 @@
+#ifndef BUFFERS_H
+#define BUFFERS_H
+
+#include <glad/glad.h>
+
+#include <map>
+
+// Объект массива вершин
+class VAO
+{
+    public:
+        VAO(); // Создает VAO и активирует его
+        ~VAO(); // Уничтожает VAO
+        VAO(const VAO & copy); // Конструктор копирования
+        VAO& operator=(const VAO & other); // Оператор присваивания
+
+        void use(); // Активация VAO
+        static void disable(); // Деактивация активного VAO
+
+    private:
+        GLuint handler; // Дескриптор
+        static std::map<GLuint, GLuint> handler_count; // Счетчик использований дескриптора
+};
+
+// Тип буфера
+enum BUFFER_TYPE {  VERTEX = GL_ARRAY_BUFFER
+                  , ELEMENT = GL_ELEMENT_ARRAY_BUFFER
+                  , UNIFORM = GL_UNIFORM_BUFFER
+                 };
+
+// Объект вершинного буфера
+class BO
+{
+    public:
+        BO(BUFFER_TYPE type); // Создает пустой буфер заданного типа
+        BO(BUFFER_TYPE type, const void *data, int size); // Создает и загружает туда данные
+        ~BO(); // Уничтожает буфер
+        BO(const BO & copy); // Конструктор копирования
+        BO& operator=(const BO & other); // Оператор присваивания
+
+        void load(const void *data, int size, GLuint mode = GL_STATIC_DRAW); // Загрузка данных в буфер
+        void use(); 
+
+    protected:
+        GLuint handler; // Дескриптор
+        BUFFER_TYPE type; // Тип буфера
+    private:
+        static std::map<GLuint, GLuint> handler_count; // Счетчик использований дескриптора
+};
+
+// Объект uniform-буфера
+class UBO : public BO
+{
+    public:
+        UBO(int size, int binding); // Создает пустой uniform-буфер заданного размера с автоматической привязкой
+        UBO(const void *data, int size, int binding); // Создает пустой uniform-буфер заданного размера с автоматической привязкой
+
+        void rebind(int binding); // Перепривязка
+        void loadSub(const void *data, int size, int offset = 0); // Загрузка с отступом
+};
+
+// Объект буфера кадра
+class FBO
+{
+    public:
+        FBO(GLuint *attachments = 0, int count = 0); // Создает буфер кадра с нужным числом прикреплений текстур
+        ~FBO(); // Уничтожение буфера
+
+        void use(GLuint mode = GL_FRAMEBUFFER); // Активирует буфер кадра в заданном режиме
+        static void useDefault(GLuint mode = GL_FRAMEBUFFER); // Активирует базовый буфер в заданном режиме
+        void assignRenderBuffer(GLuint hander, GLuint attachment = GL_DEPTH_ATTACHMENT); // Привязка рендер буфера
+    protected:
+        GLuint handler; // Дескриптор
+};
+
+// Объект буфера рендера
+class RBO
+{
+    public:
+        RBO(int w, int h, GLuint component = GL_DEPTH_COMPONENT); // Создает буфер рендера с заданными параметрами размеров и используемых компонент
+        ~RBO(); // Уничтожение буфера
+
+        void reallocate(int w, int h, GLuint component = GL_DEPTH_COMPONENT); // Изменяет размеры буфера рендера
+
+        GLuint getHandler(); // Возвращает дескриптор буфера рендера
+    protected:
+        GLuint handler; // Дескриптор
+};
+
+#endif // BUFFERS_H
--- a/include/Camera.h
+++ b/include/Camera.h
@@ -0,0 +1,82 @@
+#ifndef CAMERA_H
+#define CAMERA_H
+
+#include <GLM/glm.hpp>
+#include <GLM/gtx/euler_angles.hpp>
+#include <GLM/gtc/matrix_transform.hpp>
+#include <GLM/ext/matrix_transform.hpp>
+
+#include "Model.h"
+ 
+// Ближняя граница области отсечения
+#define CAMERA_NEAR 0.1f
+// Дальняя граница области отсечения
+#define CAMERA_FAR 100.0f
+// Вектор, задающий верх для камеры
+#define CAMERA_UP_VECTOR glm::vec3(0.0f, 1.0f, 0.0f)
+// Вектор, задающий стандартный поворот углами Эйлера (в положительном направлении оси Z)
+#define CAMERA_DEFAULT_ROTATION glm::vec3(0.0f, 180.0f, 0.0f)
+// Стандартный угол обзора 
+#define CAMERA_FOVy 60.0f
+// Стандартная чувствительность
+#define CAMERA_DEFAULT_SENSIVITY 0.005f
+// Количество каскадов для карт теней
+#define CAMERA_CASCADE_COUNT 4
+
+// Данные о дистанциях каскадов 
+extern const float camera_cascade_distances[]; // src/Camera.cpp
+
+// Данные о камере для шейдера
+struct CameraData
+{
+    glm::mat4 projection;
+    glm::mat4 view;
+    glm::vec3 position;
+};
+
+// Класс камеры
+class Camera : public Node
+{
+    public:
+        Camera(float aspect, const glm::vec3 &position = glm::vec3(0.0f), const glm::vec3 &initialRotation = CAMERA_DEFAULT_ROTATION, float fovy = CAMERA_FOVy); // Конструктор камеры с проекцией перспективы
+        Camera(float width, float height, const glm::vec3 &position = glm::vec3(0.0f), const glm::vec3 &initialRotation = CAMERA_DEFAULT_ROTATION); // Конструктор ортографической камеры
+        Camera(const Camera& copy); // Конструктор копирования камеры
+        Camera& operator=(const Camera& other); // Оператор присваивания
+        virtual ~Camera(); // Деструктор
+
+        const glm::mat4& getVP(); // Возвращает ссылку на константную матрицу произведения матриц вида и проекции
+        const glm::mat4& getProjection(); // Возвращает ссылку на константную матрицу проекции 
+        const glm::mat4& getView(); // Возвращает ссылку на константную матрицу вида
+        
+        void rotate(const glm::vec2 &xyOffset); // Поворачивает камеру на dx и dy пикселей с учетом чувствительности
+        
+        void setPerspective(float fov, float aspect); // Устанавливает заданную матрицу перспективы
+        void setOrtho(float width, float height); // Устанавливает заданную ортографическую матрицу
+        void setSensitivity(float sensitivity); // Изменяет чувствительность мыши
+        const float& getSensitivity() const; // Возвращает чувствительность мыши
+        
+        void use(); // Использование этой камеры как текущей
+        static Camera& current(); // Ссылка на текущую используемую камеру
+        
+        CameraData& getData(); // Данные о камере для шейдера
+        std::pair<bool, const glm::vec4(*)[8]> getProjCoords(); // Доступ к координатам с флагом изменения, описывающим пространство вида с пересчетом, если это требуется
+    protected:
+        Camera(const glm::vec3 &position, const glm::vec3 &initialRotation); // Защищенный (protected) конструктор камеры без перспективы 
+
+        glm::mat4 view; // Матрица вида
+        glm::mat4 projection; // Матрица проекции
+        glm::mat4 vp; // Матрица произведения вида и проекции
+        bool requiredRecalcVP; // Необходимость пересчета матрицы вида и проекции камеры
+        bool requiredRecalcCoords; // Необходимость пересчета точек, описывающих пространство камеры
+        glm::vec4 coords[CAMERA_CASCADE_COUNT][8]; // Координаты, описывающие пространство камеры
+        glm::mat4 cascade_proj[CAMERA_CASCADE_COUNT]; // Матрицы проекций каскадов
+
+        float sensitivity; // Чувствительность мыши
+        
+        virtual void recalcMatrices(); // Метод пересчета матрицы вида и произведения Вида*Проекции по необходимости, должен сбрасывать флаг changed
+
+        static Camera* p_current; // Указатель на текущую используемую камеру
+};      
+
+
+#endif // CAMERA_H
--- a/include/Lights.h
+++ b/include/Lights.h
@@ -0,0 +1,108 @@
+#ifndef LIGHTS_H
+#define LIGHTS_H
+
+#include <GLM/glm.hpp>
+
+#include "Model.h"
+#include "Camera.h"
+
+// Максимальное число источников света
+#define MAX_LIGHTS 64
+// Стандартное направление источника без поворота
+#define DEFAULT_LIGHT_DIRECTION glm::vec4(0.0f, 0.0f, 1.0f, 0.0f)
+// Максимальное число образцов для SSAO
+#define MAX_SSAO 64
+
+// Точечный источник света
+struct LightData 
+{
+    alignas(16) glm::vec3 position; // Позиция
+    alignas(16) glm::vec3 color; // Цвет 
+    alignas(16) glm::vec3 attenuation; // Радиус действия источника, линейный и квадратичный коэф. угасания   
+    alignas(16) glm::vec4 direction_angle; // Направление и половинный угол освещенности
+    alignas(16) glm::mat4 vp[6]; // Матрицы проекции и трансформации в пространство источника
+};
+
+// Источник света
+class Light : public Node
+{
+    public:
+        static int getUBOsize(); // Возвращает размер буфера в байтах
+        static void upload(UBO& lights_data); // Загрузка данных в буфер
+
+        static Light& getNew(); // Возвращает ссылку на новый источник света
+        void destroy(); // Уничтожает источник света
+
+        static int getCount(); // Возвращает количество источников
+        const glm::vec3& c_color() const; // Константный доступ к цвету
+        glm::vec3& e_color(); // Неконстантная ссылка для изменений цвета
+
+        const float& c_radius() const; // Константный доступ к радиусу
+        float& e_radius(); // Неконстантная ссылка для изменений радиуса
+
+        const float& c_angle() const; // Константный доступ к углу освещенности
+        float& e_angle(); // Неконстантная ссылка для изменений угла освещенности
+
+        static void render(ShaderProgram &shaderProgram, UBO &material_buffer); // Рисование отладочных лампочек
+    private:
+        Light(); // Конструктор без параметров
+        Light(const Light& copy) = delete; // Конструктор копирования ОТКЛЮЧЕН
+        Light& operator=(const Light& other); // Оператор  присваивания
+        virtual ~Light(); 
+
+        glm::vec3 color; // Цвет
+        float radius; // Радиус действия источника
+        float angle; // Угол полный освещенности 
+
+        int index; // Индекс в массиве отправки (может не совпадать с lights) для дефрагментированного доступа
+        static Light& findByIndex(GLuint index); // Возвращает ссылку на источник с нужным индексом
+
+        bool uploadReq; // Необходимость загрузки в следствии изменений
+        void check_id(); // Проверка что не взаимодествуем с пустым источником
+        void toData(); // Преобразует информацию об источнике в структуру LightData
+
+        virtual void recalcMatrices(); // Метод пересчета матрицы трансформации по необходимости, должен сбрасывать флаг changed
+        void recalcVP(); // Пересчитывает по необходимости матрицу вида-проекции
+
+        static GLuint count; // количество используемых источников (должно быть <= MAX_LIGHTS)
+        static LightData data[MAX_LIGHTS]; // Массив данных по источникам света
+        static Light lights[MAX_LIGHTS]; // Массив источников-узлов сцены
+};
+
+// Класс направленного источника освещения
+class Sun
+{
+    public:
+        static Sun& get(); // Доступ к синглтону
+        static void upload(UBO& sun_data); // Загрузка данных об источнике в буфер
+        
+        const glm::vec3& c_direction() const; // Константный доступ к направлению лучей источника
+        glm::vec3& e_direction(); // Неконстантная ссылка для изменений направления лучей источника
+
+        const glm::vec3& c_color() const; // Константный доступ к цвету
+        glm::vec3& e_color(); // Неконстантная ссылка для изменений цвета
+
+    private:
+        Sun(const glm::vec3 &direction = glm::vec3(0.0f, 1.0f, 0.0f), const glm::vec3 &color = glm::vec3(0.4f, 0.4f, 0.4f));
+        
+        alignas(16) glm::vec3 direction; // Направление лучей источника
+        alignas(16) glm::vec3 color; // Цвет
+        alignas(16) glm::mat4 vp[CAMERA_CASCADE_COUNT]; // Матрица вида-проекции источника
+
+        void recalcVP(); // Пересчитывает по необходимости матрицу вида-проекции
+        
+        static Sun instance; // Экземпляр синглтона
+        static bool uploadReq; // Необходимость загрузки в следствии изменений
+};
+
+// Данные для SSAO
+struct SSAO_data
+{
+    float radius = 0.05f;
+    float bias = 0.025f;
+    int size = MAX_SSAO;
+    alignas(16) glm::vec2 scale;
+    glm::vec3 samples[MAX_SSAO];
+};
+
+#endif // LIGHTS_H
--- a/include/Model.h
+++ b/include/Model.h
@@ -0,0 +1,121 @@
+#ifndef MODEL_H
+#define MODEL_H
+
+#include "Buffers.h"
+#include "Texture.h"
+#include "Shader.h"
+
+#include <GLM/glm.hpp>
+#include <GLM/gtc/quaternion.hpp>
+#include <GLM/gtc/matrix_transform.hpp>
+
+#include <vector>
+
+class Model genShpere(float radius, int sectorsCount, class Node* parent = NULL); // Генерирует сферу заданного радиуса с определенным количеством сегментов
+
+void calc_tb(const GLuint* indices, const int indices_count, const glm::vec3* verteces, const glm::vec2* texCords, glm::vec3* tangent, glm::vec3* bitangent); // Расчет касательных и бикасательных векторов
+
+// Класс узла сцены
+class Node 
+{
+    public:
+        Node(Node* parent = NULL); // Конструктор с заданным родителем (по умолчанию NULL)
+        Node(const Node& copy); // Конструктор копирования
+        Node& operator=(const Node& other); // Оператор присваивания
+        virtual ~Node();
+
+        void setParent(Node * parent); // Устанавливает родителя для узла
+
+        virtual const glm::mat4& getTransformMatrix(); // Возвращает матрицу трансформации модели
+        bool isChanged(); // Возвращает необходимость пересчета матрицы трансформации
+
+        const glm::vec3& c_position() const; // Константный доступ к позиции
+        const glm::quat& c_rotation() const; // Константный доступ к повороту
+        const glm::vec3& c_scale() const; // Константный доступ к масштабированию
+        virtual glm::vec3& e_position(); // Неконстантная ссылка для изменений позиции
+        virtual glm::quat& e_rotation(); // Неконстантная ссылка для изменений поворота
+        virtual glm::vec3& e_scale(); // Неконстантная ссылка для изменений масштабирования 
+
+        Node* getParent(); // Возвращает указатель на родителя
+        const std::vector<Node*>& getChildren() const; // Возвращает ссылку на вектор дочерних узлов
+
+    protected:
+        Node *parent; // Родительский узел
+        std::vector<Node*> children; // Узлы-потомки !Не должны указывать на NULL!
+
+        glm::vec3 position; // позиция модели
+        glm::quat rotation; // поворот модели
+        glm::vec3 scale;    // масштабирование модели
+
+        bool changed; // Флаг необходимости пересчета матрицы трансформации
+        glm::mat4 transform; // Матрица трансформации модели
+        bool parent_changed; // Флаг изменений у родителя - необходимость пересчета итоговой трансформации
+        glm::mat4 result_transform; // Итоговая трансформация с учетом родительской
+
+        virtual void recalcMatrices(); // Метод пересчета матрицы трансформации по необходимости, должен сбрасывать флаг changed
+        void invalidateParent(); // Проход потомков в глубину с изменением флага parent_changed
+};
+
+// Материал модели
+struct Material
+{
+    alignas(16) glm::vec3 base_color; // Базовый цвет материала
+    float roughness; // Шероховатость поверхности
+    float metallic; // Металличность поверхности
+    float specular; // Интенсивность блика диэлектриков
+    alignas(16) glm::vec3 emitted; // Излучаемый поверхностью свет
+    int normalmapped; // Использование карт нормалей
+    int parallaxmapped; // Использование параллакса
+    int displacementmapped; // Использование карт высот для сдвига вершин
+    // Значения по умолчанию
+    Material() : base_color(0.8f), roughness(0.5f), metallic(0.0f), specular(0.5f), emitted(0.0f), normalmapped(false), parallaxmapped(false), displacementmapped(false) { };
+};
+
+// Идентификатор модели
+struct ID
+{
+    GLuint64 value = 0; // Идентификатор
+    GLuint etc = 0; // Дополнительная информация
+};
+
+// Класс модели
+class Model : public Node
+{
+    public:
+        Model(Node *parent = NULL); // Конструктор по умолчанию
+        Model(const Model& copy); // Конструктор копирования
+        Model& operator=(const Model& other); // Оператор присваивания
+        virtual ~Model();
+
+        void render(); // Вызов отрисовки без uniform-данных
+        void render(ShaderProgram &shaderProgram, UBO &material_buffer); // Вызов отрисовки
+
+        void load_verteces(glm::vec3* verteces, GLuint count); // Загрузка вершин в буфер
+        void load_indices(GLuint* indices, GLuint count); // Загрузка индексов в буфер
+        void load_texCoords(glm::vec2* texCoords, GLuint count); // Загрузка текстурных координат в буфер
+        void load_normals(glm::vec3* normals, GLuint count); // Загрузка нормалей в буфер
+        void load_tangent(glm::vec3* tangent, GLuint count); // Загрузка касательных векторов в буфер
+        void load_bitangent(glm::vec3* bitangent, GLuint count); // Загрузка бикасательных векторов в буфер
+        void set_index_range(size_t first_byteOffset, size_t count); // Ограничение диапазона из буфера индексов
+        void set_texture(Texture& texture); // Привязка текстуры к модели
+        
+        Material material; // Материал модели
+
+        ID id; // ID модели
+    private:
+        VAO vao;
+        BO vertex_vbo, index_vbo; // вершинный и индексный буферы
+        BO normals_vbo, texCoords_vbo; // буферы с нормалями и текстурными координатами
+        BO tangent_vbo, bitangent_vbo; // буферы с касательными и бикасательными векторами
+        GLuint verteces_count; // Количество вершин
+        size_t first_index_byteOffset, indices_count; // Сдвиг в байтах для первого и количество индексов
+        Texture texture_albedo; // Текстура альбедо (цвет поверхности)
+        Texture texture_roughness; // Текстура шероховатостей
+        Texture texture_metallic; // Текстура металличности
+        Texture texture_specular; // Текстура интенсивности блика диэлектриков
+        Texture texture_emitted; // Текстура излучаемого света
+        Texture texture_heights; // Текстура высот
+        Texture texture_normals; // Текстура нормалей
+};
+
+#endif // MODEL_H
--- a/include/Scene.h
+++ b/include/Scene.h
@@ -0,0 +1,39 @@
+#ifndef SCENE_H
+#define SCENE_H
+
+#include <list>
+
+#include "Model.h"
+#include "Camera.h"
+
+#define DEFAULT_MTL_DIR "./"
+class Scene loadOBJtoScene(const char* filename, const char* mtl_directory = DEFAULT_MTL_DIR, const char* texture_directory = DEFAULT_MTL_DIR);
+
+// Класс сцены
+class Scene
+{
+    public:
+        Scene(); // Конструктор пустой сцены
+        Scene(const Scene &copy); // Конструктор копирования
+        Scene& operator=(const Scene& other); // Оператор присваивания
+
+        void render(ShaderProgram &shaderProgram, UBO &material_buffer); // Рендер сцены
+
+        void set_group_id(GLuint64 id, GLuint etc = 0); // Изменение флага записи идентификатора для всех моделей
+
+        Node root; // Корневой узел
+
+        // Списки объектов, выступающих узлами
+        std::list<Node> nodes; // Список пустых узлов
+        std::list<Model> models; // Список моделей для рендера
+        std::list<Camera> cameras; // Список камер
+    
+    protected:
+        void rebuld_tree(const Scene& from); // Перестройка дерева после копирования или присваивания
+        template <class T>
+        void rebuild_Nodes_list(T& nodes, const Scene& from); // Перестройка узлов выбранного списка
+        template <class T>
+        void move_parent(Node& for_node, const std::list<T>& from_nodes, std::list<T>& this_nodes); // Сдвигает родителя узла между двумя списками при условии его принадлежности к оригинальному
+};
+
+#endif // SCENE_H
--- a/include/Shader.h
+++ b/include/Shader.h
@@ -0,0 +1,30 @@
+#ifndef SHADER_H
+#define SHADER_H
+
+#include <glad/glad.h>
+
+#include <map>
+#include <string>
+
+// Класс шейдерной программы
+class ShaderProgram
+{
+    public:
+        ShaderProgram();
+        ShaderProgram(const ShaderProgram &copy);
+        ~ShaderProgram();
+        ShaderProgram& operator=(const ShaderProgram& other);
+
+        void use(); // Использование шейдеров
+        void load(GLuint type, const char* filename); // Функция для загрузки шейдеров
+        void link(); // Формирование программы из загруженных шейдеров
+        GLuint getUniformLoc(const char* name); // Возвращает местоположение uniform-переменной
+        void bindUniformBlock(const char* name, int binding); // Привязка uniform-блока
+        void bindTextures(const char* textures_base_shader_names[], int count); // Инициализация текстур на шейдере
+    private:
+        GLuint program; // Дескриптор
+        static std::map<int, int> handler_count; // Получение количества использований по дескриптору шейдера (Shared pointer)
+        std::map<const char*, GLuint> uniformLocations; // Местоположения uniform-переменных
+};
+
+#endif // SHADER_H
--- a/include/TRS.h
+++ b/include/TRS.h
@@ -0,0 +1,45 @@
+#ifndef TRS_H
+#define TRS_H
+
+#define T_SENSITIVITY 0.001f
+#define R_SENSITIVITY 0.01f
+#define S_SENSITIVITY 0.00001f
+
+#include "Scene.h"
+
+// Интерфейс инструмента
+class TRS 
+{
+    public:
+        void render(GLuint64 selectedID, ShaderProgram &shaderProgram, UBO &material_buffer); // Рендер инструмента нужного типа для выбранного объекта
+        virtual void process(GLuint64 selectedID, GLuint etc, const glm::vec4& dpos) = 0; // Взаимодействие с инструментом
+    protected:
+        void init_etc(); // Инициализирует дополнительную информацию модели
+        Scene tool; // Модель
+};
+
+// Инструмент трансформации
+class Transform : public TRS
+{
+    public: 
+        Transform();
+        virtual void process(GLuint64 selectedID, GLuint etc, const glm::vec4& dpos); // Взаимодействие с инструментом
+};
+
+// Инструмент поворота
+class Rotate : public TRS
+{
+    public: 
+        Rotate();
+        virtual void process(GLuint64 selectedID, GLuint etc, const glm::vec4& drot); // Взаимодействие с инструментом
+};
+
+// Инструмент масштабирования
+class Scale : public TRS
+{
+    public: 
+        Scale();
+        virtual void process(GLuint64 selectedID, GLuint etc, const glm::vec4& dscale); // Взаимодействие с инструментом
+};
+
+#endif // TRS_H
--- a/include/Texture.h
+++ b/include/Texture.h
@@ -0,0 +1,95 @@
+#ifndef TEXTURE_H
+#define TEXTURE_H
+
+#include <glad/glad.h>
+
+#include <map>
+#include <string>
+
+enum TexType {
+    TEX_ALBEDO,
+    TEX_ROUGHNESS,
+    TEX_METALLIC,
+    TEX_SPECULAR,
+    TEX_EMITTED,
+    TEX_HEIGHTS,
+    TEX_NORMAL,
+    TEX_AVAILABLE_COUNT
+};
+
+// Абстрактный класс базовой текстуры
+class BaseTexture
+{
+    public:
+        ~BaseTexture();
+        virtual void use() = 0; // Привязка текстуры
+        static void disable(GLuint type); // Отвязка текстуры по типу
+        GLuint getType(); // Возвращает тип текстуры
+        void setType(GLuint type); // Задает тип текстуры
+    protected:
+        GLuint handler; // Дескриптор текстуры
+        GLuint type; // Тип текстуры, соответствует её слоту
+        static std::map<std::string, int> filename_handler; // Получение дескриптора текстуры по её имени
+        static std::map<int, int> handler_count; // Получение количества использований по дескриптору текстуры (Shared pointer)
+};
+
+// Класс 2D текстуры
+class Texture : public BaseTexture
+{
+    public:
+        Texture(GLuint type = TEX_AVAILABLE_COUNT, const std::string& filename = ""); // Загрузка текстуры с диска или использование "пустой"
+        Texture(GLuint width, GLuint height, GLuint attachment, GLuint texType = TEX_ALBEDO, GLint internalformat = GL_RGBA, GLint format = GL_RGBA, GLenum dataType = GL_FLOAT); // Конструктор текстуры заданного размера для использования в буфере
+        Texture(GLuint width, GLuint height, void* data, GLuint texType = TEX_ALBEDO, GLint internalformat = GL_RGBA, GLint format = GL_RGBA, GLenum dataType = GL_FLOAT); // Конструктор текстуры заданного размера без привязки к буферу с загрузкой пикселей по указателю
+        Texture(const Texture& other); // Конструктор копирования
+
+        Texture& operator=(const Texture& other); // Оператор присваивания
+
+        void reallocate(GLuint width, GLuint height, GLuint texType = TEX_ALBEDO, GLint internalformat = GL_RGBA, GLint format = GL_RGBA, GLenum dataType = GL_FLOAT); // Пересоздает текстуру для имеющегося дескриптора
+
+        virtual void use(); // Привязка текстуры       
+};
+
+// Класс 3D текстуры
+class TextureArray : public BaseTexture
+{
+    public:
+        TextureArray(GLuint levels, GLuint width, GLuint height, GLuint attachment, GLuint texType = TEX_ALBEDO, GLint internalformat = GL_RGBA, GLint format = GL_RGBA, GLenum dataType = GL_FLOAT); // Конструктор текстуры заданного размера для использования в буфере
+        TextureArray(const TextureArray& other); // Конструктор копирования
+
+        TextureArray& operator=(const TextureArray& other); // Оператор присваивания
+
+        void reallocate(GLuint levels, GLuint width, GLuint height, GLuint texType = TEX_ALBEDO, GLint internalformat = GL_RGBA, GLint format = GL_RGBA, GLenum dataType = GL_FLOAT); // Пересоздает текстуру для имеющегося дескриптора
+
+        virtual void use(); // Привязка текстуры       
+};
+
+// Класс кубической текстуры
+class TextureCube : public BaseTexture
+{
+    public:
+        TextureCube(GLuint type = TEX_AVAILABLE_COUNT, const std::string (&filename)[6] = {""}); // Загрузка текстуры с диска или использование "пустой"
+        TextureCube(GLuint width, GLuint height, GLuint attachment, GLuint texType = TEX_ALBEDO, GLint internalformat = GL_RGBA, GLint format = GL_RGBA, GLenum dataType = GL_FLOAT); // Конструктор текстуры заданного размера для использования в буфере
+        TextureCube(const TextureCube& other); // Конструктор копирования
+
+        TextureCube& operator=(const TextureCube& other); // Оператор присваивания
+
+        void reallocate(GLuint width, GLuint height, GLuint texType = TEX_ALBEDO, GLint internalformat = GL_RGBA, GLint format = GL_RGBA, GLenum dataType = GL_FLOAT); // Пересоздает текстуру для имеющегося дескриптора
+
+        virtual void use(); // Привязка текстуры       
+};
+
+// Класс 3D кубической текстуры
+class TextureCubeArray : public BaseTexture
+{
+    public:
+        TextureCubeArray(GLuint levels, GLuint width, GLuint height, GLuint attachment, GLuint texType = TEX_ALBEDO, GLint internalformat = GL_RGBA, GLint format = GL_RGBA, GLenum dataType = GL_FLOAT); // Конструктор текстуры заданного размера для использования в буфере
+        TextureCubeArray(const TextureCubeArray& other); // Конструктор копирования
+
+        TextureCubeArray& operator=(const TextureCubeArray& other); // Оператор присваивания
+
+        void reallocate(GLuint levels, GLuint width, GLuint height, GLuint texType = TEX_ALBEDO, GLint internalformat = GL_RGBA, GLint format = GL_RGBA, GLenum dataType = GL_FLOAT); // Пересоздает текстуру для имеющегося дескриптора
+
+        virtual void use(); // Привязка текстуры       
+};
+
+#endif // TEXTURE_H