API tools faq
paste
Guest User

Untitled

a guest
Jun 20th, 2018
74
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 41.24 KB | None | 0 0
raw download clone embed print report
  1. #include <fstream>
  2. #include <iostream>
  3. #include <windows.h>
  4. #include <vector>
  5. #define VK_USE_PLATFORM_WIN32_KHR
  6. #include <C:/VulkanSDK/1.1.73.0/Include/vulkan/vulkan.h>
  7.  
  8. /*
  9. steps to compile:
  10. 1. download nuwen's mingw distro
  11. 2. download lunarg vulkan sdk
  12. 3. correct path names in the #include and also in the mingw command below as necessary and compile:
  13. g++ vulkan1.cpp -o vulkan1.exe -m64 -I C:\VulkanSDK\1.1.73.0\Include\vulkan -L C:\VulkanSDK\1.1.73.0\Lib -l vulkan-1 -lgdi32
  14. if you delete the array on line 250 it causes it to crash
  15. */
  16.  
  17. /* win32 callback function to for the window */
  18. LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
  19. {
  20. switch (message)
  21. {
  22. case WM_DESTROY:
  23. {
  24. DestroyWindow(hWnd);
  25. PostQuitMessage(0);
  26. }
  27. break;
  28. default:
  29. return DefWindowProc(hWnd, message, wParam, lParam);
  30. break;
  31. }
  32. }
  33.  
  34.  
  35. INT WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
  36. {
  37.  
  38. /* win32 initialization code */
  39. unsigned int windowWidth = 1280;
  40. unsigned int windowHeight = 720;
  41. HINSTANCE windowInstance;
  42. HWND window;
  43. const char * applicationName = "Triangle";
  44. AllocConsole();
  45. AttachConsole(GetCurrentProcessId());
  46. freopen("CON", "w", stdout);
  47. freopen("CON", "w", stderr);
  48. SetConsoleTitle(TEXT(applicationName));
  49.  
  50. WNDCLASSEX windowInfo =
  51. {
  52. sizeof(WNDCLASSEX), //UINT cbSize;
  53. CS_HREDRAW | CS_VREDRAW, //UINT style;
  54. WndProc, //WNDPROC lpfnWndProc;
  55. 0, //int cbClsExtra;
  56. 0, //int cbWndExtra;
  57. windowInstance, //HINSTANCE hInstance;
  58. LoadIcon(NULL, IDI_APPLICATION), //HICON hIcon;
  59. LoadCursor(NULL, IDC_ARROW), //HCURSOR hCursor;
  60. (HBRUSH)GetStockObject(BLACK_BRUSH), //HBRUSH hbrBackground;
  61. NULL, //LPCTSTR lpszMenuName;
  62. applicationName, //LPCTSTR lpszClassName;
  63. LoadIcon(NULL, IDI_APPLICATION) //HICON hIconSm;
  64. };
  65.  
  66. RegisterClassEx(&windowInfo);
  67. int windowFlags = WS_OVERLAPPEDWINDOW | WS_CLIPSIBLINGS | WS_CLIPCHILDREN;
  68. window = CreateWindowEx( 0, applicationName, applicationName, windowFlags, 0, 0, windowWidth+16, windowHeight+38, 0, 0, windowInstance, 0);
  69. ShowWindow(window, SW_SHOW);
  70. SetForegroundWindow(window);
  71. SetFocus(window);
  72. RECT win32Rect;
  73. GetClientRect(window, &win32Rect);
  74.  
  75. /*Create Instance */
  76. VkInstance instance;
  77.  
  78. const char * extensionNameArray[2]{VK_KHR_SURFACE_EXTENSION_NAME, VK_KHR_WIN32_SURFACE_EXTENSION_NAME};
  79.  
  80. VkInstanceCreateInfo instanceInfo =
  81. {
  82. VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, // VkStructureType sType;
  83. NULL, // const void* pNext;
  84. 0, // VkInstanceCreateFlags flags;
  85. NULL, // const VkApplicationInfo* pApplicationInfo;
  86. 0, // uint32_t enabledLayerCount;
  87. NULL, // const char* const* ppEnabledLayerNames;
  88. 2, // uint32_t enabledExtensionCount;
  89. extensionNameArray //const char* const* ppEnabledExtensionNames;
  90. };
  91.  
  92. vkCreateInstance(&instanceInfo, NULL, &instance);
  93.  
  94. /* Create Device */
  95. VkDevice device;
  96.  
  97. std::vector<float> queuePriorities = { 1.0f };
  98.  
  99. uint32_t queueFamilyIndex = 0;
  100.  
  101. VkDeviceQueueCreateInfo deviceQueueInfo =
  102. {
  103. VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, // VkStructureType sType
  104. nullptr, // const void *pNext
  105. 0, // VkDeviceQueueCreateFlags flags
  106. queueFamilyIndex, // uint32_t queueFamilyIndex
  107. static_cast<uint32_t>(queuePriorities.size()), // uint32_t queueCount
  108. &queuePriorities[0] // const float *pQueuePriorities
  109. };
  110.  
  111. const char * deviceExtensionNames[1] = {VK_KHR_SWAPCHAIN_EXTENSION_NAME};
  112. VkDeviceCreateInfo deviceInfo =
  113. {
  114. VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, // VkStructureType sType;
  115. nullptr, // const void* pNext;
  116. 0, // VkDeviceCreateFlags flags;
  117. 1, // uint32_t queueCreateInfoCount;
  118. &deviceQueueInfo, // const VkDeviceQueueCreateInfo* pQueueCreateInfos;
  119. 0, // uint32_t enabledLayerCount;
  120. nullptr, // const char* const* ppEnabledLayerNames;
  121. 1, // uint32_t enabledExtensionCount;
  122. deviceExtensionNames, // const char* const* ppEnabledExtensionNames;
  123. nullptr // const VkPhysicalDeviceFeatures* pEnabledFeatures;
  124. };
  125.  
  126. VkPhysicalDevice physicalDevice;
  127. unsigned deviceCount = 1;
  128. vkEnumeratePhysicalDevices(instance, &deviceCount, &physicalDevice);
  129. vkCreateDevice(physicalDevice, &deviceInfo, NULL, &device);
  130.  
  131. /*Create Queues */
  132. VkQueue graphicsQueue;
  133. VkQueue presentQueue;
  134. vkGetDeviceQueue(device, 0, 0, &graphicsQueue);
  135. vkGetDeviceQueue(device, 0, 0, &presentQueue);
  136.  
  137.  
  138. /*Create Surface*/
  139. VkSurfaceKHR surface;
  140.  
  141. VkWin32SurfaceCreateInfoKHR win32Info =
  142. {
  143. VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR, //VkStructureType sType;
  144. nullptr, //const void* pNext;
  145. 0, //VkWin32SurfaceCreateFlagsKHR flags;
  146. windowInstance, //HINSTANCE hinstance;
  147. window //HWND hwnd;
  148. };
  149.  
  150. vkCreateWin32SurfaceKHR(instance, &win32Info, NULL, &surface);
  151.  
  152.  
  153.  
  154.  
  155.  
  156. /*Create swapchain */
  157. VkSwapchainKHR swapchain;
  158. unsigned imageCount = 1;
  159.  
  160. VkExtent2D extent = {unsigned(win32Rect.right) , unsigned(win32Rect.bottom) };
  161.  
  162. VkSwapchainCreateInfoKHR swapchainCreateInfo =
  163. {
  164. VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR, //VkStructureType sType;
  165. nullptr, //const void* pNext;
  166. 0, //VkSwapchainCreateFlagsKHR flags;
  167. surface, //VkSurfaceKHR surface;
  168. imageCount, //uint32_t minImageCount;
  169. VK_FORMAT_R8G8B8A8_UNORM, //VkFormat imageFormat;
  170. VK_COLOR_SPACE_SRGB_NONLINEAR_KHR, //VkColorSpaceKHR imageColorSpace;
  171. extent, //VkExtent2D imageExtent;
  172. 0, //uint32_t imageArrayLayers;
  173. 0, //VkImageUsageFlags imageUsage;
  174. VK_SHARING_MODE_EXCLUSIVE, //VkSharingMode imageSharingMode;
  175. 1, //uint32_t queueFamilyIndexCount;
  176. 0, //const uint32_t* pQueueFamilyIndices;
  177. (VkSurfaceTransformFlagBitsKHR)0, //VkSurfaceTransformFlagBitsKHR preTransform;
  178. (VkCompositeAlphaFlagBitsKHR)0, //VkCompositeAlphaFlagBitsKHR compositeAlpha;
  179. VK_PRESENT_MODE_MAILBOX_KHR, //VkPresentModeKHR presentMode;
  180. 0, //VkBool32 clipped;
  181. NULL //VkSwapchainKHR oldSwapchain;
  182. };
  183.  
  184. vkCreateSwapchainKHR( device, &swapchainCreateInfo, NULL, &swapchain);
  185. std::vector<VkImage> swapchainImages;
  186. swapchainImages.resize(imageCount);
  187.  
  188.  
  189.  
  190. /*Create renderPass */
  191. VkRenderPass renderPass;
  192.  
  193. VkAttachmentDescription attachmentDescriptions[] =
  194. {
  195. {
  196. 0, // VkAttachmentDescriptionFlags flags
  197. VK_FORMAT_R8G8B8A8_UNORM, // VkFormat format
  198. VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples
  199. VK_ATTACHMENT_LOAD_OP_CLEAR, // VkAttachmentLoadOp loadOp
  200. VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp storeOp
  201. VK_ATTACHMENT_LOAD_OP_DONT_CARE, // VkAttachmentLoadOp stencilLoadOp
  202. VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp stencilStoreOp
  203. VK_IMAGE_LAYOUT_PRESENT_SRC_KHR, // VkImageLayout initialLayout;
  204. VK_IMAGE_LAYOUT_PRESENT_SRC_KHR // VkImageLayout finalLayout
  205. }
  206. };
  207.  
  208. VkAttachmentReference colorAttachmentReferences[] =
  209. {
  210. {
  211. 0, // uint32_t attachment
  212. VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL // VkImageLayout layout
  213. }
  214. };
  215.  
  216. VkSubpassDescription subpassDescriptions[] =
  217. {
  218. {
  219. 0, // VkSubpassDescriptionFlags flags
  220. VK_PIPELINE_BIND_POINT_GRAPHICS, // VkPipelineBindPoint pipelineBindPoint
  221. 0, // uint32_t inputAttachmentCount
  222. nullptr, // const VkAttachmentReference *pInputAttachments
  223. 1, // uint32_t colorAttachmentCount
  224. colorAttachmentReferences, // const VkAttachmentReference *pColorAttachments
  225. nullptr, // const VkAttachmentReference *pResolveAttachments
  226. nullptr, // const VkAttachmentReference *pDepthStencilAttachment
  227. 0, // uint32_t preserveAttachmentCount
  228. nullptr // const uint32_t* pPreserveAttachments
  229. }
  230. };
  231.  
  232. VkRenderPassCreateInfo renderPassInfo =
  233. {
  234. VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, // VkStructureType sType
  235. nullptr, // const void *pNext
  236. 0, // VkRenderPassCreateFlags flags
  237. 1, // uint32_t attachmentCount
  238. attachmentDescriptions, // const VkAttachmentDescription *pAttachments
  239. 1, // uint32_t subpassCount
  240. subpassDescriptions, // const VkSubpassDescription *pSubpasses
  241. 0, // uint32_t dependencyCount
  242. nullptr // const VkSubpassDependency *pDependencies
  243. };
  244.  
  245. if( vkCreateRenderPass( device, &renderPassInfo, nullptr, &renderPass ) != VK_SUCCESS )
  246. {
  247. std::cout << "Failed to create renderpass. \n";
  248. }
  249.  
  250. int asdf[5] = {1,2,3,4,5};
  251.  
  252.  
  253. /* create Framebuffer */
  254. std::vector<VkFramebuffer> frameBuffers;
  255. frameBuffers.resize(swapchainImages.size());
  256. vkGetSwapchainImagesKHR( device, swapchain, &imageCount, &swapchainImages[0]);
  257. for( size_t i = 0; i < swapchainImages.size(); ++i )
  258. {
  259. VkImageViewCreateInfo imageViewCreateInfo =
  260. {
  261. VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, // VkStructureType sType
  262. nullptr, // const void *pNext
  263. 0, // VkImageViewCreateFlags flags
  264. swapchainImages[i], // VkImage image
  265. VK_IMAGE_VIEW_TYPE_2D, // VkImageViewType viewType
  266. VK_FORMAT_R8G8B8A8_UNORM, // VkFormat format
  267. { // VkComponentMapping components
  268. VK_COMPONENT_SWIZZLE_IDENTITY, // VkComponentSwizzle r
  269. VK_COMPONENT_SWIZZLE_IDENTITY, // VkComponentSwizzle g
  270. VK_COMPONENT_SWIZZLE_IDENTITY, // VkComponentSwizzle b
  271. VK_COMPONENT_SWIZZLE_IDENTITY // VkComponentSwizzle a
  272. },
  273. { // VkImageSubresourceRange subresourceRange
  274. VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask
  275. 0, // uint32_t baseMipLevel
  276. 1, // uint32_t levelCount
  277. 0, // uint32_t baseArrayLayer
  278. 1 // uint32_t layerCount
  279. }
  280. };
  281.  
  282. VkImageView imageView;
  283. if( vkCreateImageView(device, &imageViewCreateInfo, nullptr, &imageView ) != VK_SUCCESS )
  284. {
  285. std::cout << "Failed to create image view for framebuffer.\n";
  286. }
  287.  
  288. VkFramebufferCreateInfo framebufferCreateInfo =
  289. {
  290. VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, // VkStructureType sType
  291. nullptr, // const void *pNext
  292. 0, // VkFramebufferCreateFlags flags
  293. renderPass, // VkRenderPass renderPass
  294. 1, // uint32_t attachmentCount
  295. &imageView, // const VkImageView *pAttachments
  296. windowWidth, // uint32_t width
  297. windowHeight, // uint32_t height
  298. 1 // uint32_t layers
  299. };
  300.  
  301. if( vkCreateFramebuffer(device, &framebufferCreateInfo, nullptr, &frameBuffers[i] ) != VK_SUCCESS )
  302. {
  303. std::cout << "Failed to create a framebuffer!\n";
  304. }
  305. }
  306.  
  307.  
  308. /*create Pipeline */
  309. std::vector<char> shaderCode;
  310. std::ifstream is ("vert.spv", std::ifstream::binary);
  311. if (is)
  312. {
  313. // get length of file:
  314. is.seekg (0, is.end);
  315. int length = is.tellg();
  316. is.seekg (0, is.beg);
  317. shaderCode.resize(length);
  318. is.read (shaderCode.data(),length);
  319.  
  320. if (is)
  321. std::cout << "all " << is.gcount() << " characters of vert.spv read successfully. \n";
  322. else
  323. std::cout << "error: only " << is.gcount() << " could be read\n";
  324. is.close();
  325. }
  326.  
  327. VkShaderModuleCreateInfo shaderModuleCreateInfo =
  328. {
  329. VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO, // VkStructureType sType
  330. nullptr, // const void *pNext
  331. 0, // VkShaderModuleCreateFlags flags
  332. shaderCode.size(), // size_t codeSize
  333. reinterpret_cast<const uint32_t*>(&shaderCode[0]) // const uint32_t *pCode
  334. };
  335.  
  336. VkShaderModule vertexShaderModule;
  337. if( vkCreateShaderModule(device, &shaderModuleCreateInfo, nullptr, &vertexShaderModule ) != VK_SUCCESS )
  338. {
  339. std::cout << "Failed to create shader module\n";
  340. }
  341.  
  342. is.open("frag.spv", std::ifstream::binary);
  343. if (is)
  344. {
  345. // get length of file:
  346. is.seekg (0, is.end);
  347. int length = is.tellg();
  348. is.seekg (0, is.beg);
  349. shaderCode.resize(length);
  350. is.read (shaderCode.data(),length);
  351.  
  352. if (is)
  353. std::cout << "all " << is.gcount() << " characters of frag.spv read successfully. \n";
  354. else
  355. std::cout << "error: only " << is.gcount() << " could be read\n";
  356. is.close();
  357. }
  358.  
  359. shaderModuleCreateInfo =
  360. {
  361. VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO, // VkStructureType sType
  362. nullptr, // const void *pNext
  363. 0, // VkShaderModuleCreateFlags flags
  364. shaderCode.size(), // size_t codeSize
  365. reinterpret_cast<const uint32_t*>(&shaderCode[0]) // const uint32_t *pCode
  366. };
  367.  
  368. VkShaderModule fragmentShaderModule;
  369. if( vkCreateShaderModule(device, &shaderModuleCreateInfo, nullptr, &fragmentShaderModule ) != VK_SUCCESS )
  370. {
  371. std::cout << "Failed to create shader module\n";
  372. }
  373.  
  374. std::vector<VkPipelineShaderStageCreateInfo> shaderStageCreateInfos =
  375. {
  376. // Vertex shader
  377. {
  378. VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType
  379. nullptr, // const void *pNext
  380. 0, // VkPipelineShaderStageCreateFlags flags
  381. VK_SHADER_STAGE_VERTEX_BIT, // VkShaderStageFlagBits stage
  382. vertexShaderModule, // VkShaderModule module
  383. "main", // const char *pName
  384. nullptr // const VkSpecializationInfo *pSpecializationInfo
  385. },
  386. // Fragment shader
  387. {
  388. VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType
  389. nullptr, // const void *pNext
  390. 0, // VkPipelineShaderStageCreateFlags flags
  391. VK_SHADER_STAGE_FRAGMENT_BIT, // VkShaderStageFlagBits stage
  392. fragmentShaderModule, // VkShaderModule module
  393. "main", // const char *pName
  394. nullptr // const VkSpecializationInfo *pSpecializationInfo
  395. }
  396. };
  397.  
  398. VkPipelineVertexInputStateCreateInfo vertexInputStateCreateInfo =
  399. {
  400. VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, // VkStructureType sType
  401. nullptr, // const void *pNext
  402. 0, // VkPipelineVertexInputStateCreateFlags flags;
  403. 0, // uint32_t vertexBindingDescriptionCount
  404. nullptr, // const VkVertexInputBindingDescription *pVertexBindingDescriptions
  405. 0, // uint32_t vertexAttributeDescriptionCount
  406. nullptr // const VkVertexInputAttributeDescription *pVertexAttributeDescriptions
  407. };
  408.  
  409. VkPipelineInputAssemblyStateCreateInfo inputAssemblyStateCreateInfo =
  410. {
  411. VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, // VkStructureType sType
  412. nullptr, // const void *pNext
  413. 0, // VkPipelineInputAssemblyStateCreateFlags flags
  414. VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, // VkPrimitiveTopology topology
  415. VK_FALSE // VkBool32 primitiveRestartEnable
  416. };
  417.  
  418. VkViewport viewport =
  419. {
  420. 0.0f, // float x
  421. 0.0f, // float y
  422. float(windowWidth), // float width
  423. float(windowHeight), // float height
  424. 0.0f, // float minDepth
  425. 1.0f // float maxDepth
  426. };
  427.  
  428. VkRect2D scissor =
  429. {
  430. { // VkOffset2D offset
  431. 0, // int32_t x
  432. 0 // int32_t y
  433. },
  434. { // VkExtent2D extent
  435. windowWidth, // int32_t width
  436. windowHeight // int32_t height
  437. }
  438. };
  439.  
  440. VkPipelineViewportStateCreateInfo viewportStateCreateInfo =
  441. {
  442. VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO, // VkStructureType sType
  443. nullptr, // const void *pNext
  444. 0, // VkPipelineViewportStateCreateFlags flags
  445. 1, // uint32_t viewportCount
  446. &viewport, // const VkViewport *pViewports
  447. 1, // uint32_t scissorCount
  448. &scissor // const VkRect2D *pScissors
  449. };
  450.  
  451. VkPipelineRasterizationStateCreateInfo rasterizationStateCreateInfo =
  452. {
  453. VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO, // VkStructureType sType
  454. nullptr, // const void *pNext
  455. 0, // VkPipelineRasterizationStateCreateFlags flags
  456. VK_FALSE, // VkBool32 depthClampEnable
  457. VK_FALSE, // VkBool32 rasterizerDiscardEnable
  458. VK_POLYGON_MODE_FILL, // VkPolygonMode polygonMode
  459. VK_CULL_MODE_BACK_BIT, // VkCullModeFlags cullMode
  460. VK_FRONT_FACE_COUNTER_CLOCKWISE, // VkFrontFace frontFace
  461. VK_FALSE, // VkBool32 depthBiasEnable
  462. 0.0f, // float depthBiasConstantFactor
  463. 0.0f, // float depthBiasClamp
  464. 0.0f, // float depthBiasSlopeFactor
  465. 1.0f // float lineWidth
  466. };
  467.  
  468. VkPipelineMultisampleStateCreateInfo multisampleStateCreateInfo =
  469. {
  470. VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, // VkStructureType sType
  471. nullptr, // const void *pNext
  472. 0, // VkPipelineMultisampleStateCreateFlags flags
  473. VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits rasterizationSamples
  474. VK_FALSE, // VkBool32 sampleShadingEnable
  475. 1.0f, // float minSampleShading
  476. nullptr, // const VkSampleMask *pSampleMask
  477. VK_FALSE, // VkBool32 alphaToCoverageEnable
  478. VK_FALSE // VkBool32 alphaToOneEnable
  479. };
  480.  
  481. VkPipelineColorBlendAttachmentState colorBlendAttachmentState =
  482. {
  483. VK_FALSE, // VkBool32 blendEnable
  484. VK_BLEND_FACTOR_ONE, // VkBlendFactor srcColorBlendFactor
  485. VK_BLEND_FACTOR_ZERO, // VkBlendFactor dstColorBlendFactor
  486. VK_BLEND_OP_ADD, // VkBlendOp colorBlendOp
  487. VK_BLEND_FACTOR_ONE, // VkBlendFactor srcAlphaBlendFactor
  488. VK_BLEND_FACTOR_ZERO, // VkBlendFactor dstAlphaBlendFactor
  489. VK_BLEND_OP_ADD, // VkBlendOp alphaBlendOp
  490. VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | // VkColorComponentFlags colorWriteMask
  491. VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT
  492. };
  493.  
  494. VkPipelineColorBlendStateCreateInfo colorBlendStateCreateInfo =
  495. {
  496. VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, // VkStructureType sType
  497. nullptr, // const void *pNext
  498. 0, // VkPipelineColorBlendStateCreateFlags flags
  499. VK_FALSE, // VkBool32 logicOpEnable
  500. VK_LOGIC_OP_COPY, // VkLogicOp logicOp
  501. 1, // uint32_t attachmentCount
  502. &colorBlendAttachmentState, // const VkPipelineColorBlendAttachmentState *pAttachments
  503. { 0.0f, 0.0f, 0.0f, 0.0f } // float blendConstants[4]
  504. };
  505.  
  506. VkPipelineLayoutCreateInfo layoutCreateInfo =
  507. {
  508. VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, // VkStructureType sType
  509. nullptr, // const void *pNext
  510. 0, // VkPipelineLayoutCreateFlags flags
  511. 0, // uint32_t setLayoutCount
  512. nullptr, // const VkDescriptorSetLayout *pSetLayouts
  513. 0, // uint32_t pushConstantRangeCount
  514. nullptr // const VkPushConstantRange *pPushConstantRanges
  515. };
  516.  
  517. VkPipelineLayout pipelineLayout;
  518. if( vkCreatePipelineLayout(device, &layoutCreateInfo, nullptr, &pipelineLayout ) != VK_SUCCESS )
  519. {
  520. std::cout << "Failed to create a pipeline layout!\n";
  521. }
  522.  
  523. VkGraphicsPipelineCreateInfo pipelineCreateInfo =
  524. {
  525. VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO, // VkStructureType sType
  526. nullptr, // const void *pNext
  527. 0, // VkPipelineCreateFlags flags
  528. static_cast<uint32_t>(shaderStageCreateInfos.size()), // uint32_t stageCount
  529. &shaderStageCreateInfos[0], // const VkPipelineShaderStageCreateInfo *pStages
  530. &vertexInputStateCreateInfo, // const VkPipelineVertexInputStateCreateInfo *pVertexInputState;
  531. &inputAssemblyStateCreateInfo, // const VkPipelineInputAssemblyStateCreateInfo *pInputAssemblyState
  532. nullptr, // const VkPipelineTessellationStateCreateInfo *pTessellationState
  533. &viewportStateCreateInfo, // const VkPipelineViewportStateCreateInfo *pViewportState
  534. &rasterizationStateCreateInfo, // const VkPipelineRasterizationStateCreateInfo *pRasterizationState
  535. &multisampleStateCreateInfo, // const VkPipelineMultisampleStateCreateInfo *pMultisampleState
  536. nullptr, // const VkPipelineDepthStencilStateCreateInfo *pDepthStencilState
  537. &colorBlendStateCreateInfo, // const VkPipelineColorBlendStateCreateInfo *pColorBlendState
  538. nullptr, // const VkPipelineDynamicStateCreateInfo *pDynamicState
  539. pipelineLayout, // VkPipelineLayout layout
  540. renderPass, // VkRenderPass renderPass
  541. 0, // uint32_t subpass
  542. VK_NULL_HANDLE, // VkPipeline basePipelineHandle
  543. -1 // int32_t basePipelineIndex
  544. };
  545.  
  546. VkPipeline graphicsPipeline;
  547. if( vkCreateGraphicsPipelines(device, VK_NULL_HANDLE, 1, &pipelineCreateInfo, nullptr, &graphicsPipeline ) != VK_SUCCESS )
  548. {
  549. std::cout << "Failed to create a graphics pipeline!\n" ;
  550. }
  551.  
  552.  
  553.  
  554. /*create Synchronization objects */
  555. VkImageSubresourceRange imageSubresourceRange =
  556. {
  557. VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask
  558. 0, // uint32_t baseMipLevel
  559. 1, // uint32_t levelCount
  560. 0, // uint32_t baseArrayLayer
  561. 1 // uint32_t layerCount
  562. };
  563.  
  564. VkClearValue clearValue =
  565. {
  566. { 1.0f, 0.0f, 0.0f, 0.0f }, // VkClearColorValue color
  567. };
  568.  
  569. VkImageMemoryBarrier barrierFromDrawToPresent =
  570. {
  571. VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType
  572. nullptr, // const void *pNext
  573. VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, // VkAccessFlags srcAccessMask
  574. VK_ACCESS_MEMORY_READ_BIT, // VkAccessFlags dstAccessMask
  575. VK_IMAGE_LAYOUT_PRESENT_SRC_KHR, // VkImageLayout oldLayout
  576. VK_IMAGE_LAYOUT_PRESENT_SRC_KHR, // VkImageLayout newLayout
  577. 0, // uint32_t srcQueueFamilyIndex
  578. 0, // uint32_t dstQueueFamilyIndex
  579. swapchainImages[0], // VkImage image
  580. imageSubresourceRange // VkImageSubresourceRange subresourceRange
  581. };
  582.  
  583. VkImageMemoryBarrier barrierFromPresentToDraw =
  584. {
  585. VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType
  586. nullptr, // const void *pNext
  587. VK_ACCESS_MEMORY_READ_BIT, // VkAccessFlags srcAccessMask
  588. VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, // VkAccessFlags dstAccessMask
  589. VK_IMAGE_LAYOUT_PRESENT_SRC_KHR, // VkImageLayout oldLayout
  590. VK_IMAGE_LAYOUT_PRESENT_SRC_KHR, // VkImageLayout newLayout
  591. 0, // uint32_t srcQueueFamilyIndex
  592. 0, // uint32_t dstQueueFamilyIndex
  593. swapchainImages[1], // VkImage image
  594. imageSubresourceRange // VkImageSubresourceRange subresourceRange
  595. };
  596.  
  597. VkSemaphoreCreateInfo semaphoreCreateInfo =
  598. {
  599. VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO, // VkStructureType sType
  600. nullptr, // const void* pNext
  601. 0 // VkSemaphoreCreateFlags flags
  602. };
  603.  
  604. VkSemaphore imageAvailableSemaphore;
  605. VkSemaphore renderingFinishedSemaphore;
  606.  
  607. if( (vkCreateSemaphore( device, &semaphoreCreateInfo, nullptr, &imageAvailableSemaphore ) != VK_SUCCESS) ||
  608. (vkCreateSemaphore( device, &semaphoreCreateInfo, nullptr, &renderingFinishedSemaphore ) != VK_SUCCESS) )
  609. {
  610. std::cout << "Could not create semaphores!" << std::endl;
  611. }
  612.  
  613.  
  614.  
  615. /*create and allocate Command Buffer */
  616. std::vector<VkCommandBuffer> commandBuffers;
  617. VkCommandPool commandPool;
  618. commandBuffers.resize(imageCount);
  619. VkCommandPoolCreateInfo comandPoolCreateInfo =
  620. {
  621. VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO, // VkStructureType sType
  622. nullptr, // const void *pNext
  623. 0, // VkCommandPoolCreateFlags flags
  624. queueFamilyIndex // uint32_t queueFamilyIndex
  625. };
  626.  
  627. if( vkCreateCommandPool(device, &comandPoolCreateInfo, nullptr, &commandPool ) != VK_SUCCESS )
  628. {
  629. std::cout << "Failed to create a command pool.\n";
  630. }
  631.  
  632. VkCommandBufferAllocateInfo commandBufferAllocateInfo =
  633. {
  634. VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, // VkStructureType sType
  635. nullptr, // const void *pNext
  636. commandPool, // VkCommandPool commandPool
  637. VK_COMMAND_BUFFER_LEVEL_PRIMARY, // VkCommandBufferLevel level
  638. imageCount // uint32_t bufferCount
  639. };
  640.  
  641. if( vkAllocateCommandBuffers(device, &commandBufferAllocateInfo, commandBuffers.data() ) != VK_SUCCESS )
  642. {
  643. std::cout << "Failed to allocate command buffers.\n";
  644. }
  645.  
  646.  
  647. VkCommandBufferBeginInfo graphicsCommandBufferBeginInfo =
  648. {
  649. VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType
  650. nullptr, // const void *pNext
  651. VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT, // VkCommandBufferUsageFlags flags
  652. nullptr // const VkCommandBufferInheritanceInfo *pInheritanceInfo
  653. };
  654.  
  655. for( size_t i = 0; i < commandBuffers.size(); ++i )
  656. {
  657. vkBeginCommandBuffer( commandBuffers[i], &graphicsCommandBufferBeginInfo );
  658. vkCmdPipelineBarrier( commandBuffers[i], VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, 0, 0, nullptr, 0, nullptr, 1, &barrierFromPresentToDraw );
  659.  
  660. VkRenderPassBeginInfo renderPassBeginInfo =
  661. {
  662. VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, // VkStructureType sType
  663. nullptr, // const void *pNext
  664. renderPass, // VkRenderPass renderPass
  665. frameBuffers[i], // VkFramebuffer framebuffer
  666. { // VkRect2D renderArea
  667. { // VkOffset2D offset
  668. 0, // int32_t x
  669. 0 // int32_t y
  670. },
  671. { // VkExtent2D extent
  672. windowWidth, // int32_t width
  673. windowHeight, // int32_t height
  674. }
  675. },
  676. 1, // uint32_t clearValueCount
  677. &clearValue // const VkClearValue *pClearValues
  678. };
  679.  
  680. vkCmdBeginRenderPass( commandBuffers[i], &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE );
  681. vkCmdBindPipeline( commandBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, graphicsPipeline );
  682. vkCmdDraw( commandBuffers[i], 3, 1, 0, 0 );
  683. vkCmdEndRenderPass( commandBuffers[i] );
  684. vkCmdPipelineBarrier( commandBuffers[i], VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, 0, 0, nullptr, 0, nullptr, 1, &barrierFromDrawToPresent );
  685. vkEndCommandBuffer( commandBuffers[i] );
  686. }
  687.  
  688.  
  689.  
  690.  
  691. uint32_t imageIndex;
  692. VkPipelineStageFlags waitDstStageMask = VK_PIPELINE_STAGE_TRANSFER_BIT;
  693. VkSubmitInfo submitInfo =
  694. {
  695. VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType
  696. nullptr, // const void *pNext
  697. 1, // uint32_t waitSemaphoreCount
  698. &imageAvailableSemaphore, // const VkSemaphore *pWaitSemaphores
  699. &waitDstStageMask, // const VkPipelineStageFlags *pWaitDstStageMask;
  700. 1, // uint32_t commandBufferCount
  701. &commandBuffers[imageIndex], // const VkCommandBuffer *pCommandBuffers
  702. 1, // uint32_t signalSemaphoreCount
  703. &renderingFinishedSemaphore // const VkSemaphore *pSignalSemaphores
  704. };
  705.  
  706. vkAcquireNextImageKHR( device, swapchain, UINT64_MAX, imageAvailableSemaphore, VK_NULL_HANDLE, &imageIndex );
  707. vkQueueSubmit( graphicsQueue, 1, &submitInfo, VK_NULL_HANDLE );
  708.  
  709. VkPresentInfoKHR presentInfo =
  710. {
  711. VK_STRUCTURE_TYPE_PRESENT_INFO_KHR, // VkStructureType sType
  712. nullptr, // const void *pNext
  713. 1, // uint32_t waitSemaphoreCount
  714. &renderingFinishedSemaphore, // const VkSemaphore *pWaitSemaphores
  715. 1, // uint32_t swapchainCount
  716. &swapchain, // const VkSwapchainKHR *pSwapchains
  717. &imageIndex, // const uint32_t *pImageIndices
  718. nullptr // VkResult *pResults
  719. };
  720.  
  721.  
  722. MSG message;
  723. PeekMessage(&message, 0, 0, 0, PM_REMOVE);
  724. while (message.message != WM_QUIT)
  725. {
  726. TranslateMessage(&message);
  727. DispatchMessage(&message);
  728. vkQueuePresentKHR( presentQueue, &presentInfo);
  729. PeekMessage(&message, 0, 0, 0, PM_REMOVE);
  730. }
  731.  
  732. vkResetCommandPool( device, commandPool, 0);
  733. vkDestroySwapchainKHR( device, swapchain,NULL);
  734. vkDestroyDevice( device, NULL);
  735. vkDestroyInstance( instance, NULL);
  736. return 0;
  737. }
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!