Changeset e1a7f5a in opengl-game

Timestamp:

Aug 16, 2019, 3:47:01 PM (5 years ago)

Author:

Dmitry Portnoy <dmitry.portnoy@…>

Branches:

feature/imgui-sdl, master, points-test

Children:

5936c58

Parents:

5f3dba8

Message:

Copy an SDL Texture to a Vulkan texture to use as a UI overlay on the 3D scene

Files:

• README.txt (modified) (1 diff)
• shaders/shader.frag (modified) (1 diff)
• shaders/shader.vert (modified) (1 diff)
• vulkan-game.cpp (modified) (12 diffs)

README.txt

@@ -105 +105 @@
                                 1   v
                                     1
+
+DEPLOYMENT
+-----------
+
+The deploy folder has an old Inno Setup script for deploying the game on Windows.
+
+I should check out IzPack. Seems to be a cross-platform solution.

shaders/shader.frag

@@ -13 +13 @@
 void main() {
    if (isOverlay == 1) {
-      outColor = vec4(fragColor * texture(uiTexSampler, fragTexCoord).rgb, 0.3);
+      outColor = vec4(fragColor * texture(uiTexSampler, fragTexCoord).rgb, 1.0);
    } else {
       outColor = vec4(fragColor * texture(texSampler, fragTexCoord).rgb, 1.0);

shaders/shader.vert

@@ -23 +23 @@
    } else {
       gl_Position = vec4(inPosition, 1.0);
-      fragColor = vec3(0.0, 1.0, 1.0);
+      fragColor = vec3(1.0, 1.0, 1.0);
       isOverlay = 1;
    }

vulkan-game.cpp

@@ -32 +32 @@
 using namespace std;
 
+// TODO: Maybe add asserts for testing
+
 const int SCREEN_WIDTH = 800;
 const int SCREEN_HEIGHT = 600;
@@ -182 +184 @@
       VkSurfaceKHR surface;
 
-      // TODO: It seems that I can call all the same draw functions on an SDL_Renderer that I can
-      // on an SDL_Surface, so I should use gRenderer (probably after renaming it) instead of getting
-      // sdlSurface from the created window
-      SDL_Surface* sdlSurface = nullptr;
-
       VkPhysicalDevice physicalDevice = VK_NULL_HANDLE;
       VkDevice device;
@@ -221 +218 @@
       VkImageView overlayImageView;
 
+      VkImage sdlOverlayImage;
+      VkDeviceMemory sdlOverlayImageMemory;
+      VkImageView sdlOverlayImageView;
+
       VkSampler textureSampler;
 
@@ -268 +269 @@
          }
 
-         uiOverlay = SDL_CreateTexture(gRenderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, SCREEN_WIDTH, SCREEN_HEIGHT);
+         uiOverlay = SDL_CreateTexture(gRenderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_STREAMING, SCREEN_WIDTH, SCREEN_HEIGHT);
          if (uiOverlay == nullptr) {
             cout << "Unable to create blank texture! SDL Error: " << SDL_GetError() << endl;
@@ -333 +334 @@
          createFramebuffers();
          createImageResources("textures/texture.jpg", textureImage, textureImageMemory, textureImageView);
-         createImageResources("textures/space.jpg", overlayImage, overlayImageMemory, overlayImageView);
+         createImageResourcesFromSDLTexture(uiOverlay, sdlOverlayImage, sdlOverlayImageMemory, sdlOverlayImageView);
          createTextureSampler();
          createVertexBuffer();
@@ -444 +445 @@
 
       void createSurface() {
-         sdlSurface = SDL_GetWindowSurface(window);
-
-         if (sdlSurface == nullptr) {
-            cout << "Could not get SDL Surface! =(" << endl;
-         }
-
          if (gui->CreateVulkanSurface(instance, &surface) == RTWO_ERROR) {
             throw runtime_error("failed to create window surface!");
@@ -1087 +1082 @@
       }
 
+      void createImageResourcesFromSDLTexture(SDL_Texture* texture, VkImage& image, VkDeviceMemory& imageMemory, VkImageView& view) {
+         int a, w, h;
+
+         // I only need this here for the width and height, which are constants, so just use those instead
+         SDL_QueryTexture(texture, nullptr, &a, &w, &h);
+         //cout << "TEXTURE INFO" << endl;
+         //cout << "w: " << w << endl;
+         //cout << "h: " << h << endl;
+
+         createImage(w, h, VK_FORMAT_R8G8B8A8_UNORM, VK_IMAGE_TILING_OPTIMAL,
+            VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT,
+            VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, image, imageMemory);
+
+         view = createImageView(image, VK_FORMAT_R8G8B8A8_UNORM, VK_IMAGE_ASPECT_COLOR_BIT);
+      }
+
+      void populateImageFromSDLTexture(SDL_Texture* texture, VkImage& image) {
+         int a, w, h, pitch;
+
+         SDL_QueryTexture(texture, nullptr, &a, &w, &h);
+
+         VkDeviceSize imageSize = w * h * 4;
+         unsigned char* pixels = new unsigned char[imageSize];
+
+         SDL_RenderReadPixels(gRenderer, nullptr, SDL_PIXELFORMAT_ABGR8888, pixels, w * 4);
+
+         VkBuffer stagingBuffer;
+         VkDeviceMemory stagingBufferMemory;
+
+         createBuffer(imageSize,
+            VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
+            VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
+            stagingBuffer, stagingBufferMemory);
+
+         void* data;
+
+         vkMapMemory(device, stagingBufferMemory, 0, VK_WHOLE_SIZE, 0, &data);
+         memcpy(data, pixels, static_cast<size_t>(imageSize));
+
+         VkMappedMemoryRange mappedMemoryRange = {};
+         mappedMemoryRange.sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE;
+         mappedMemoryRange.memory = stagingBufferMemory;
+         mappedMemoryRange.offset = 0;
+         mappedMemoryRange.size = VK_WHOLE_SIZE;
+
+         // TODO: Should probably check that the function succeeded
+         vkFlushMappedMemoryRanges(device, 1, &mappedMemoryRange);
+
+         vkUnmapMemory(device, stagingBufferMemory);
+
+         transitionImageLayout(image, VK_FORMAT_R8G8B8A8_UNORM, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
+         copyBufferToImage(stagingBuffer, image, static_cast<uint32_t>(w), static_cast<uint32_t>(h));
+         transitionImageLayout(image, VK_FORMAT_R8G8B8A8_UNORM, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
+
+         vkDestroyBuffer(device, stagingBuffer, nullptr);
+         vkFreeMemory(device, stagingBufferMemory, nullptr);
+      }
+
       void createImage(uint32_t width, uint32_t height, VkFormat format, VkImageTiling tiling, VkImageUsageFlags usage,
             VkMemoryPropertyFlags properties, VkImage& image, VkDeviceMemory& imageMemory) {
@@ -1452 +1505 @@
             VkDescriptorImageInfo overlayImageInfo = {};
             overlayImageInfo.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
-            overlayImageInfo.imageView = overlayImageView;
+            overlayImageInfo.imageView = sdlOverlayImageView;
             overlayImageInfo.sampler = textureSampler;
 
@@ -1595 +1648 @@
             }
 
-            //drawFrame();
-
             drawUI();
+
+            drawFrame();
          }
 
@@ -1667 +1720 @@
       }
 
-      /* NOTES:
-       *
-       * SDL can already render rects and lines. Rendering circles would be nice, but I can implement it myself
-       * and wouldn't use it that often anyway
-       */
       void drawUI() {
-         SDL_SetRenderTarget(gRenderer, nullptr);
+         // TODO: Since I currently don't use any other render targets,
+         // I may as well set this once before the render loop
+         SDL_SetRenderTarget(gRenderer, uiOverlay);
 
          SDL_SetRenderDrawColor(gRenderer, 0x00, 0x9F, 0x9F, 0xFF);
-                        SDL_RenderClear(gRenderer);
-
-         SDL_SetRenderTarget(gRenderer, uiOverlay);
-
-         SDL_SetRenderDrawColor(gRenderer, 0x00, 0x00, 0x00, 0x00);
          SDL_RenderClear(gRenderer);
 
@@ -1701 +1746 @@
          SDL_RenderDrawLine(gRenderer, 50, 5, 150, 500);
 
-         SDL_SetRenderTarget(gRenderer, nullptr);
-
-         SDL_RenderCopy(gRenderer, uiOverlay, nullptr, nullptr);
-
-         SDL_RenderPresent(gRenderer);
+         populateImageFromSDLTexture(uiOverlay, sdlOverlayImage);
       }
 
@@ -1766 +1807 @@
          vkFreeMemory(device, overlayImageMemory, nullptr);
 
+         vkDestroyImageView(device, sdlOverlayImageView, nullptr);
+         vkDestroyImage(device, sdlOverlayImage, nullptr);
+         vkFreeMemory(device, sdlOverlayImageMemory, nullptr);
+
          vkDestroyDescriptorSetLayout(device, descriptorSetLayout, nullptr);