Копия проекта с репозитория 05

.gitignore

@@ -12,23 +12,14 @@
 *.gch
 *.pch
 
-# Compiled Dynamic libraries
-*.so
-*.dylib
-*.dll
-
 # Fortran module files
 *.mod
 *.smod
 
-# Compiled Static libraries
-*.lai
-*.la
-*.a
-*.lib
-
 # Executables
 *.exe
 *.out
 *.app
 
+# SPIR-V shaders
+*.spv

.vscode/c_cpp_properties.json

@@ -0,0 +1,18 @@
+{
+    "configurations": [
+        {
+            "name": "some_name",
+            "includePath": [
+                "${workspaceFolder}/include",
+                "C:/VulkanSDK/1.2.189.2/Include",
+                "${workspaceFolder}/../dependencies/GLFW/include",
+                "${workspaceFolder}/../dependencies/glm"
+            ],
+            "compilerPath": "C:/MinGW/bin/g++.exe",
+            "cStandard": "c11",
+            "cppStandard": "c++11",
+            "intelliSenseMode": "gcc-x86"
+        }
+    ],
+    "version": 4
+}

.vscode/settings.json

@@ -0,0 +1,50 @@
+{
+    "files.associations": {
+        "vector": "cpp",
+        "array": "cpp",
+        "atomic": "cpp",
+        "*.tcc": "cpp",
+        "cctype": "cpp",
+        "clocale": "cpp",
+        "cmath": "cpp",
+        "cstdarg": "cpp",
+        "cstddef": "cpp",
+        "cstdint": "cpp",
+        "cstdio": "cpp",
+        "cstdlib": "cpp",
+        "cwchar": "cpp",
+        "cwctype": "cpp",
+        "deque": "cpp",
+        "unordered_map": "cpp",
+        "exception": "cpp",
+        "algorithm": "cpp",
+        "functional": "cpp",
+        "iterator": "cpp",
+        "memory": "cpp",
+        "memory_resource": "cpp",
+        "numeric": "cpp",
+        "random": "cpp",
+        "string": "cpp",
+        "system_error": "cpp",
+        "tuple": "cpp",
+        "type_traits": "cpp",
+        "utility": "cpp",
+        "fstream": "cpp",
+        "initializer_list": "cpp",
+        "iosfwd": "cpp",
+        "iostream": "cpp",
+        "istream": "cpp",
+        "limits": "cpp",
+        "new": "cpp",
+        "ostream": "cpp",
+        "sstream": "cpp",
+        "stdexcept": "cpp",
+        "streambuf": "cpp",
+        "typeinfo": "cpp",
+        "cstring": "cpp",
+        "list": "cpp",
+        "unordered_set": "cpp",
+        "map": "cpp",
+        "set": "cpp"
+    }
+}

.vscode/tasks.json

@@ -0,0 +1,41 @@
+{
+    "tasks": [
+        {
+            "type": "cppbuild",
+            "label": "C/C++: g++.exe сборка активного файла",
+            "command": "C:/MinGW/bin/g++.exe",
+            "args": [
+                "-fdiagnostics-color=always",
+                "${workspaceRoot}/src/*.cpp",
+
+                "-I${workspaceRoot}/include",
+
+                "--std=c++11",
+                
+                "-IC:/VulkanSDK/1.2.189.2/Include",
+                "-LC:/VulkanSDK/1.2.189.2/Lib32",
+
+                "-I${workspaceRoot}/../dependencies/GLFW/include",
+                "-I${workspaceRoot}/../dependencies/glm",
+                "-L${workspaceRoot}/../dependencies/GLFW/lib-mingw",
+                "-static",
+                "-lvulkan-1",
+                "-lglfw3dll",
+                "-o",
+                "${workspaceRoot}/${workspaceFolderBasename}.exe"
+            ],
+            "options": {
+                "cwd": "${fileDirname}"
+            },
+            "problemMatcher": [
+                "$gcc"
+            ],
+            "group": {
+                "kind": "build",
+                "isDefault": true
+            },
+            "detail": "Задача создана отладчиком."
+        }
+    ],
+    "version": "2.0.0"
+}

include/PhysicalDevice.h

@@ -0,0 +1,17 @@
+#ifndef PHYSICALDEVICE_H
+#define PHYSICALDEVICE_H
+
+#include <vulkan/vulkan.h>
+
+#include <vector>
+
+typedef struct _PhysicalDevice
+{
+    VkPhysicalDevice device; // устройство
+    VkPhysicalDeviceProperties properties; // параметры 
+    VkPhysicalDeviceFeatures features; // функции 
+    VkPhysicalDeviceMemoryProperties memory; // память
+    std::vector<VkQueueFamilyProperties> queueFamilyProperties; // семейства очередей
+} PhysicalDevice;
+
+#endif // PHYSICALDEVICE_H

include/Queue.h

@@ -0,0 +1,13 @@
+#ifndef QUEUE_H
+#define QUEUE_H
+
+#include <vulkan/vulkan.h>
+
+typedef struct _Queue
+{
+    uint32_t index;
+    VkQueue descriptor;
+    VkQueueFamilyProperties properties;
+} Queue;
+
+#endif // QUEUE_H

include/Surface.h

@@ -0,0 +1,21 @@
+#ifndef SURFACE_H
+#define SURFACE_H
+
+#include <vulkan/vulkan.h>
+
+#include <vector>
+
+typedef struct _Surface
+{
+    VkSurfaceKHR surface; // Поверхность окна
+    VkSurfaceCapabilitiesKHR capabilities; // общая информация
+    std::vector<VkSurfaceFormatKHR> formats; // формат поверхности
+    std::vector<VkPresentModeKHR> presentModes; // режим показа
+    // Данные о списке показа
+    VkSurfaceFormatKHR selectedFormat; // выбранный формат поверхности
+    VkPresentModeKHR selectedPresentMode; // выбранный режим показа
+    VkExtent2D selectedExtent; // выбранное разрешение
+    uint32_t imageCount; // количество изображений
+} Surface;
+
+#endif // SURFACE_H

include/Vertex.h

@@ -0,0 +1,12 @@
+#ifndef VERTEX_H
+#define VERTEX_H
+
+#include <GLM/glm.hpp>
+
+typedef struct _Vertex
+{
+    glm::vec2 position;
+    glm::vec3 color;    
+} Vertex;
+
+#endif // VERTEX_H

include/macroses.h

@@ -0,0 +1 @@
+#define CLAMP(min, value, max) (value > min) ? min : (max < value) ? max : value;

include/vk.h

@@ -0,0 +1,58 @@
+#ifndef VK_H
+#define VK_H
+
+#include <vulkan/vulkan.h>
+#include <GLFW/glfw3.h>
+
+#include "PhysicalDevice.h"
+#include "Surface.h"
+#include "Queue.h"
+
+class Vulkan
+{
+    public:
+        void init(GLFWwindow* window); // инициализация 
+        void destroy(); // завершение работы
+    private:
+        VkInstance instance; // Экземпляр Vulkan
+        PhysicalDevice physicalDevice; // Физическое устройство
+        VkDevice logicalDevice; // логическое устройство
+        Queue queue; // очередь
+        Surface surface; // Поверхность окна
+        VkSwapchainKHR swapChain; // Список показа
+        std::vector<VkImage> swapChainImages; // Изображения из списка показа
+        std::vector<VkImageView> swapChainImageViews; // Информация об изображениях из списка показа
+        VkRenderPass renderPass; // Проходы рендера
+        VkPipelineLayout pipelineLayout; // Раскладка конвейера
+        VkPipeline graphicsPipeline; // Графический конвейер
+        VkCommandPool commandPool; // Пул команд
+        std::vector<VkCommandBuffer> commandBuffers; // Буферы команд
+        VkBuffer vertexBuffer; // Буфер вершин
+        VkDeviceMemory vertexBufferMemory; // Память буфера вершин
+        VkBuffer indexBuffer; // Буфер индексов
+        VkDeviceMemory indexBufferMemory; // Память буфера индексов
+
+        // Структура для хранения флагов
+        struct 
+        {
+            const bool VALIDATION = true; // Использование слоев проверки
+        } states;
+
+        
+        void createInstance(); // Создание экземпяра Vulkan
+        void selectPhysicalDevice(std::vector<const char*> &deviceExtensions); // Выбор физического устройства
+        void pickQueues(); // Выбор очередей
+        void createLogicalDevice(std::vector<const char*> &deviceExtensions); // Создание логического устройства
+        void createWindowSurface(GLFWwindow* window); // Создание поверхности окна
+        void createSwapchain(GLFWwindow* window); // Создание цепочки показа
+        void createRenderpass(); // Создание проходов рендера
+        VkShaderModule createShaderModule(const char * filename); // Создание шейдерного модуля
+        void createGraphicPipeline(); // Создание графического конвеера
+        void createBuffer(VkDeviceSize size, VkBufferUsageFlags usage, VkMemoryPropertyFlags properties, VkBuffer& buffer, VkDeviceMemory& bufferMemory); // Создание произвольного буфера данных
+        void createCommandPool(); // Создание пула команд
+        void copyBuffer(VkBuffer srcBuffer, VkBuffer dstBuffer, VkDeviceSize size); // Копирование между буферами данных
+        void createVertexBuffer(); // Создание буфера вершин
+        void createIndexBuffer(); // Создание буфера индексов
+};  
+
+#endif // VK_H

shaders/shader.frag

@@ -0,0 +1,9 @@
+#version 450
+
+layout(location = 0) in vec3 fragColor;
+
+layout(location = 0) out vec4 outColor;
+
+void main() {
+    outColor = vec4(fragColor, 1.0);
+}

shaders/shader.vert

@@ -0,0 +1,11 @@
+#version 450
+
+layout(location = 0) in vec2 inPosition;
+layout(location = 1) in vec3 inColor;
+
+layout(location = 0) out vec3 fragColor;
+
+void main() {
+    gl_Position = vec4(inPosition, 0.0, 1.0);
+    fragColor = inColor;
+}

src/main.cpp

@@ -0,0 +1,53 @@
+#include "vk.h"
+
+
+#include <iostream>
+
+void vkInit();
+
+int main(int argc, char* argv[]) {
+
+    // Инициализация GLFW
+    glfwInit(); 
+
+    // Проверка доступности Vulkan
+    if (glfwVulkanSupported())
+    {
+        // объект класса-обертки Vulkan API
+        Vulkan vulkan;
+
+        // Отключим создание контекста
+        glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
+        // Отключим возможность изменения размеров окна
+        glfwWindowHint(GLFW_RESIZABLE, GLFW_FALSE);
+        // Создание окна
+        GLFWwindow* window = glfwCreateWindow(800, 600, "Vulkan window", nullptr, nullptr);
+
+        // Инициализация Vulkan API
+        vulkan.init(window);
+
+        // Жизненный цикл
+        while(!glfwWindowShouldClose(window)) {
+            // Обработка событий
+            glfwPollEvents();
+        }
+
+        // Уничтожение окна
+        glfwDestroyWindow(window);
+        
+        // Завершение работы с Vulkan
+        vulkan.destroy();
+    }
+    else
+        std::cout << "There is no Vulkan Supported\n";
+
+    // Завершение работы с GLFW
+    glfwTerminate();
+
+    return 0;
+}
+
+
+
+
+

src/vk.cpp

@@ -0,0 +1,922 @@
+#include "vk.h"
+#include "Vertex.h"
+
+#include <iostream>
+#include <vector>
+#include <stdexcept>
+
+#include "macroses.h"
+
+// инициализация 
+void Vulkan::init(GLFWwindow* window)
+{
+    createInstance(); // Создание экземпяра 
+    createWindowSurface(window); // Создание поверхности
+    // Расширения для устройства: имена задаются внутри фигурных скобок в кавычках
+    std::vector<const char*> deviceExtensions({"VK_KHR_swapchain"});
+    selectPhysicalDevice(deviceExtensions); // Выбор физического устройства
+    createLogicalDevice(deviceExtensions); // Создание физического устройства
+    createSwapchain(window); // Создание списка показа
+    createRenderpass(); // Создание проходов рендера
+    createGraphicPipeline(); // Создание графического конвейера
+    createCommandPool(); // Создание пула команд
+    createVertexBuffer(); // Создание буфера вершин
+    createIndexBuffer(); // Создание буфера индексов
+}
+
+// завершение работы
+void Vulkan::destroy()
+{
+    vkDestroyBuffer(logicalDevice, indexBuffer, nullptr); // Уничтожение буфера индексов
+    vkFreeMemory(logicalDevice, indexBufferMemory, nullptr); // Освобождение памяти буфера индексов
+
+    vkDestroyBuffer(logicalDevice, vertexBuffer, nullptr); // Уничтожение буфера вершин
+    vkFreeMemory(logicalDevice, vertexBufferMemory, nullptr); // Освобождение памяти буфера вершин
+
+    vkDestroyCommandPool(logicalDevice, commandPool, nullptr); // Уничтожение командного пула
+    
+    vkDestroyPipeline(logicalDevice, graphicsPipeline, nullptr); // Уничтожение графического конвейера
+    vkDestroyPipelineLayout(logicalDevice, pipelineLayout, nullptr); // Уничтожение раскладки графического конвейера
+    vkDestroyRenderPass(logicalDevice, renderPass, nullptr); // Уничтожение проходов рендера
+
+    // Уничтожение информации о изображениях списка показа
+    for (auto & imageView : swapChainImageViews) 
+    {
+        vkDestroyImageView(logicalDevice, imageView, nullptr);
+    }
+    
+    vkDestroySwapchainKHR(logicalDevice, swapChain, nullptr); // уничтожение цепочки показа
+    vkDestroySurfaceKHR(instance, surface.surface, nullptr); // уничтожение поверхности
+    vkDestroyDevice(logicalDevice, nullptr); // Уничтожение логического устройства
+    vkDestroyInstance(instance, nullptr); // Уничтожение экземпляра Vulkan
+}
+
+#include <cstring>
+// Проверка слоев на доступность. Возвращает true, если все слои доступны
+// по ссылке заполняет вектор недоступных слоев
+bool checkValidationLayerSupport(std::vector <const char*> requestedLayers, std::vector <const char*> & unavailableLayers)
+{
+    bool layerAvailable; // флаг доступности слоя для цикла
+
+    // Первым вызовом определим кол-во доступных слоев
+    uint32_t layerCount;
+    vkEnumerateInstanceLayerProperties(&layerCount, nullptr);
+
+    // Вторым вызовом запишем в вектор доступные слои
+    std::vector<VkLayerProperties> availableLayers(layerCount);
+    vkEnumerateInstanceLayerProperties(&layerCount, availableLayers.data());
+
+    // Цикл по запрошенным слоям
+    for (const char* layerName : requestedLayers) 
+    {
+       layerAvailable = false;
+
+        // Цикл по доступным слоям
+        for (const auto& layerProperties : availableLayers) 
+        {
+            // Сравнение строк
+            if (strcmp(layerName, layerProperties.layerName) == 0) 
+            {
+                layerAvailable = true;
+                break;
+            }
+        }
+
+        // Если слой не найден то заносим в массив недоступных
+        if (!layerAvailable) {
+            unavailableLayers.push_back(layerName);
+        }
+    }
+
+    return unavailableLayers.size() == 0;
+}
+
+// Проверка слоев устройства на доступность. Возвращает true, если все слои доступны
+// по ссылке заполняет вектор недоступных слоев
+bool checkDeviceLayerSupport(VkPhysicalDevice physicalDevice, std::vector <const char*> requestedLayers, std::vector <const char*> & unavailableLayers)
+{
+    bool layerAvailable; // флаг доступности слоя для цикла
+
+    // Первым вызовом определим кол-во доступных слоев
+    uint32_t layerCount;
+    vkEnumerateDeviceLayerProperties(physicalDevice, &layerCount, nullptr);
+
+    // Вторым вызовом запишем в вектор доступные слои
+    std::vector<VkLayerProperties> availableLayers(layerCount);
+    vkEnumerateDeviceLayerProperties(physicalDevice, &layerCount, availableLayers.data());
+
+    // Цикл по запрошенным слоям
+    for (const char* layerName : requestedLayers) 
+    {
+       layerAvailable = false;
+
+        // Цикл по доступным слоям
+        for (const auto& layerProperties : availableLayers) 
+        {
+            // Сравнение строк
+            if (strcmp(layerName, layerProperties.layerName) == 0) 
+            {
+                layerAvailable = true;
+                break;
+            }
+        }
+
+        // Если слой не найден то заносим в массив недоступных
+        if (!layerAvailable) {
+            unavailableLayers.push_back(layerName);
+        }
+    }
+
+    return unavailableLayers.size() == 0;
+}
+
+void Vulkan::createInstance()
+{
+    // Структура с данными о приложении
+    VkApplicationInfo appInfo{};
+    appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO; 
+    appInfo.pApplicationName = "Vulkan Notes";
+    appInfo.applicationVersion = VK_MAKE_VERSION(1, 0, 0);
+    appInfo.pEngineName = "No Engine";
+    appInfo.engineVersion = VK_MAKE_VERSION(1, 0, 0);
+    appInfo.apiVersion = VK_API_VERSION_1_0;
+
+    // Структура с данными 
+    VkInstanceCreateInfo createInfo{};
+    createInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
+    createInfo.pApplicationInfo = &appInfo;
+
+    // Расширения для glfw
+    uint32_t glfwExtensionCount = 0;
+    const char** glfwExtensions;
+    glfwExtensions = glfwGetRequiredInstanceExtensions(&glfwExtensionCount);
+    // Инициализируем вектор расширений тем, что требуется для glfw
+    std::vector<const char*> extensions(glfwExtensions, glfwExtensions + glfwExtensionCount);
+
+    // Подключение других расширений
+    // extensions.push_back(ИМЯ_РАСШИРЕНИЯ);
+
+    // Запишем данные об используемых расширениях в структуру
+    createInfo.enabledExtensionCount = static_cast<uint32_t>(extensions.size());
+    createInfo.ppEnabledExtensionNames = extensions.data();
+    
+    // Подключение слоев
+    std::vector<const char*> validationLayers = {
+        "VK_LAYER_KHRONOS_validation"
+    };
+
+    if (states.VALIDATION) 
+    {
+        createInfo.enabledLayerCount = static_cast<uint32_t>(validationLayers.size());
+        createInfo.ppEnabledLayerNames = validationLayers.data();
+    }
+
+    // Проверим доступность слоев
+    std::vector<const char*> unavailableLayers;
+    if (!checkValidationLayerSupport(validationLayers, unavailableLayers))
+    {
+        std::cout << "Запрошены недоступные слои:\n";
+        // Цикл по недоступным слоям
+        for (const char* layer : unavailableLayers) 
+            std::cout << layer << "\n";  
+        // Отправим исключение об отсутствующем слое 
+        throw std::runtime_error("Requested layer unavailable");
+    }
+
+    // Создание экземпляра Vulkan
+    VkResult result = vkCreateInstance(&createInfo, nullptr, &instance);
+    if (result != VK_SUCCESS) 
+    { // Отправим исключение в случае ошибок создания экземпляра 
+        throw std::runtime_error("Instance create error");
+    }
+}
+
+#include <algorithm>
+// Выбор физического устройства на основании требований
+PhysicalDevice selectPhysicalDeviceByProperties(std::vector<VkPhysicalDevice> & devices, Surface & surface, std::vector<const char*> &requestedExtensions)
+{
+    int i;
+    PhysicalDevice result; // физическое устройство (PhysicalDevice.h)
+    for (const auto& device : devices) 
+    {
+        // Запомним устройство
+        result.device = device;
+        // Получаем данные
+        vkGetPhysicalDeviceProperties(device, &result.properties);
+        vkGetPhysicalDeviceFeatures(device, &result.features);
+        vkGetPhysicalDeviceMemoryProperties(device, &result.memory);
+        
+        // Данные по семействам очередей    
+        uint32_t queueFamilyPropertiesCount = 0;
+        vkGetPhysicalDeviceQueueFamilyProperties(device, &queueFamilyPropertiesCount, nullptr);
+        result.queueFamilyProperties.resize(queueFamilyPropertiesCount);
+        vkGetPhysicalDeviceQueueFamilyProperties(device, &queueFamilyPropertiesCount, result.queueFamilyProperties.data());
+
+        // Данные по расширениям    
+        uint32_t extensionsCount = 0;
+        vkEnumerateDeviceExtensionProperties(device, nullptr, &extensionsCount, nullptr);
+        std::vector<VkExtensionProperties> extensions(extensionsCount);
+        vkEnumerateDeviceExtensionProperties(device, nullptr, &extensionsCount, extensions.data());
+
+        int availableExtensionsCount = 0;
+        // подсчитаем совпадающие расширения
+        for (auto extension1 : requestedExtensions)
+            for (auto extension2 : extensions)
+                if (strcmp(extension1, extension2.extensionName) == 0)
+                {
+                    availableExtensionsCount++;
+                    break;
+                }
+            
+        // Получение информации о поверхности
+        VkSurfaceCapabilitiesKHR capabilities;
+        vkGetPhysicalDeviceSurfaceCapabilitiesKHR(device, surface.surface, &capabilities);
+
+        // Получение форматов поверхности
+        uint32_t formatCount;
+        vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface.surface, &formatCount, nullptr);
+        std::vector<VkSurfaceFormatKHR> formats(formatCount);
+        vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface.surface, &formatCount, formats.data());
+
+        // Получение данных о поддерживаемых режимах показа
+        uint32_t presentModeCount;
+        vkGetPhysicalDeviceSurfacePresentModesKHR(device, surface.surface, &presentModeCount, nullptr);
+        std::vector<VkPresentModeKHR> presentModes(presentModeCount);
+        vkGetPhysicalDeviceSurfacePresentModesKHR(device, surface.surface, &presentModeCount, presentModes.data());
+        
+        // Если есть форматы и режимы показа, то на данном устройстве можно создать список показа
+        bool swapchainSupport = formatCount && presentModeCount;
+
+        // Производим оценку
+        if (availableExtensionsCount == requestedExtensions.size()
+        &&  result.features.geometryShader
+        &&  4000 < result.memory.memoryHeaps[0].size / 1000 / 1000
+        &&  swapchainSupport)
+        {
+            // Заполним данные о поверхности
+            surface.capabilities = capabilities;
+            surface.formats = formats;
+            surface.presentModes = presentModes;
+            // Вернем устройство
+            return result;
+        }
+    }
+    // Если устройство не найдено - вернем пустую структуру
+    return PhysicalDevice();
+}
+
+// Выбор физического устройства
+void Vulkan::selectPhysicalDevice(std::vector<const char*> &deviceExtensions)
+{
+    // Узнаем количество доступных устройств
+    uint32_t deviceCount = 0;
+    vkEnumeratePhysicalDevices(instance, &deviceCount, nullptr);
+
+    // Проверка на отсутствие физических устройств
+    if (deviceCount == 0)
+    {
+        throw std::runtime_error("Unable to find physical devices");
+    }
+
+    // Создадим вектор нужного размера и заполним его данными
+    std::vector<VkPhysicalDevice> devices(deviceCount);
+    vkEnumeratePhysicalDevices(instance, &deviceCount, devices.data());
+
+    // Выбор физического устройства на основании требований
+    physicalDevice = selectPhysicalDeviceByProperties(devices, surface, deviceExtensions);
+
+    // Если не удалось выбрать подходящее требованием устройство - выдадим исключение
+    if (!physicalDevice.device) 
+    {
+        throw std::runtime_error("failed to find a suitable GPU!");
+    }
+}
+
+// Выбор очередей
+void Vulkan::pickQueues()
+{
+    queue.index = -1;
+    
+    for (int i = 0; i < physicalDevice.queueFamilyProperties.size(); i++)
+    {
+        // Проверка возможности вывода
+        VkBool32 presentSupport = false;
+        vkGetPhysicalDeviceSurfaceSupportKHR(physicalDevice.device, i, surface.surface, &presentSupport);
+        // Проверка поддержки очередью графических операций
+        if (physicalDevice.queueFamilyProperties[i].queueFlags & VK_QUEUE_GRAPHICS_BIT
+        &&  presentSupport) 
+        {
+            queue.index = i;
+            queue.properties = physicalDevice.queueFamilyProperties[i];
+            break;
+        }
+    }
+}
+
+// Создание логического устройства
+void Vulkan::createLogicalDevice(std::vector<const char*> &deviceExtensions)
+{
+    // Выберем очереди
+    pickQueues();
+
+    // Приоритеты очередей
+    float priority[1] = {1};
+    // Данные о необходимых очередях
+    VkDeviceQueueCreateInfo queueCreateInfo{};
+    queueCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
+    queueCreateInfo.queueFamilyIndex = queue.index;
+    queueCreateInfo.queueCount = 1;
+    queueCreateInfo.pQueuePriorities = priority; 
+
+    // слои для логического устройства
+    std::vector<const char*> layers; 
+    // Подключение других слоев
+    // layers.push_back(ИМЯ_СЛОЯ);
+
+    // Проверим доступность слоев
+    std::vector<const char*> unavailableLayers;
+    if (!checkDeviceLayerSupport(physicalDevice.device, layers, unavailableLayers))
+    {
+        std::cout << "Запрошены недоступные слои:\n";
+        // Цикл по недоступным слоям
+        for (const char* layer : unavailableLayers) 
+            std::cout << layer << "\n";  
+        // Отправим исключение об отсутствующем слое 
+        throw std::runtime_error("Requested layer unavailable");
+    }
+
+    // Данные о создаваемом логическом устройстве
+    VkDeviceCreateInfo createInfo{};
+    createInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
+    createInfo.pQueueCreateInfos = &queueCreateInfo;
+    createInfo.queueCreateInfoCount = 1;
+    createInfo.enabledExtensionCount = deviceExtensions.size();
+    createInfo.ppEnabledExtensionNames = deviceExtensions.data();
+    createInfo.enabledLayerCount = layers.size();
+    createInfo.ppEnabledLayerNames = layers.data();
+    createInfo.pEnabledFeatures = nullptr;//&physicalDevice.features;
+
+    // Создание логического устройства
+    if (vkCreateDevice(physicalDevice.device, &createInfo, nullptr, &logicalDevice) != VK_SUCCESS)
+    {
+        // Отправим исключение в случае ошибок создания лог. устройства 
+        throw std::runtime_error("failed to create logical device!");
+    }
+
+    // Получим дескриптор очереди логического устройства
+    vkGetDeviceQueue(logicalDevice, queueCreateInfo.queueFamilyIndex, 0, &queue.descriptor);
+}
+
+// Создание поверхности окна
+void Vulkan::createWindowSurface(GLFWwindow* window)
+{
+    if (glfwCreateWindowSurface(instance, window, nullptr, &surface.surface) != VK_SUCCESS) 
+    {
+        throw std::runtime_error("Unable to create window surface");
+    }
+}
+
+// Создание цепочки показа
+void Vulkan::createSwapchain(GLFWwindow* window)
+{
+    // Выбор формата
+    surface.selectedFormat = surface.formats[0];
+    for (auto& format : surface.formats) 
+    {
+        if (format.format == VK_FORMAT_B8G8R8A8_SRGB 
+        &&  format.colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR) 
+        {
+            surface.selectedFormat = format;
+            break;
+        }
+    }
+
+    // Выбор режима показа
+    surface.selectedPresentMode = VK_PRESENT_MODE_FIFO_KHR;
+    for (auto& presentMode : surface.presentModes) 
+    {
+        if (presentMode == VK_PRESENT_MODE_MAILBOX_KHR)
+        {
+            surface.selectedPresentMode = presentMode;
+            break;
+        }
+    }
+
+    // Выбор разрешения изображений
+    // Разрешение окна 
+    int width, height;
+    glfwGetFramebufferSize(window, &width, &height);
+    // Выберем разрешение исходя из ограничений физического устройства
+    surface.selectedExtent.width = CLAMP(  surface.capabilities.minImageExtent.width
+                                    , width
+                                    , surface.capabilities.maxImageExtent.width
+                                );
+    surface.selectedExtent.height = CLAMP(  surface.capabilities.minImageExtent.height
+                                    , height
+                                    , surface.capabilities.maxImageExtent.height
+                                );
+
+    // Выбор количества изображений в списке показа
+    surface.imageCount = surface.capabilities.minImageCount + 1;
+    // Если есть ограничение по максимуму изображений - применим его
+    if (surface.capabilities.maxImageCount)
+        surface.imageCount %= surface.capabilities.maxImageCount;
+
+    // Заполнение данных о создаваемом списке показа
+    VkSwapchainCreateInfoKHR createInfo{};
+    createInfo.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
+    createInfo.surface = surface.surface;
+    createInfo.minImageCount = surface.imageCount;
+    createInfo.imageFormat = surface.selectedFormat.format;
+    createInfo.imageColorSpace = surface.selectedFormat.colorSpace;
+    createInfo.imageExtent = surface.selectedExtent;
+    createInfo.imageArrayLayers = 1;
+    createInfo.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
+    createInfo.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
+    createInfo.preTransform = surface.capabilities.currentTransform;
+    createInfo.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
+    createInfo.presentMode = surface.selectedPresentMode;
+    createInfo.clipped = VK_TRUE;
+    createInfo.oldSwapchain = VK_NULL_HANDLE;
+
+    // Создание списка показа
+    if (vkCreateSwapchainKHR(logicalDevice, &createInfo, nullptr, &swapChain) != VK_SUCCESS) 
+    {
+        throw std::runtime_error("Unable to create swap chain");
+    }
+
+    // Получение изображений списка показа
+    vkGetSwapchainImagesKHR(logicalDevice, swapChain, &surface.imageCount, nullptr);
+    swapChainImages.resize(surface.imageCount);
+    vkGetSwapchainImagesKHR(logicalDevice, swapChain, &surface.imageCount, swapChainImages.data());
+
+    // Зададим размер массива в соответствии с количеством изображений
+    swapChainImageViews.resize(swapChainImages.size());
+    // Для каждого изображения из списка показа
+    for (int i = 0; i < swapChainImages.size(); i++) 
+    {
+        // Заполним данные о создаваемом объекте VkImageView
+        VkImageViewCreateInfo createInfo{};
+        createInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
+        createInfo.image = swapChainImages[i];
+        createInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
+        createInfo.format = surface.selectedFormat.format;  
+        createInfo.components.r = VK_COMPONENT_SWIZZLE_IDENTITY;
+        createInfo.components.g = VK_COMPONENT_SWIZZLE_IDENTITY;
+        createInfo.components.b = VK_COMPONENT_SWIZZLE_IDENTITY;
+        createInfo.components.a = VK_COMPONENT_SWIZZLE_IDENTITY;
+        createInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+        createInfo.subresourceRange.baseMipLevel = 0;
+        createInfo.subresourceRange.levelCount = 1;
+        createInfo.subresourceRange.baseArrayLayer = 0;
+        createInfo.subresourceRange.layerCount = 1;
+
+        // Создание VkImageView
+        if (vkCreateImageView(logicalDevice, &createInfo, nullptr, &swapChainImageViews[i]) != VK_SUCCESS) 
+        {
+            throw std::runtime_error("Unable to create image views");
+        }
+    }
+}
+
+// Создание проходов рендера
+void Vulkan::createRenderpass()
+{
+    // Информация о прикреплении
+    VkAttachmentDescription colorAttachment{};
+    colorAttachment.format = surface.selectedFormat.format;
+    colorAttachment.samples = VK_SAMPLE_COUNT_1_BIT;
+    colorAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
+    colorAttachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
+    colorAttachment.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
+    colorAttachment.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
+    colorAttachment.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
+    colorAttachment.finalLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
+
+    // Информация о выходном прикреплении
+    VkAttachmentReference colorAttachmentRef{};
+    colorAttachmentRef.attachment = 0;
+    colorAttachmentRef.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
+
+    // Информация о подпроходе
+    VkSubpassDescription subpass{};
+    subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
+    subpass.colorAttachmentCount = 1;
+    subpass.pColorAttachments = &colorAttachmentRef;
+
+    // Зависимости подпрохода
+    VkSubpassDependency dependency{};
+    dependency.srcSubpass = VK_SUBPASS_EXTERNAL;
+    dependency.dstSubpass = 0;
+    dependency.srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
+    dependency.srcAccessMask = 0;
+    dependency.dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
+    dependency.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
+
+    // Информация о создаваемом проходе рендера
+    VkRenderPassCreateInfo renderPassInfo{};
+    renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
+    renderPassInfo.attachmentCount = 1;
+    renderPassInfo.pAttachments = &colorAttachment;
+    renderPassInfo.subpassCount = 1;
+    renderPassInfo.pSubpasses = &subpass;
+    renderPassInfo.dependencyCount = 1;
+    renderPassInfo.pDependencies = &dependency;
+
+    // Создание проходов рендера
+    if (vkCreateRenderPass(logicalDevice, &renderPassInfo, nullptr, &renderPass) != VK_SUCCESS) 
+    {
+        throw std::runtime_error("Unable to create render pass");
+    }
+
+}
+
+#include <fstream>
+// Считывание бинарного файла, содержащего шейдер
+void readFile(const char * filename, std::vector<char>& buffer) 
+{
+    // откроем файл как бинарный и установим курсор в конец файла
+    std::ifstream file(filename, std::ios::ate | std::ios::binary);
+    // если файл не открыт - генерируем исключение
+    if (!file.is_open()) 
+    {
+        throw std::runtime_error("Can't open file");
+    }
+    // определим размер файла
+    size_t fileSize = (size_t) file.tellg();
+    // создадим буфер
+    buffer.resize(fileSize);
+
+    // перенесем курсор в начало файла
+    file.seekg(0);
+    // считаем данные в буфер
+    file.read(buffer.data(), fileSize);
+    // закроем файл
+    file.close();
+}
+
+// Создание шейдерного модуля
+VkShaderModule Vulkan::createShaderModule(const char * filename)
+{
+    // буфер для чтения из файла
+    std::vector<char> buffer;
+    // считаем шейдер из файла
+    readFile(filename, buffer);
+
+    // Информация о создаваемом шейдерном модуле
+    VkShaderModuleCreateInfo createInfo{};
+    createInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
+    createInfo.codeSize = buffer.size();
+    createInfo.pCode = reinterpret_cast<const uint32_t*>(buffer.data());
+
+    // Создание шейдерного модуля
+    VkShaderModule shaderModule;
+    if (vkCreateShaderModule(logicalDevice, &createInfo, nullptr, &shaderModule) != VK_SUCCESS) {
+        throw std::runtime_error("Unable to create shader module");
+    }
+
+    return shaderModule;
+}
+
+// Создание графического конвеера
+void Vulkan::createGraphicPipeline()
+{
+    // Входные данные вершин
+    VkPipelineVertexInputStateCreateInfo vertexInputInfo{};
+    vertexInputInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
+
+    // Привязка
+    VkVertexInputBindingDescription bindingDescription{};
+    bindingDescription.binding = 0;
+    bindingDescription.stride = sizeof(Vertex);
+    bindingDescription.inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
+
+    // Описание атрибута 
+    VkVertexInputAttributeDescription attributeDescriptions[2];
+
+    attributeDescriptions[0].binding = 0;
+    attributeDescriptions[0].location = 0;
+    attributeDescriptions[0].format = VK_FORMAT_R32G32_SFLOAT;
+    attributeDescriptions[0].offset = offsetof(Vertex, position);
+
+    attributeDescriptions[1].binding = 0;
+    attributeDescriptions[1].location = 1;
+    attributeDescriptions[1].format = VK_FORMAT_R32G32B32_SFLOAT;
+    attributeDescriptions[1].offset = offsetof(Vertex, color);
+
+    vertexInputInfo.vertexBindingDescriptionCount = 1;
+    vertexInputInfo.vertexAttributeDescriptionCount = 2;
+    vertexInputInfo.pVertexBindingDescriptions = &bindingDescription;
+    vertexInputInfo.pVertexAttributeDescriptions = attributeDescriptions;
+
+    // Входной сборщик
+    VkPipelineInputAssemblyStateCreateInfo inputAssembly{};
+    inputAssembly.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
+    inputAssembly.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
+    inputAssembly.primitiveRestartEnable = VK_FALSE;
+
+    // Область просмотра
+    VkViewport viewport{};
+    viewport.x = 0.0f;
+    viewport.y = 0.0f;
+    viewport.width = surface.selectedExtent.width;
+    viewport.height = surface.selectedExtent.height;
+    viewport.minDepth = 0.0f;
+    viewport.maxDepth = 1.0f;
+
+    // Прямоугольник отсечения
+    VkRect2D scissor{};
+    scissor.offset = {0, 0};
+    scissor.extent = surface.selectedExtent;
+
+    // Состояние области просмотра
+    VkPipelineViewportStateCreateInfo viewportState{};
+    viewportState.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
+    viewportState.viewportCount = 1;
+    viewportState.pViewports = &viewport;
+    viewportState.scissorCount = 1;
+    viewportState.pScissors = &scissor;
+
+    // Растеризатор
+    VkPipelineRasterizationStateCreateInfo rasterizer{};
+    rasterizer.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
+    rasterizer.depthClampEnable = VK_FALSE;
+    rasterizer.rasterizerDiscardEnable = VK_FALSE;
+    rasterizer.polygonMode = VK_POLYGON_MODE_FILL;
+    rasterizer.lineWidth = 1.0f;
+    rasterizer.cullMode = VK_CULL_MODE_BACK_BIT;
+    rasterizer.frontFace = VK_FRONT_FACE_CLOCKWISE;
+    rasterizer.depthBiasEnable = VK_FALSE;
+
+    // Мультисэмплинг 
+    VkPipelineMultisampleStateCreateInfo multisampling{};
+    multisampling.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
+    multisampling.sampleShadingEnable = VK_FALSE;
+    multisampling.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
+
+    // Смешивание цветов для буфера
+    VkPipelineColorBlendAttachmentState colorBlendAttachment{};
+    colorBlendAttachment.colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
+    colorBlendAttachment.blendEnable = VK_FALSE;
+
+    // Глобальные настройки смешивания цветов
+    VkPipelineColorBlendStateCreateInfo colorBlending{};
+    colorBlending.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
+    colorBlending.logicOpEnable = VK_FALSE;
+    colorBlending.logicOp = VK_LOGIC_OP_COPY;
+    colorBlending.attachmentCount = 1;
+    colorBlending.pAttachments = &colorBlendAttachment;
+    colorBlending.blendConstants[0] = 0.0f;
+    colorBlending.blendConstants[1] = 0.0f;
+    colorBlending.blendConstants[2] = 0.0f;
+    colorBlending.blendConstants[3] = 0.0f;
+
+    // раскладка конвейера
+    VkPipelineLayoutCreateInfo pipelineLayoutInfo{};
+    pipelineLayoutInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
+    pipelineLayoutInfo.setLayoutCount = 0;
+    pipelineLayoutInfo.pushConstantRangeCount = 0;
+
+    if (vkCreatePipelineLayout(logicalDevice, &pipelineLayoutInfo, nullptr, &pipelineLayout) != VK_SUCCESS) 
+    {
+        throw std::runtime_error("Unable to create pipeline layout");
+    }
+
+    // Создание шейдеров
+    VkShaderModule vertShaderModule = createShaderModule("shaders/vert.spv");
+    VkShaderModule fragShaderModule = createShaderModule("shaders/frag.spv");
+
+    VkPipelineShaderStageCreateInfo vertShaderStageInfo{};
+    vertShaderStageInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
+    vertShaderStageInfo.stage = VK_SHADER_STAGE_VERTEX_BIT;
+    vertShaderStageInfo.module = vertShaderModule;
+    vertShaderStageInfo.pName = "main";
+
+    VkPipelineShaderStageCreateInfo fragShaderStageInfo{};
+    fragShaderStageInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
+    fragShaderStageInfo.stage = VK_SHADER_STAGE_FRAGMENT_BIT;
+    fragShaderStageInfo.module = fragShaderModule;
+    fragShaderStageInfo.pName = "main";
+
+    // Шейдерные стадии
+    VkPipelineShaderStageCreateInfo shaderStages[] = {vertShaderStageInfo, fragShaderStageInfo};
+
+    
+    // Информация о создаваемом конвейере
+    VkGraphicsPipelineCreateInfo pipelineInfo{};
+    pipelineInfo.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
+    pipelineInfo.stageCount = 2;
+    pipelineInfo.pStages = shaderStages;
+    pipelineInfo.pVertexInputState = &vertexInputInfo;
+    pipelineInfo.pInputAssemblyState = &inputAssembly;
+    pipelineInfo.pViewportState = &viewportState;
+    pipelineInfo.pRasterizationState = &rasterizer;
+    pipelineInfo.pMultisampleState = &multisampling;
+    pipelineInfo.pColorBlendState = &colorBlending;
+    pipelineInfo.layout = pipelineLayout;
+    pipelineInfo.renderPass = renderPass;
+    pipelineInfo.subpass = 0;
+    pipelineInfo.basePipelineHandle = VK_NULL_HANDLE;
+
+    // Создание графического конвейера
+    if (vkCreateGraphicsPipelines(logicalDevice, VK_NULL_HANDLE, 1, &pipelineInfo, nullptr, &graphicsPipeline) != VK_SUCCESS) 
+    {
+        throw std::runtime_error("Unable to create graphics pipeline");
+    }
+
+    // Удаление шейдерных модулей
+    vkDestroyShaderModule(logicalDevice, fragShaderModule, nullptr);
+    vkDestroyShaderModule(logicalDevice, vertShaderModule, nullptr);
+}
+
+// Создание произвольного буфера данных
+void Vulkan::createBuffer(VkDeviceSize size, VkBufferUsageFlags usage, VkMemoryPropertyFlags properties, VkBuffer& buffer, VkDeviceMemory& bufferMemory) 
+{
+    // Информация о создаваемом буфере
+    VkBufferCreateInfo bufferInfo{};
+    bufferInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
+    bufferInfo.size = size;
+    bufferInfo.usage = usage;
+    bufferInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
+
+    // Создание буфера
+    if (vkCreateBuffer(logicalDevice, &bufferInfo, nullptr, &buffer) != VK_SUCCESS) 
+    {
+        throw std::runtime_error("Unable to create buffer");
+    }
+    
+    // Требования к памяти
+    VkMemoryRequirements memRequirements;
+    vkGetBufferMemoryRequirements(logicalDevice, buffer, &memRequirements);
+
+    // Поиск индекса типа подходящей памяти
+    uint32_t index_memory;
+    for (index_memory = 0; index_memory < physicalDevice.memory.memoryTypeCount; index_memory++) 
+    {
+        if ((memRequirements.memoryTypeBits & (1 << index_memory)) 
+        &&  (physicalDevice.memory.memoryTypes[index_memory].propertyFlags & properties) == properties) 
+        {
+            break;
+        }
+    }
+
+    // Если индекс равен размеру массива - поиск не удался и нужно выдать исключение
+    if (index_memory == physicalDevice.memory.memoryTypeCount)
+        throw std::runtime_error("Unable to find suitable memory type");
+
+    // Информация о выделяемой памяти
+    VkMemoryAllocateInfo allocInfo{};
+    allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
+    allocInfo.allocationSize = memRequirements.size;
+    allocInfo.memoryTypeIndex = index_memory;
+
+    // Выделение памяти
+    if (vkAllocateMemory(logicalDevice, &allocInfo, nullptr, &bufferMemory) != VK_SUCCESS) 
+    {
+        throw std::runtime_error("Unable to allocate buffer memory");
+    }
+
+    // Привязка выделенной памяти к буферу
+    vkBindBufferMemory(logicalDevice, buffer, bufferMemory, 0);
+}
+
+// Создание пула команд
+void Vulkan::createCommandPool()
+{
+    // Информация о создаваемом командном пуле
+    VkCommandPoolCreateInfo poolInfo{};
+    poolInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
+    poolInfo.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
+    poolInfo.queueFamilyIndex = queue.index;
+
+    // Создание командного пула
+    if (vkCreateCommandPool(logicalDevice, &poolInfo, nullptr, &commandPool) != VK_SUCCESS) 
+    {
+        throw std::runtime_error("Unable to create graphics command pool");
+    }
+
+    // Выделим память под буферы команд
+    commandBuffers.resize(swapChainImages.size());
+
+    // Информация о выделяемых буферах
+    VkCommandBufferAllocateInfo allocInfo{};
+    allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
+    allocInfo.commandPool = commandPool;
+    allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
+    allocInfo.commandBufferCount = (uint32_t) commandBuffers.size();
+
+    // Выделение буферов команд из пула команд
+    if (vkAllocateCommandBuffers(logicalDevice, &allocInfo, commandBuffers.data()) != VK_SUCCESS) 
+    {
+        throw std::runtime_error("Unable to allocate command buffers");
+    }
+}
+
+// Копирование между буферами данных
+void Vulkan::copyBuffer(VkBuffer srcBuffer, VkBuffer dstBuffer, VkDeviceSize size) 
+{
+    // Информация о выделяемом буфере команд
+    VkCommandBufferAllocateInfo allocInfo{};
+    allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
+    allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
+    allocInfo.commandPool = commandPool;
+    allocInfo.commandBufferCount = 1;
+
+    // Дескриптор и выделение буфера команд
+    VkCommandBuffer commandBuffer;
+    vkAllocateCommandBuffers(logicalDevice, &allocInfo, &commandBuffer);
+
+    // Начало записи команд
+    VkCommandBufferBeginInfo beginInfo{};
+    beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
+    beginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
+    vkBeginCommandBuffer(commandBuffer, &beginInfo);
+
+    // Операция копирования
+    VkBufferCopy copyRegion{};
+    copyRegion.size = size;
+    vkCmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, 1, &copyRegion);
+
+    // Конец записи команд
+    vkEndCommandBuffer(commandBuffer);
+
+    // Информация о запускаемых буферах команд
+    VkSubmitInfo submitInfo{};
+    submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
+    submitInfo.commandBufferCount = 1;
+    submitInfo.pCommandBuffers = &commandBuffer;
+
+    // Запуск командного буфера копирования и ожидание завершения
+    vkQueueSubmit(queue.descriptor, 1, &submitInfo, VK_NULL_HANDLE);
+    vkQueueWaitIdle(queue.descriptor);
+
+    // Освобождение командного буфера копирования
+    vkFreeCommandBuffers(logicalDevice, commandPool, 1, &commandBuffer);
+}
+
+// Создание вершинного буфера
+void Vulkan::createVertexBuffer()
+{
+    //Вершины, записываемые в буфер
+    Vertex vertices[] = {
+                            { {-0.5f, -0.5f}, {1.0f, 0.0f, 0.0f} },
+                            { { 0.5f, -0.5f}, {0.0f, 1.0f, 0.0f} },
+                            { { 0.5f,  0.5f}, {0.0f, 0.0f, 1.0f} },
+                            { {-0.5f,  0.5f}, {1.0f, 1.0f, 1.0f} }
+                        };
+    // Размер буфера в байтах
+    VkDeviceSize bufferSize = sizeof(Vertex) * 4;
+
+    // Промежуточный буфер для переноса на устройство
+    VkBuffer stagingBuffer;
+    VkDeviceMemory stagingBufferMemory;
+    createBuffer(bufferSize, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, stagingBuffer, stagingBufferMemory);
+
+    // Отображение памяти буфера
+    void* data;
+    vkMapMemory(logicalDevice, stagingBufferMemory, 0, bufferSize, 0, &data);
+    // Копирование вершин в промежуточный буфер
+    memcpy(data, vertices, (size_t) bufferSize);
+    // Прекращение отображения памяти буфера
+    vkUnmapMemory(logicalDevice, stagingBufferMemory);
+
+    // Создание буфера вершин
+    createBuffer(bufferSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, vertexBuffer, vertexBufferMemory);
+    // Копирование из промежуточного в буфер вершин
+    copyBuffer(stagingBuffer, vertexBuffer, bufferSize);
+   
+    // Освобождение памяти и уничтожение буферов
+    vkDestroyBuffer(logicalDevice, stagingBuffer, nullptr);
+    vkFreeMemory(logicalDevice, stagingBufferMemory, nullptr);
+}
+
+// Создание буфера индексов
+void Vulkan::createIndexBuffer() 
+{
+    // Индексы, записываемые в буфер
+    uint16_t indices[] = {0, 1, 2, 2, 3, 0};
+    // Размер буфера в байтах
+    VkDeviceSize bufferSize = sizeof(uint16_t) * 6;
+
+    // Промежуточный буфер для переноса на устройство
+    VkBuffer stagingBuffer;
+    VkDeviceMemory stagingBufferMemory;
+    createBuffer(bufferSize, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, stagingBuffer, stagingBufferMemory);
+
+    // Отображение памяти буфера
+    void* data;
+    vkMapMemory(logicalDevice, stagingBufferMemory, 0, bufferSize, 0, &data);
+    // Копирование вершин в промежуточный буфер
+    memcpy(data, indices, (size_t) bufferSize);
+    // Прекращение отображения памяти буфера
+    vkUnmapMemory(logicalDevice, stagingBufferMemory);
+
+    // Создание буфера вершин
+    createBuffer(bufferSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_INDEX_BUFFER_BIT, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, indexBuffer, indexBufferMemory);
+    // Копирование из промежуточного в буфер вершин
+    copyBuffer(stagingBuffer, indexBuffer, bufferSize);
+
+    // Освобождение памяти и уничтожение буферов
+    vkDestroyBuffer(logicalDevice, stagingBuffer, nullptr);
+    vkFreeMemory(logicalDevice, stagingBufferMemory, nullptr);
+}