- Update multiple Vulkan tutorial sections and examples with improvements and fixes

   - Add frame time-based rotation to `36_multiple_objects.cpp` for consistent object rotation speed.
   - Enhance Vulkan Configurator documentation for clarity and consistency.
   - Convert `README.md` to AsciiDoc (`README.adoc`) with improved structure and detailed instructions.
   - Include reference links for Khronos formats (glTF, KTX2) and improve descriptions.
   - Refine shared and per-object resource explanations in the multiple objects guide.

Author: gpx1000

attachments/36_multiple_objects.cpp

@@ -1404,16 +1404,20 @@ class VulkanApplication {
 
     void updateUniformBuffers() {
         static auto startTime = std::chrono::high_resolution_clock::now();
+        static auto lastFrameTime = startTime;
         auto currentTime = std::chrono::high_resolution_clock::now();
         float time = std::chrono::duration<float>(currentTime - startTime).count();
+        float deltaTime = std::chrono::duration<float>(currentTime - lastFrameTime).count();
+        lastFrameTime = currentTime;
 
         // Camera and projection matrices (shared by all objects)
         glm::mat4 view = glm::lookAt(glm::vec3(2.0f, 2.0f, 6.0f), glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(0.0f, 1.0f, 0.0f));
         glm::mat4 proj = glm::perspective(glm::radians(45.0f), static_cast<float>(swapChainExtent.width) / static_cast<float>(swapChainExtent.height), 0.1f, 20.0f);
         // Update uniform buffers for each object
         for (auto& gameObject : gameObjects) {
-            // Apply continuous rotation to the object
-            gameObject.rotation.y += 0.001f; // Slow rotation around Y axis
+            // Apply continuous rotation to the object based on frame time
+            const float rotationSpeed = 0.5f; // Rotation speed in radians per second
+            gameObject.rotation.y += rotationSpeed * deltaTime; // Slow rotation around Y axis scaled by frame time
 
             // Get the model matrix for this object
             glm::mat4 model = gameObject.getModelMatrix();

attachments/android/README.md attachments/android/README.adocattachments/android/README.md renamed to attachments/android/README.adoc

@@ -1,34 +1,37 @@
-# Android Project for Vulkan Tutorial
+= Android Project for Vulkan Tutorial
 
 This Android project allows you to run different chapters of the Vulkan Tutorial on Android devices.
 
-## Selecting a Chapter
+== Selecting a Chapter
 
 By default, the project builds and runs the `34_android` chapter. You can select a different chapter by setting the `chapter` property in your Gradle build.
 
-### Available Chapters
+=== Available Chapters
 
-- `34_android`: The Android chapter that uses tinyobjloader to load OBJ models
-- `35_gltf_ktx`: The glTF and KTX chapter that uses tinygltf to load glTF models and KTX to load KTX2 textures
+* `34_android`: The Android chapter that uses tinyobjloader to load OBJ models
+* `35_gltf_ktx`: The glTF and KTX chapter that uses tinygltf to load glTF models and KTX to load KTX2 textures
 
-### How to Select a Chapter
+=== How to Select a Chapter
 
-#### From the Command Line
+==== From the Command Line
 
-```bash
+[source,bash]
+----
 ./gradlew assembleDebug -Pchapter=35_gltf_ktx
-```
+----
 
-#### From Android Studio
+==== From Android Studio
 
 1. Edit the `gradle.properties` file in the project root directory
 2. Add the following line:
-   ```
-   chapter=35_gltf_ktx
-   ```
++
+[source]
+----
+chapter=35_gltf_ktx
+----
 3. Sync the project and build
 
-## Adding New Chapters
+== Adding New Chapters
 
 To add support for a new chapter:
 
@@ -38,7 +41,8 @@ To add support for a new chapter:
 
 For example, to add support for a hypothetical `36_new_feature` chapter:
 
-```cmake
+[source,cmake]
+----
 # Define the list of supported chapters
 set(SUPPORTED_CHAPTERS
     "34_android"
@@ -55,9 +59,9 @@ elseif(CHAPTER STREQUAL "36_new_feature")
     target_link_libraries(vulkan_tutorial_android
         # Add any required libraries here
     )
-    
+
     target_compile_definitions(vulkan_tutorial_android PRIVATE
         # Add any required compile definitions here
     )
 endif()
-```
+----

en/12_Ecosystem_Utilities_and_Compatibility.adoc

@@ -63,11 +63,15 @@ If you're considering using a specific extension:
 
 This helps you decide whether to require the extension or provide a fallback path.
 
-==== Example: Using the vulkanconfig Tool
+==== Example: Using the Vulkan Configurator Tool
 
-The `vulkanconfig` tool is included in the Vulkan SDK and provides a convenient way to configure Vulkan settings on your system. Here's how to use it:
+The Vulkan Configurator tool (executable name `vkconfig` on all platforms) is included in the Vulkan SDK and provides a convenient way to configure Vulkan settings on your system. Here's how to use it:
 
-1. *Launch vulkanconfig*: Open a terminal or command prompt and run `vulkanconfig`
+1. *Launch the Vulkan Configurator*:
+   - On Windows: It's recommended to start "Vulkan Configurator" from the Start menu, as running `vkconfig.exe` from the command line only shows limited options
+   - On other platforms: Open a terminal and run `vkconfig`
+
+   Note that the executable is called `vkconfig` on all platforms.
 
 2. *Configure Validation Layers*:
    - Navigate to the "Layers" tab
@@ -87,12 +91,12 @@ The `vulkanconfig` tool is included in the Vulkan SDK and provides a convenient
    - Save your configuration for later use or to share with team members
    - This ensures consistent Vulkan environments across development machines
 
-Using `vulkanconfig` is particularly helpful when:
+Using the Vulkan Configurator is particularly helpful when:
 - Debugging Vulkan applications with different validation layer configurations
 - Testing your application with different Vulkan settings without modifying code
 - Setting up a development environment with specific Vulkan requirements
 
-==== Using vulkanconfig for Validation Layers Instead of Code
+==== Using Vulkan Configurator for Validation Layers Instead of Code
 
 In many Vulkan applications, validation layers are enabled programmatically during instance creation, typically only in debug builds. Here's how this is commonly done:
 
@@ -142,7 +146,7 @@ While this approach works, it has several drawbacks:
 2. It's harder to experiment with different validation layer configurations
 3. It adds complexity to your codebase
 
-A better approach is to use `vulkanconfig` to manage validation layers externally. Here's how to modify your code to take advantage of this:
+A better approach is to use the Vulkan Configurator to manage validation layers externally. Here's how to modify your code to take advantage of this:
 
 [,c++]
 ----
@@ -162,12 +166,12 @@ void createInstance() {
 With this approach:
 
 1. You remove all validation layer-specific code from your application
-2. You use `vulkanconfig` to enable validation layers when needed
+2. You use the Vulkan Configurator to enable validation layers when needed
 3. You can switch validation configurations without recompiling
 
-To enable validation layers with `vulkanconfig`:
+To enable validation layers with the Vulkan Configurator:
 
-1. Launch `vulkanconfig`
+1. Launch the Vulkan Configurator (from the Start menu on Windows, or run `vkconfig` from the terminal - the executable is called `vkconfig` on all platforms)
 2. Go to the "Layers" tab
 3. Enable the `VK_LAYER_KHRONOS_validation` layer
 4. Apply the settings
@@ -187,7 +191,7 @@ Besides GPUInfo.org, several other tools can help you develop and debug Vulkan a
 
 * *Vulkan SDK Tools*:
 ** `vulkaninfo`: Displays Vulkan capabilities of your local system
-** `vulkanconfig`: A configuration tool for managing Vulkan settings (see <<Example: Using the vulkanconfig Tool>> for details)
+** `vkconfig` (Vulkan Configurator): A configuration tool for managing Vulkan settings (see <<Example: Using the Vulkan Configurator Tool>> for details)
 ** Validation layers: Help identify API usage errors
 ** RenderDoc: Graphics debugging tool
 

en/13_Vulkan_Profiles.adoc

@@ -85,6 +85,9 @@ First, you need to include the Vulkan profiles header:
 
 This header provides the necessary functions and structures to work with Vulkan profiles.
 
+The Vulkan Profiles header is NOT part of the standard Vulkan headers.
+It is only available if you use the Vulkan SDK. Make sure you have the Vulkan SDK installed and properly configured in your development environment.
+
 === Defining the Profile Requirements
 
 Instead of manually checking for features and extensions, you can define your profile requirements:

en/14_Android.adoc

@@ -30,7 +30,7 @@ Now that we understand the key differences, let's set up our Android project. Ou
 
 Before we begin, make sure you have the following tools installed:
 
-* *Android Studio*: The official IDE for Android development
+* *link:++https://developer.android.com/studio[Android Studio]++[Android Studio]*: The official IDE for Android development
 * *Android NDK (Native Development Kit)*: Enables native C++ development on Android
 * *Android SDK*: With a recent API level (24+, which corresponds to Android 7.0 or higher) for Vulkan support
 * *CMake and Ninja build tools*: For building native code (these can be installed through Android Studio)

en/15_GLTF_KTX2_Migration.adoc

@@ -23,7 +23,7 @@ Let's dive into the migration process and see how to adapt our Vulkan applicatio
 
 === What is glTF?
 
-glTF (GL Transmission Format) is a royalty-free specification for the efficient transmission and loading of 3D scenes and models. Developed by the Khronos Group, glTF is designed to be a "JPEG for 3D" - a common publishing format for 3D content.
+https://www.khronos.org/gltf/[glTF] (GL Transmission Format) is a royalty-free specification for the efficient transmission and loading of 3D scenes and models. Developed by the Khronos Group, glTF is designed to be a "JPEG for 3D" - a common publishing format for 3D content.
 
 Key features of glTF include:
 
@@ -70,7 +70,7 @@ Let's compare the OBJ format with glTF:
 
 === What is KTX2?
 
-KTX2 (Khronos Texture 2.0) is a container file format for storing texture data optimized for GPU usage. It's designed to work efficiently with modern graphics APIs like Vulkan, OpenGL, and DirectX.
+https://www.khronos.org/ktx/[KTX2] (Khronos Texture 2.0) is a container file format for storing texture data optimized for GPU usage. It's designed to work efficiently with modern graphics APIs like Vulkan, OpenGL, and DirectX.
 
 Key features of KTX2 include:
 

en/16_Multiple_Objects.adoc

@@ -15,13 +15,15 @@ When rendering multiple objects, we need to consider which resources should be:
 Here's a quick reference for what typically falls into each category:
 
 *Shared resources:*
+
 * Vertex and index buffers (when objects use the same mesh)
 * Textures and samplers (when objects use the same textures)
 * Pipeline objects and pipeline layouts
 * Render passes
 * Command pools
 
 *Per-object resources:*
+
 * Transformation matrices (position, rotation, scale)
 * Uniform buffers containing those matrices
 * Descriptor sets that reference those uniform buffers
@@ -306,14 +308,16 @@ When rendering multiple objects, keep these performance considerations in mind:
 == Conclusion
 
 You've now learned how to render multiple objects in Vulkan by:
+
 1. Creating a structure to hold per-object data
-2. Duplicating the necessary resources (uniform buffers, descriptor sets) for each object
+2. Duplicating the necessary resources with (uniform buffers, descriptor sets) for each object
 3. Sharing resources that can be reused (vertex/index buffers, pipeline, textures)
 4. Updating the rendering loop to draw each object with its own transformation
 
 This approach gives you the flexibility to position, rotate, and scale objects independently while maintaining good performance by sharing resources where appropriate.
 
 In a real-world application, you might extend this system with:
+
 * Object hierarchies (parent-child relationships)
 * Different meshes and materials for different objects
 * Frustum culling to avoid rendering objects outside the camera view