Adjust documentation to source changes

Author: asuessenbach

en/03_Drawing_a_triangle/00_Setup/01_Instance.adoc

@@ -150,14 +150,17 @@ Or use the tuple:
 
 [,c++]
 ----
-    auto [result, imageIndex] = swapChain->acquireNextImage( UINT64_MAX, **presentCompleteSemaphore[currentFrame], nullptr );
-    if (result == vk::Result::eErrorOutOfDateKHR) {
-        recreateSwapChain();
-        return;
-    }
-    if (result != vk::Result::eSuccess && result != vk::Result::eSuboptimalKHR) {
-        throw std::runtime_error("failed to acquire swap chain image!");
-    }
+		auto [result, imageIndex] = swapChain.acquireNextImage(UINT64_MAX, *presentCompleteSemaphores[frameIndex], nullptr);
+
+		if (result == vk::Result::eErrorOutOfDateKHR)
+		{
+			recreateSwapChain();
+			return;
+		}
+		if (result != vk::Result::eSuccess && result != vk::Result::eSuboptimalKHR)
+		{
+			throw std::runtime_error("failed to acquire swap chain image!");
+		}
 ----
 
 Those examples are from later parts of our tutorial, this is just an example

en/03_Drawing_a_triangle/03_Drawing/03_Frames_in_flight.adoc

@@ -77,35 +77,35 @@ We will use a frame index for that purpose:
 
 [,c++]
 ----
-uint32_t currentFrame = 0;
+uint32_t frameIndex 0;
 ----
 
 The `drawFrame` function can now be modified to use the right objects:
 
 [,c++]
 ----
 void drawFrame() {
-    while ( vk::Result::eTimeout == device.waitForFences( inFlightFences[currentFrame], vk::True, UINT64_MAX ) )
+    while ( vk::Result::eTimeout == device.waitForFences( inFlightFences[frameIndex], vk::True, UINT64_MAX ) )
             ;
-    auto [result, imageIndex] = swapChain.acquireNextImage( UINT64_MAX, presentCompleteSemaphores[currentFrame], nullptr );
+    auto [result, imageIndex] = swapChain.acquireNextImage( UINT64_MAX, presentCompleteSemaphores[frameIndex], nullptr );
 
-    device.resetFences( inFlightFences[currentFrame] );
+    device.resetFences( inFlightFences[frameIndex] );
 
     ...
 
-    commandBuffers[currentFrame].reset();
-    recordCommandBuffer(commandBuffers[currentFrame], imageIndex);
+    commandBuffers[frameIndex].reset();
+    recordCommandBuffer(commandBuffers[frameIndex], imageIndex);
 
     ...
 
     vk::PipelineStageFlags waitDestinationStageMask( vk::PipelineStageFlagBits::eColorAttachmentOutput );
-    const vk::SubmitInfo submitInfo{ .waitSemaphoreCount = 1, .pWaitSemaphores = &*presentCompleteSemaphores[currentFrame],
-                        .pWaitDstStageMask = &waitDestinationStageMask, .commandBufferCount = 1, .pCommandBuffers = &*commandBuffers[currentFrame],
-                        .signalSemaphoreCount = 1, .pSignalSemaphores = &*renderFinishedSemaphores[currentFrame] };
+    const vk::SubmitInfo submitInfo{ .waitSemaphoreCount = 1, .pWaitSemaphores = &*presentCompleteSemaphores[frameIndex],
+                        .pWaitDstStageMask = &waitDestinationStageMask, .commandBufferCount = 1, .pCommandBuffers = &*commandBuffers[frameIndex],
+                        .signalSemaphoreCount = 1, .pSignalSemaphores = &*renderFinishedSemaphores[frameIndex] };
 
     ...
 
-    graphicsQueue.submit(submitInfo, inFlightFences[currentFrame]);
+    graphicsQueue.submit(submitInfo, inFlightFences[frameIndex]);
 }
 ----
 
@@ -116,7 +116,7 @@ Of course, we shouldn't forget to advance to the next frame every time:
 void drawFrame() {
     ...
 
-    currentFrame = (currentFrame + 1) % MAX_FRAMES_IN_FLIGHT;
+    frameIndex = (frameIndex + 1) % MAX_FRAMES_IN_FLIGHT;
 }
 ----
 

en/03_Drawing_a_triangle/04_Swap_chain_recreation.adoc

@@ -87,7 +87,7 @@ Usually happens after a window resize.
 
 [,c++]
 ----
-auto [result, imageIndex] = swapChain.acquireNextImage( UINT64_MAX, *presentCompleteSemaphores[currentFrame], nullptr );
+auto [result, imageIndex] = swapChain.acquireNextImage( UINT64_MAX, *presentCompleteSemaphores[frameIndex], nullptr );
 
 if (result == vk::Result::eErrorOutOfDateKHR) {
     recreateSwapChain();
@@ -113,7 +113,7 @@ if (result == vk::Result::eErrorOutOfDateKHR || result == vk::Result::eSuboptima
     throw std::runtime_error("failed to present swap chain image!");
 }
 
-currentFrame = (currentFrame + 1) % MAX_FRAMES_IN_FLIGHT;
+frameIndex = (frameIndex + 1) % MAX_FRAMES_IN_FLIGHT;
 ----
 
 The `vkQueuePresentKHR` function returns the same values with the same meaning.
@@ -135,10 +135,10 @@ The beginning of `drawFrame` should now look like this:
 
 [,c++]
 ----
-vkWaitForFences(device, 1, &inFlightFences[currentFrame], VK_TRUE, UINT64_MAX);
+vkWaitForFences(device, 1, &inFlightFences[frameIndex], VK_TRUE, UINT64_MAX);
 
 uint32_t imageIndex;
-VkResult result = vkAcquireNextImageKHR(device, swapChain, UINT64_MAX, imageAvailableSemaphores[currentFrame], VK_NULL_HANDLE, &imageIndex);
+VkResult result = vkAcquireNextImageKHR(device, swapChain, UINT64_MAX, imageAvailableSemaphores[frameIndex], VK_NULL_HANDLE, &imageIndex);
 
 if (result == VK_ERROR_OUT_OF_DATE_KHR) {
     recreateSwapChain();
@@ -148,7 +148,7 @@ if (result == VK_ERROR_OUT_OF_DATE_KHR) {
 }
 
 // Only reset the fence if we are submitting work
-vkResetFences(device, 1, &inFlightFences[currentFrame]);
+vkResetFences(device, 1, &inFlightFences[frameIndex]);
 ----
 
 == Handling resizes explicitly

en/04_Vertex_buffers/01_Vertex_buffer_creation.adoc

@@ -230,11 +230,11 @@ We're going to extend the `recordCommandBuffer` function to do that.
 
 [,c++]
 ----
-commandBuffers[currentFrame].bindPipeline(vk::PipelineBindPoint::eGraphics, *graphicsPipeline);
+commandBuffers[frameIndex].bindPipeline(vk::PipelineBindPoint::eGraphics, *graphicsPipeline);
 
-commandBuffers[currentFrame].bindVertexBuffers(0, *vertexBuffer, {0});
+commandBuffers[frameIndex].bindVertexBuffers(0, *vertexBuffer, {0});
 
-commandBuffers[currentFrame].draw(3, 1, 0, 0);
+commandBuffers[frameIndex].draw(3, 1, 0, 0);
 ----
 
 The `vkCmdBindVertexBuffers` function is used to bind vertex buffers to bindings, like the one we set up in the previous chapter.

en/04_Vertex_buffers/03_Index_buffer.adoc

@@ -102,8 +102,8 @@ It's unfortunately not possible to use different indices for each vertex attribu
 
 [,c++]
 ----
-commandBuffers[currentFrame].bindVertexBuffers(0, *vertexBuffer, {0});
-commandBuffers[currentFrame].bindIndexBuffer( *indexBuffer, 0, vk::IndexType::eUint16 );
+commandBuffers[frameIndex].bindVertexBuffers(0, *vertexBuffer, {0});
+commandBuffers[frameIndex].bindIndexBuffer( *indexBuffer, 0, vk::IndexType::eUint16 );
 ----
 
 An index buffer is bound with `vkCmdBindIndexBuffer` which has the index buffer, a byte offset into it, and the type of index data as parameters.
@@ -114,7 +114,7 @@ Remove the `vkCmdDraw` line and replace it with `vkCmdDrawIndexed`:
 
 [,c++]
 ----
-commandBuffers[currentFrame].drawIndexed(indices.size(), 1, 0, 0, 0);
+commandBuffers[frameIndex].drawIndexed(indices.size(), 1, 0, 0, 0);
 ----
 
 A call to this function is very similar to `vkCmdDraw`.

en/05_Uniform_buffers/00_Descriptor_set_layout_and_buffer.adoc

@@ -267,13 +267,17 @@ Create a new function `updateUniformBuffer` and add a call to it from the `drawF
 void drawFrame() {
     ...
 
-    updateUniformBuffer(currentFrame);
+    updateUniformBuffer(frameIndex);
 
     ...
 
-    const vk::SubmitInfo submitInfo{ .waitSemaphoreCount = 1, .pWaitSemaphores = &*presentCompleteSemaphore[currentFrame],
-                            .pWaitDstStageMask = &waitDestinationStageMask, .commandBufferCount = 1, .pCommandBuffers = &*commandBuffers[currentFrame],
-                            .signalSemaphoreCount = 1, .pSignalSemaphores = &*renderFinishedSemaphore[currentFrame] };
+		const vk::SubmitInfo   submitInfo{.waitSemaphoreCount   = 1,
+		                                  .pWaitSemaphores      = &*presentCompleteSemaphores[frameIndex],
+		                                  .pWaitDstStageMask    = &waitDestinationStageMask,
+		                                  .commandBufferCount   = 1,
+		                                  .pCommandBuffers      = &*commandBuffers[frameIndex],
+		                                  .signalSemaphoreCount = 1,
+		                                  .pSignalSemaphores    = &*renderFinishedSemaphores[imageIndex]};
 
     ...
 }

en/05_Uniform_buffers/01_Descriptor_pool_and_sets.adoc

@@ -165,8 +165,8 @@ This needs to be done before the `vkCmdDrawIndexed` call:
 
 [,c++]
 ----
-commandBuffers[currentFrame].bindDescriptorSets(vk::PipelineBindPoint::eGraphics, pipelineLayout, 0, *descriptorSets[currentFrame], nullptr);
-commandBuffers[currentFrame].drawIndexed(indices.size(), 1, 0, 0, 0);
+commandBuffers[frameIndex].bindDescriptorSets(vk::PipelineBindPoint::eGraphics, pipelineLayout, 0, *descriptorSets[frameIndex], nullptr);
+commandBuffers[frameIndex].drawIndexed(indices.size(), 1, 0, 0, 0);
 ----
 
 Unlike vertex and index buffers, descriptor sets are not unique to graphics pipelines.

en/08_Loading_models.adoc

@@ -71,7 +71,7 @@ Remember to also change the `vkCmdBindIndexBuffer` parameter:
 
 [,c++]
 ----
-commandBuffers[currentFrame]->bindIndexBuffer( **indexBuffer, 0, vk::IndexType::eUint32 );
+commandBuffers[frameIndex]->bindIndexBuffer( **indexBuffer, 0, vk::IndexType::eUint32 );
 ----
 
 The tinyobjloader library is included in the same way as STB libraries.

en/11_Compute_Shader.adoc

@@ -443,7 +443,7 @@ This image shows the relation between these two in three dimensions:
 
 image::/images/compute_space.svg[]
 
-The number of dimensions for work groups (defined by `computeCommandBuffers[currentFrame]->dispatch`) and invocations depends (defined by the local sizes in the compute shader) on how input data is structured.
+The number of dimensions for work groups (defined by `computeCommandBuffers[frameIndex]->dispatch`) and invocations depends (defined by the local sizes in the compute shader) on how input data is structured.
 If you e.g.,
 work on a one-dimensional array, like we do in this chapter, you only have to specify the x dimension for both.
 
@@ -534,27 +534,27 @@ We use this to index into our particle array.
 === Dispatch
 
 Now it's time to actually tell the GPU to do some compute.
-This is done by calling `computeCommandBuffers[currentFrame]->dispatch` inside a command buffer.
-While not perfectly true, a dispatch is for compute as a draw call like `commandBuffers[currentFrame]->draw` is for graphics.
+This is done by calling `computeCommandBuffers[frameIndex]->dispatch` inside a command buffer.
+While not perfectly true, a dispatch is for compute as a draw call like `commandBuffers[frameIndex]->draw` is for graphics.
 This dispatches a given number of compute work items in at max.
 three dimensions.
 
 [,c++]
 ----
-computeCommandBuffers[currentFrame]->begin({});
+computeCommandBuffers[frameIndex]->begin({});
 ...
 
-computeCommandBuffers[currentFrame]->bindPipeline(vk::PipelineBindPoint::eCompute, *computePipeline);
-computeCommandBuffers[currentFrame]->bindDescriptorSets(vk::PipelineBindPoint::eCompute, *computePipelineLayout, 0, {computeDescriptorSets[currentFrame]}, {});
+computeCommandBuffers[frameIndex]->bindPipeline(vk::PipelineBindPoint::eCompute, *computePipeline);
+computeCommandBuffers[frameIndex]->bindDescriptorSets(vk::PipelineBindPoint::eCompute, *computePipelineLayout, 0, {computeDescriptorSets[frameIndex]}, {});
 
-computeCommandBuffers[currentFrame]->dispatch( PARTICLE_COUNT / 256, 1, 1 );
+computeCommandBuffers[frameIndex]->dispatch( PARTICLE_COUNT / 256, 1, 1 );
 
 ...
 
-computeCommandBuffers[currentFrame]->end();
+computeCommandBuffers[frameIndex]->end();
 ----
 
-The `computeCommandBuffers[currentFrame]->dispatch` will dispatch `PARTICLE_COUNT / 256` local work groups in the x dimension.
+The `computeCommandBuffers[frameIndex]->dispatch` will dispatch `PARTICLE_COUNT / 256` local work groups in the x dimension.
 As our particle array is linear, we leave the other two dimensions at one, resulting in a one-dimensional dispatch.
 But why do we divide the number of particles (in our array) by 256?
 That's because in the previous paragraph, we defined that every compute shader in a work group will do 256 invocations.
@@ -574,9 +574,9 @@ As our sample does both compute and graphics operations, we'll be doing two subm
 [,c++]
 ----
 ...
-computeQueue->submit(submitInfo, **computeInFlightFences[currentFrame]);
+computeQueue->submit(submitInfo, **computeInFlightFences[frameIndex]);
 ...
-graphicsQueue->submit(submitInfo, **inFlightFences[currentFrame]);
+graphicsQueue->submit(submitInfo, **inFlightFences[frameIndex]);
 ----
 
 The first submit to the compute queue updates the particle positions using the compute shader, and the second submit will then use that updated data to draw the particle system.
@@ -623,30 +623,30 @@ We then use these to synchronize the compute buffer submission with the graphics
 ----
 {
     // Compute submission
-    while ( vk::Result::eTimeout == device->waitForFences(**computeInFlightFences[currentFrame], vk::True, UINT64_MAX) )
+    while ( vk::Result::eTimeout == device->waitForFences(**computeInFlightFences[frameIndex], vk::True, UINT64_MAX) )
         ;
 
-    updateUniformBuffer(currentFrame);
-    device->resetFences( **computeInFlightFences[currentFrame] );
-    computeCommandBuffers[currentFrame]->reset();
+    updateUniformBuffer(frameIndex);
+    device->resetFences( **computeInFlightFences[frameIndex] );
+    computeCommandBuffers[frameIndex]->reset();
     recordComputeCommandBuffer();
 
-    const vk::SubmitInfo submitInfo({}, {}, {**computeCommandBuffers[currentFrame]}, { **computeFinishedSemaphores[currentFrame]});
-    computeQueue->submit(submitInfo, **computeInFlightFences[currentFrame]);
+    const vk::SubmitInfo submitInfo({}, {}, {**computeCommandBuffers[frameIndex]}, { **computeFinishedSemaphores[frameIndex]});
+    computeQueue->submit(submitInfo, **computeInFlightFences[frameIndex]);
 }
 {
     // Graphics submission
-    while ( vk::Result::eTimeout == device->waitForFences(**inFlightFences[currentFrame], vk::True, UINT64_MAX))
+    while ( vk::Result::eTimeout == device->waitForFences(**inFlightFences[frameIndex], vk::True, UINT64_MAX))
 ...
 
-    device->resetFences(  **inFlightFences[currentFrame] );
-    commandBuffers[currentFrame]->reset();
+    device->resetFences(  **inFlightFences[frameIndex] );
+    commandBuffers[frameIndex]->reset();
     recordCommandBuffer(imageIndex);
 
-    vk::Semaphore waitSemaphores[] = {**presentCompleteSemaphore[currentFrame], **computeFinishedSemaphores[currentFrame]};
+    vk::Semaphore waitSemaphores[] = {**presentCompleteSemaphore[frameIndex], **computeFinishedSemaphores[frameIndex]};
     vk::PipelineStageFlags waitDestinationStageMask[] = { vk::PipelineStageFlagBits::eVertexInput, vk::PipelineStageFlagBits::eColorAttachmentOutput };
-    const vk::SubmitInfo submitInfo( waitSemaphores, waitDestinationStageMask, {**commandBuffers[currentFrame]}, {**renderFinishedSemaphore[currentFrame]} );
-    graphicsQueue->submit(submitInfo, **inFlightFences[currentFrame]);
+    const vk::SubmitInfo submitInfo( waitSemaphores, waitDestinationStageMask, {**commandBuffers[frameIndex]}, {**renderFinishedSemaphore[frameIndex]} );
+    graphicsQueue->submit(submitInfo, **inFlightFences[frameIndex]);
 ----
 
 Similar to the sample in the
@@ -724,7 +724,7 @@ vk::SubmitInfo computeSubmitInfo{
     .pWaitSemaphores = &*semaphore,
     .pWaitDstStageMask = waitStages,
     .commandBufferCount = 1,
-    .pCommandBuffers = &*computeCommandBuffers[currentFrame],
+    .pCommandBuffers = &*computeCommandBuffers[frameIndex],
     .signalSemaphoreCount = 1,
     .pSignalSemaphores = &*semaphore
 };
@@ -750,7 +750,7 @@ vk::SubmitInfo graphicsSubmitInfo{
     .pWaitSemaphores = &*semaphore,
     .pWaitDstStageMask = &waitStage,
     .commandBufferCount = 1,
-    .pCommandBuffers = &*commandBuffers[currentFrame],
+    .pCommandBuffers = &*commandBuffers[frameIndex],
     .signalSemaphoreCount = 1,
     .pSignalSemaphores = &*semaphore
 };
@@ -817,9 +817,9 @@ We then bind and draw it like we would with any vertex buffer:
 
 [,c++]
 ----
-commandBuffers[currentFrame]->bindVertexBuffers(0, { *shaderStorageBuffers[currentFrame] }, {0});
+commandBuffers[frameIndex]->bindVertexBuffers(0, { *shaderStorageBuffers[frameIndex] }, {0});
 
-commandBuffers[currentFrame]->draw( PARTICLE_COUNT, 1, 0, 0 );
+commandBuffers[frameIndex]->draw( PARTICLE_COUNT, 1, 0, 0 );
 ----
 
 == Conclusion

en/16_Multiple_Objects.adoc

@@ -257,7 +257,7 @@ void updateUniformBuffers() {
         };
 
         // Copy the UBO data to the mapped memory
-        memcpy(gameObject.uniformBuffersMapped[currentFrame], &ubo, sizeof(ubo));
+        memcpy(gameObject.uniformBuffersMapped[frameIndex], &ubo, sizeof(ubo));
     }
 }
 ----
@@ -274,22 +274,22 @@ void recordCommandBuffer(uint32_t imageIndex) {
     // ... (beginning of the method remains the same)
 
     // Bind vertex and index buffers (shared by all objects)
-    commandBuffers[currentFrame].bindVertexBuffers(0, *vertexBuffer, {0});
-    commandBuffers[currentFrame].bindIndexBuffer(*indexBuffer, 0, vk::IndexType::eUint32);
+    commandBuffers[frameIndex].bindVertexBuffers(0, *vertexBuffer, {0});
+    commandBuffers[frameIndex].bindIndexBuffer(*indexBuffer, 0, vk::IndexType::eUint32);
 
     // Draw each object with its own descriptor set
     for (const auto& gameObject : gameObjects) {
         // Bind the descriptor set for this object
-        commandBuffers[currentFrame].bindDescriptorSets(
+        commandBuffers[frameIndex].bindDescriptorSets(
             vk::PipelineBindPoint::eGraphics,
             *pipelineLayout,
             0,
-            *gameObject.descriptorSets[currentFrame],
+            *gameObject.descriptorSets[frameIndex],
             nullptr
         );
 
         // Draw the object
-        commandBuffers[currentFrame].drawIndexed(indices.size(), 1, 0, 0, 0);
+        commandBuffers[frameIndex].drawIndexed(indices.size(), 1, 0, 0, 0);
     }
 
     // ... (end of the method remains the same)