常連

Visual Studio 2019を使って、Vulkanを用いたプログラミングを行っているのですが、
テクスチャロード時に、```vkAllocateMemory```でデバイスメモリを確保する際、
VisualStudioからのデバッガー起動（F5）では、問題は起こらず、```VK_SUCCESS```が結果として返ってくるのですが、
Debugでビルドした後、exeファイルを直接起動すると、```vkAllocateMemory```のところが通りません。
結果は、```VK_ERROR_OUT_OF_DEVICE_MEMORY``` が返ってきているようで、
その直後に```vkBindImageMemory```しようとすると、アプリケーション自体が落ちてしまいます。

何か、原因として考えられることありますでしょうか？

exeファイル起動でのみ起こる不具合というのが初めてなので、
どのような場合にそのようなことがありうるのか、のヒントでも回答いただければありがたいです。

よろしくお願いします。

作業の環境は以下のような具合です。
・Windows 10　Pro 64ビット
・Intel(R) Core(TM) i7-10700 CPU @ 2.90GHz(16CPUs), ~2.9GHz
・NVIDIA GeForce GTX 1660 SUPER

Vulkanで、exe起動時にのみvkAllocateMemoryに失敗

Vulkanを使った図形の描画を実装しています。
四角形の中を塗りつぶさずに、枠線だけの四角形を描画したく、
以下の流れで実装を行っているのですが、うまくいきません。

①頂点バッファを４頂点分作成
②パイプラインを作成、その際以下のように設定。
・```VkPipelineInputAssemblyStateCreateInfo```の```topology```を、```VK_PRIMITIVE_TOPOLOGY_LINE_STRIP```に設定
・```VkPipelineRasterizationStateCreateInfo```の```polygonMode```を、```VK_POLYGON_MODE_LINE```に設定
③```vkCmdDrawIndexed```を使って描画。インデックスリストは、下図のように設定。

しかし、これで描画を行うと、最初の３頂点だけで三角形が描画されてしまいます。
塗りつぶしはされていません。
インデックスリストを用いず、```vkCmdDraw```でやっても見たのですが、下図と全く同じ結果が表示されていました。
（当然のことながら、```vkCmdDraw```の引数の```vertexCount```は、４です）
![イメージ説明](7ecd8e6465964e9fc2590b965b514c53.png)

また、インデックスリストを変えて、LINE_LISTを使っても試してみたのですが、
こちらもうまくいきません。結果は、以下のような状況です。
![イメージ説明](678317d855b101dfbe4774d02ae4b1a7.png)

こちらの原因がわかる方いらっしゃれば、教えていただきたいです。
よろしくお願いいたします・・・！

VulkanでのVK_PRIMITIVE_TOPOLOGY_LINE_STRIPを用いた描画について

## 前提・実現したいこと

VulkanのWindows環境においてWindows向けの`VkSurfaceKHR`を`vkCreateWin32SurfaceKHR`で作成すると思いますが作成することができません。

`VkResult`として`VK_ERROR_EXTENSION_NOT_PRESENT`を返します。
エラーメッセージ通り`VkInstance`作成時に`VK_KHR_WIN32_SURFACE_EXTENSION_NAME`を追加してやればいいのだと思いましたが`vkEnumerateInstanceExtensionProperties`で取得することはできませんし勝手に追加しても当然失敗します。

そもそもリファレンス [www.khronos.org vkCreateWin32SurfaceKHR](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateWin32SurfaceKHR.html)に`VK_ERROR_EXTENSION_NOT_PRESENT`を返すとは書かれていません。(あり得るエラーだとは思いますが)

従来のVulkan ver.1.1の`VK_LAYER_LUNARG_standard_validation`レイヤーが有効なときにはできるのか確かめましたがこちらもたしか表示されませんでした。ですから`VkInstance`の初期化や#ifdefの切り替えの問題だとは思いますが`VK_LAYER_KHRONOS_validation`レイヤーやウィンドウハンドルを自分で作ってくるサンプルも少ないのでわかりません。

どこか間違いがありましたらご指摘ください。

## 該当のソースコード

```C
#ifndef UNICODE
#define UNICODE
#endif

#pragma comment(lib, "vulkan-1.lib")

#include <cstdint>
#include <vector>

#include <Windows.h>
#define VK_USE_PLATFORM_WIN32_KHR
#include <vulkan/vulkan.h>

namespace sample
{
	constexpr wchar_t MAIN_CLASS_NAME[] = L"main window";
	constexpr wchar_t VK_CLASS_NAME[] = L"vulkan window";

	LRESULT CALLBACK WindowProc(HWND, UINT, WPARAM, LPARAM);
	LRESULT CALLBACK VulkanProc(HWND, UINT, WPARAM, LPARAM);
}

int WINAPI wWinMain(_In_ HINSTANCE hInstance, _In_opt_ HINSTANCE hPrevInstance, _In_ LPWSTR nCmdLine, _In_ int nCmdShow)
{
	UNREFERENCED_PARAMETER(hPrevInstance);
	UNREFERENCED_PARAMETER(nCmdLine);

	WNDCLASSEXW wcx =
	{
		sizeof(WNDCLASSEXW), CS_VREDRAW | CS_HREDRAW, sample::WindowProc,
		0,0,hInstance,
		nullptr, static_cast<HCURSOR>(LoadCursor(nullptr, IDC_ARROW)), static_cast<HBRUSH>(GetStockObject(WHITE_BRUSH)),
		nullptr, sample::MAIN_CLASS_NAME, nullptr
	};
	RegisterClassExW(&wcx);

	HWND hwnd = CreateWindowExW(
		0, sample::MAIN_CLASS_NAME, L"Vulkan Initialization", WS_OVERLAPPEDWINDOW,
		0, 0, 960, 540,
		nullptr, nullptr, hInstance, nullptr
	);
	if (hwnd == nullptr)return -1;

	ShowWindow(hwnd, nCmdShow);
	UpdateWindow(hwnd);

	MSG msg = {};

	while (GetMessage(&msg, NULL, 0, 0) > 0) {
		TranslateMessage(&msg);
		DispatchMessage(&msg);
	}

	return (int)msg.wParam;
}

namespace sample
{
	LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
	{
		static HINSTANCE hGlobalInstance = nullptr;
		static HWND hwnd_vulkan = nullptr;

		switch (uMsg)
		{
		case WM_CREATE:
		{
			CREATESTRUCTW* cs = reinterpret_cast<CREATESTRUCTW*>(lParam);
			hGlobalInstance = cs->hInstance;

			// Create Window for Vulkan
			{
				WNDCLASSEXW wcv =
				{
					sizeof(WNDCLASSEXW), CS_VREDRAW | CS_HREDRAW, sample::VulkanProc,
					0, 0, hGlobalInstance,
					nullptr, static_cast<HCURSOR>(LoadCursor(nullptr, IDC_ARROW)), static_cast<HBRUSH>(GetStockObject(WHITE_BRUSH)),
					nullptr, sample::VK_CLASS_NAME, nullptr
				};

				RegisterClassExW(&wcv);

				hwnd_vulkan = CreateWindowExW(
					0, sample::VK_CLASS_NAME, L"Vulkan", WS_OVERLAPPEDWINDOW | WS_VISIBLE,
					0, 0, 480, 270,
					hwnd, nullptr, hGlobalInstance, nullptr
				);

				if (hwnd_vulkan == nullptr)
				{
					PostQuitMessage(0);
					break;
				}
			}

			// Initialize Vulkan
			{
				// Create VkInstance
				VkInstance vki = nullptr;
				{
					const char* appName = "Initialize Vulkan";
					std::vector<VkLayerProperties> vkLayerProp;

					uint32_t uLayerCount = 0;
					vkEnumerateInstanceLayerProperties(&uLayerCount, nullptr);
					vkLayerProp.resize(uLayerCount);
					vkEnumerateInstanceLayerProperties(&uLayerCount, vkLayerProp.data());

					const char lpSelectedLayer[] = "VK_LAYER_KHRONOS_validation";
					// This layer is selected from vkEnumerateInstanceLayerProperties
					// Disable to select "VK_LAYER_LUNARG_standard_validation" in ver.1.2
					// We must use "VK_LAYER_KHRONOS_validation"

					std::vector<VkExtensionProperties>vkExtensionProp;
					std::vector<const char*>vkExtensionNames;
					uint32_t uExtensionCount = 0;
					vkEnumerateInstanceExtensionProperties(lpSelectedLayer, &uExtensionCount, nullptr);
					vkExtensionProp.resize(uExtensionCount);
					vkEnumerateInstanceExtensionProperties(lpSelectedLayer, &uExtensionCount, vkExtensionProp.data());
					// We may have to get "VK_KHR_WIN32_SURFACE_EXTENSION_NAME" here for Windows Environment but I can't

					for (const VkExtensionProperties& i : vkExtensionProp)
					{
						vkExtensionNames.push_back(reinterpret_cast<const char*>(&i.extensionName));
					}

					VkApplicationInfo vkai =
					{
						VK_STRUCTURE_TYPE_APPLICATION_INFO,
						nullptr,
						appName,
						0,
						appName,
						VK_MAKE_VERSION(1, 2, 0),
						VK_API_VERSION_1_2
					};

					const char* layers[] = { lpSelectedLayer };

					VkInstanceCreateInfo vkici =
					{
						VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
						nullptr,
						0, //reserved
						&vkai,
						1,
						layers,
						vkExtensionNames.size(),
						vkExtensionNames.data()
					};

					VkResult vr_vkci = vkCreateInstance(&vkici, nullptr, &vki);
					if (vr_vkci != VK_SUCCESS)
					{
						MessageBox(hwnd, L"Failed to create VkInstance", L"CAUTION", MB_OK);
						PostQuitMessage(0);
						break;
					}
				}

				// Create VkSurfaceKHR
				VkSurfaceKHR vkSurface = nullptr;
				{
					VkWin32SurfaceCreateInfoKHR vk_winsfci =
					{
						VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR,
						nullptr,
						0, //reserved
						hGlobalInstance,
						hwnd_vulkan
					};

					VkResult vr_cws = vkCreateWin32SurfaceKHR(vki, &vk_winsfci, nullptr, &vkSurface);
					if (vr_cws != VK_SUCCESS)
					{
						MessageBox(hwnd, L"Failed to create VkSurfaceKHR", L"CAUTION", MB_OK);
						PostQuitMessage(0);
						break;
					}
				}
			}
		}
			break;

		case WM_DESTROY:
			PostQuitMessage(0);
			return 0;
		}

		return DefWindowProcW(hwnd, uMsg, wParam, lParam);
	}

	LRESULT CALLBACK VulkanProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
	{
		return DefWindowProcW(hwnd, uMsg, wParam, lParam);
	}
}

```

## 補足情報
Windows10 Pro
VisualStudio2022 Community Preview
Vulkan ver. 1.2.182.0

VulkanのWindows環境でVkSurfaceKHRが作成できない

クラウドゲームやゲームのストリーミングサービスはどうやって毎フレーム画像を生成して送信しているのですが？

何故こんな事を書くのかというとGLFWとVulkanを元にDLL経由で3DCGの画像を毎フレームごとにレンダリングして、そのレンダリングで出来た画像を下記のVulkanでスクリーンショットを生成するプログラムを元にしてコピーし、別のプログラムに送信するというプログラムを作っていたのです。

https://github.com/SaschaWillems/Vulkan/blob/master/examples/screenshot/screenshot.cpp
 
ところが毎フレームごとに画像を生成するプログラムが重すぎて使い物になりませんでした。

しかし、クラウドゲーム（ゲームストリーミングサービス）やPCからスマホにゲームの画像を送信して操作するなどといったリモートプレイのソフトウェアは30fpsから60fpsでそこまで遅延なく画像を送信できています。これは一体どういうことなのでしょうか？

何か毎フレームごとにスクリーンショットを生成するとはまた違った方法を使っているのでしょうか？それともサーバーやPCのパワーを使ってゴリ押ししているのでしょうか？

よろしくお願いします。

クラウドゲームやゲームのリモートプレイはどうやって毎フレームごとに画像を生成して送信しているのですが？

### 前提・実現したいこと
Vulkanの論理デバイス`VkDevice`を`vkCreateDevice`で作成しようとしているのですが`vkCreateDevice`で例外が飛びます.
C++, vectorにはあまり慣れないですがこれ以前の同様の処理`vkCreateInstance`は作成できています.
`VkDeviceCreateInfo::ppEnabledExtensionNames`が問題だとは思いますがうまく動作しません.
何が間違っていますでしょうか?


### 該当のソースコード

#### outline
- `vkEnumerateDeviceExtensionProperties`で`VkExtensionProperties`を取得
- `VkExtensionProperties`からextensionNameのpointerをリスト
- `vkCreateDevice`

#### codes
```C
vector<VkExtensionProperties>dep;
uint32_t DevExPropCount = 0;
const char layerlist[] = { "VK_LAYER_KHRONOS_validation" };
vkEnumerateDeviceExtensionProperties(selectedPhysicalDevice, layerlist, &DevExPropCount, nullptr);
dep.resize(DevExPropCount);
vkEnumerateDeviceExtensionProperties(selectedPhysicalDevice, layerlist, &DevExPropCount, dep.data());

vector<const char*>lpdeplist(dep.size());
for (vector<const char*>::size_type i = 0; i < lpdeplist.size(); i++)lpdeplist[i] = dep[i].extensionName;

VkDevice vkd = {};
const float prio = 1.0;
VkDeviceQueueCreateInfo dqci = {VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, nullptr, 0, 1, graphicsqueue, &prio};
VkDeviceCreateInfo vkci = { VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, nullptr, VK_VERSION_1_0, 1, &dqci, 0, nullptr, lpdeplist.size(), lpdeplist.data(), nullptr };

VkResult  res_cd = vkCreateDevice(selectedPhysicalDevice, &vkci, nullptr, &vkd);
```
selectedPhysicalDeviceは正常に初期化されています.

### 補足情報
Windows10 Pro
VisualStudio2019 Community
Vulkan SDK 1.1.121.2

vkCreateDeviceでの例外

### 前提・実現したいこと

タイトルの通りです. いくつかほかのPCでも試しましたが, 動作しなかったので私のやり方が間違っているみたいなので, 正しい方法を教えていただけると嬉しいです. ドキュメントは読み, サンプルも漁りましたが見つかりませんでした. 

### 失敗した実装方法

初めにVulkanのインスタンスを作成. この際有効化したextensionsは, `VK_KHR_SURFACE_EXTENSION_NAME`, `VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME`, `VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME`, `VK_KHR_WIN32_SURFACE_EXTENSION_NAME`, `VK_EXT_DEBUG_UTILS_EXTENSION_NAME`, layersは, `VK_LAYER_KHRONOS_validation`. 構造体のpNextは`VkDebugUtilsMessengerCreateInfoEXT`のみです.  
続いて, ウィンドウサーフェスを`vkCreateWin32SurfaceKHR`関数を用いて作成. この際構造体のpNextはありません. 
次に, 物理デバイスを選択します. グラフィックとプレゼントのキューをサポートしているものを選んだあと, VkGetPhysicalDeviceSurfaceCapabilities2KHRでフルスクリーンの対応情報を調べています. 具体的には, 関数に渡す構造体のpNextチェーンに`VkSurfaceFullScreenExclusiveWin32InfoEXT`-> `VkSurfaceFullScreenExclusiveInfoEXT`の順番で格納しました. 前者には`MonitorFromWindow(WindowsArgs.hWnd, MONITOR_DEFAULTTOPRIMARY)`を, 後者には`VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT`を渡しました. 関数で変更される構造体のpNextには`VkSurfaceCapabilitiesFullScreenExclusiveEXT`を設定しました. このとき確かに`fullScreenExclusiveSupported`は`VK_TRUE`となっていたので, 対応しているはずです. 
その後, デバイスを作成します. 有効化したextensionsは, `VK_KHR_SWAPCHAIN_EXTENSION_NAME`と, `VK_EXT_FULL_SCREEN_EXCLUSIVE_EXTENSION_NAME`です. 構造体のpNextには何も設定していません. 
最後にスワップチェーンを設定します. 構造体のpNextには先ほど用いた`VkSurfaceFullScreenExclusiveWin32InfoEXT`を再び渡しています. 

これで`vkAcquireFullScreenExclusiveModeEXT`を呼び出したのですが, フルスクリーンになりませんでした. 

### 補足情報（FW/ツールのバージョンなど）

VulkanSDK: 1.2.176.1
GPU: NVIDIA GeForce GTX 1660 SUPER
Driver: GeForce 471.68
OS: Windows10 Home / OS Build: 19042.1165

###コードについて

teratailの文字数制限に達したので, GoogleDocsを作成しました. 
[こちら](https://docs.google.com/document/d/1kkDmg0vT5O3BQKW1v-lKTXGgRZtWQv7cwNLNSjYuAXg/edit?usp=sharing)のリンクより閲覧&コメントできます. 


##最後に
最後まで読んでくださって本当にありがとうございます！

VK_EXT_full_screen_exclusiveを用いた, フルスクリーンの切り替えをしたい

[vulkan tutorial](https://vulkan-tutorial.com/Drawing_a_triangle/Setup/Instance)
検証レイアを有効にしてのvkCreateInstanceでエラーになります。
VK_ERROR_EXTENSION_NOT_PRESENT  がでます。
enableValidationLayersがfalseなら大丈夫そうなので
VK_EXT_DEBUG_UTILS_EXTENSION_NAMEが私のパソコンでは使えないってことですか？


```
      std::vector<const char*> getRequiredExtensions() {
            uint32_t glfwExtensionCount = 0;
            const char** glfwExtensions;
            glfwExtensions = glfwGetRequiredInstanceExtensions(&glfwExtensionCount);

            std::vector<const char*> extensions(glfwExtensions, glfwExtensions + glfwExtensionCount);

            if (enableValidationLayers) {
                  extensions.push_back(VK_EXT_DEBUG_UTILS_EXTENSION_NAME);
            }

            return extensions;
      }
```

```
#define GLFW_INCLUDE_VULKAN
#include <GLFW/glfw3.h>

#include <iostream>
#include <stdexcept>
#include <vector>
#include <cstring>
#include <cstdlib>

const uint32_t WIDTH = 800;
const uint32_t HEIGHT = 600;

const std::vector<const char*> validationLayers = {
    "VK_LAYER_KHRONOS_validation"
};

#ifdef NDEBUG
const bool enableValidationLayers = false;
#else
const bool enableValidationLayers = true;
#endif

VkResult CreateDebugUtilsMessengerEXT(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugUtilsMessengerEXT* pDebugMessenger) {
      auto func = (PFN_vkCreateDebugUtilsMessengerEXT)vkGetInstanceProcAddr(instance, "vkCreateDebugUtilsMessengerEXT");
      if (func != nullptr) {
            return func(instance, pCreateInfo, pAllocator, pDebugMessenger);
      }
      else {
            return VK_ERROR_EXTENSION_NOT_PRESENT;
      }
}

void DestroyDebugUtilsMessengerEXT(VkInstance instance, VkDebugUtilsMessengerEXT debugMessenger, const VkAllocationCallbacks* pAllocator) {
      auto func = (PFN_vkDestroyDebugUtilsMessengerEXT)vkGetInstanceProcAddr(instance, "vkDestroyDebugUtilsMessengerEXT");
      if (func != nullptr) {
            func(instance, debugMessenger, pAllocator);
      }
}

class HelloTriangleApplication {
public:
      void run() {
            initWindow();
            initVulkan();
            mainLoop();
            cleanup();
      }

private:
      GLFWwindow* window;

      VkInstance instance;
      VkDebugUtilsMessengerEXT debugMessenger;

      void initWindow() {
            glfwInit();

            glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
            glfwWindowHint(GLFW_RESIZABLE, GLFW_FALSE);

            window = glfwCreateWindow(WIDTH, HEIGHT, "Vulkan", nullptr, nullptr);
      }

      void initVulkan() {
            createInstance();
            setupDebugMessenger();
      }

      void mainLoop() {
            while (!glfwWindowShouldClose(window)) {
                  glfwPollEvents();
            }
      }

      void cleanup() {
            if (enableValidationLayers) {
                  DestroyDebugUtilsMessengerEXT(instance, debugMessenger, nullptr);
            }

            vkDestroyInstance(instance, nullptr);

            glfwDestroyWindow(window);

            glfwTerminate();
      }

      void createInstance() {
            if (enableValidationLayers && !checkValidationLayerSupport()) {
                  throw std::runtime_error("validation layers requested, but not available!");
            }

            VkApplicationInfo appInfo{};
            appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
            appInfo.pApplicationName = "Hello Triangle";
            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;

            auto extensions = getRequiredExtensions();
            createInfo.enabledExtensionCount = static_cast<uint32_t>(extensions.size());
            createInfo.ppEnabledExtensionNames = extensions.data();

            VkDebugUtilsMessengerCreateInfoEXT debugCreateInfo;
            if (enableValidationLayers) {
                  createInfo.enabledLayerCount = static_cast<uint32_t>(validationLayers.size());
                  createInfo.ppEnabledLayerNames = validationLayers.data();

                  populateDebugMessengerCreateInfo(debugCreateInfo);
                  createInfo.pNext = (VkDebugUtilsMessengerCreateInfoEXT*)&debugCreateInfo;
            }
            else {
                  createInfo.enabledLayerCount = 0;

                  createInfo.pNext = nullptr;
            }

            VkResult result = vkCreateInstance(&createInfo, nullptr, &instance);

            std::cout << result << std::endl;

            if (result != VK_SUCCESS) {
                  throw std::runtime_error("failed to create instance! : " + result);
            }
      }

      void populateDebugMessengerCreateInfo(VkDebugUtilsMessengerCreateInfoEXT& createInfo) {
            createInfo = {};
            createInfo.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT;
            createInfo.messageSeverity = VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT;
            createInfo.messageType = VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT;
            createInfo.pfnUserCallback = debugCallback;
      }

      void setupDebugMessenger() {
            if (!enableValidationLayers) return;

            VkDebugUtilsMessengerCreateInfoEXT createInfo;
            populateDebugMessengerCreateInfo(createInfo);

            if (CreateDebugUtilsMessengerEXT(instance, &createInfo, nullptr, &debugMessenger) != VK_SUCCESS) {
                  throw std::runtime_error("failed to set up debug messenger!");
            }
      }

      std::vector<const char*> getRequiredExtensions() {
            uint32_t glfwExtensionCount = 0;
            const char** glfwExtensions;
            glfwExtensions = glfwGetRequiredInstanceExtensions(&glfwExtensionCount);

            std::cout << glfwExtensions << std::endl;
            std::cout << glfwExtensionCount << std::endl;

            std::vector<const char*> extensions(glfwExtensions, glfwExtensions + glfwExtensionCount);

            std::cout << extensions[0] << std::endl;
            std::cout << extensions[1] << std::endl;

            if (enableValidationLayers) {
                  extensions.push_back(VK_EXT_DEBUG_UTILS_EXTENSION_NAME);
            }

            return extensions;
      }

      bool checkValidationLayerSupport() {
            uint32_t layerCount;
            vkEnumerateInstanceLayerProperties(&layerCount, nullptr);

            std::vector<VkLayerProperties> availableLayers(layerCount);
            vkEnumerateInstanceLayerProperties(&layerCount, availableLayers.data());

            for (const char* layerName : validationLayers) {
                  bool layerFound = false;

                  for (const auto& layerProperties : availableLayers) {
                        if (strcmp(layerName, layerProperties.layerName) == 0) {
                              layerFound = true;
                              break;
                        }
                  }

                  if (!layerFound) {
                        return false;
                  }
            }

            return true;
      }

      static VKAPI_ATTR VkBool32 VKAPI_CALL debugCallback(VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageType, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData, void* pUserData) {
            std::cerr << "validation layer: " << pCallbackData->pMessage << std::endl;

            return VK_FALSE;
      }
};

int main() {
      HelloTriangleApplication app;

      try {
            app.run();
      }
      catch (const std::exception& e) {
            std::cerr << e.what() << std::endl;
            return EXIT_FAILURE;
      }

      return EXIT_SUCCESS;
}
```

validation layer がうまくいかない

あまりに基礎的な質問ですみません。簡潔に話すとC++でDLLを作ったのですが、DLLではなく実行ファイル（exe)に初めから埋め込められている状態で動かす状態より、遥かに動作が重くて使いものになりませんでした。で、気になったのですがDLL経由で関数を作ると動作が重くなるのでしょうか？

詳しく話すと下記のgithubを参考にVulkanで三角形を表示するプログラムを書きました。
https://github.com/bwasty/vulkan-tutorial-hpp/blob/master/steps/15_hello_triangle.cpp

で、その次に下記のgithubを参考に、毎フレームごとにウィンドウに表示されている画像をコピーする関数を作って毎フレーム呼び出しました。
https://github.com/SaschaWillems/Vulkan/blob/master/examples/screenshot/screenshot.cpp

この時点では動画は60fpsでも非常に軽く問題はありませんでした。

ところが、その毎フレームごとにウィンドウに表示されている関数をDLL経由で使用したら、動作が非常に重くて使い物になりませんでした。私のPCの環境のタスクマネージャーで普通にexeに埋め込まれている時から5倍から重くなりました。

一体どういうことなのでしょうか？よろしくお願いします。