addressing more comments.

Author: gpx1000

en/Building_a_Simple_Engine/Mobile_Development/01_introduction.adoc

@@ -12,7 +12,7 @@ Mobile development presents unique challenges and opportunities for Vulkan appli
 
 This chapter will guide you through the complex landscape of mobile Vulkan development, where desktop assumptions often don't apply. We'll start by examining the platform-specific requirements of Android and iOS, which present unique challenges in setup, lifecycle management, and input handling. Mobile applications face constraints that desktop applications rarely encounter—sudden interruptions, battery concerns, and varying hardware capabilities all require careful consideration in your engine design.
 
-Performance optimization takes on critical importance in mobile environments where every watt of power consumption and every millisecond of frame time affects user experience. We'll explore essential techniques like power-of-two texture usage and efficient texture formats, along with mobile-specific optimizations that can mean the difference between smooth performance and user frustration.
+Performance optimization takes on critical importance in mobile environments where every watt of power consumption and every millisecond of frame time affects user experience. We'll explore essential techniques like efficient texture formats, along with mobile-specific optimizations that can mean the difference between smooth performance and user frustration.
 
 Understanding the fundamental architectural differences between mobile and desktop GPUs becomes essential for effective optimization. We'll compare Tile-Based Rendering (TBR) and Immediate Mode Rendering (IMR) approaches, helping you understand why techniques that work well on desktop might perform poorly on mobile, and how to design rendering strategies that leverage mobile GPU strengths.
 

en/Building_a_Simple_Engine/Mobile_Development/05_vulkan_extensions.adoc

@@ -148,7 +148,7 @@ This extension enhances dynamic rendering by allowing fragment shaders to read f
 
 Key benefits include:
 
-1. *Reduced Memory Bandwidth*: Reads happen from on-chip memory rather than main memory, reducing bandwidth usage by up to 30% in bandwidth-intensive operations.
+1. *Reduced Memory Bandwidth*: Reads happen from on-chip memory rather than main memory, reducing bandwidth usage for bandwidth-intensive operations.
 2. *Improved Performance*: Particularly for algorithms that need to read from previously written attachments.
 3. *Power Efficiency*: Lower memory bandwidth means lower power consumption.
 
@@ -222,7 +222,7 @@ This extension allows shaders to:
 1. *Access Tile Memory Directly*: Read and write to the current tile's memory without going through main memory.
 2. *Perform Tile-Local Operations*: Execute operations that stay entirely within the tile memory.
 3. *Optimize Bandwidth-Intensive Algorithms*: Particularly beneficial for post-processing effects.
-4. *Reduce Memory Bandwidth*: Can reduce memory bandwidth usage by up to 30% for rendering workloads that involve multiple passes.
+4. *Reduce Memory Bandwidth*: Helps lower memory bandwidth by keeping data in tile-local memory during multi-pass workloads.
 
 ==== How It Reduces Memory Bandwidth
 
@@ -232,7 +232,7 @@ The `VK_EXT_shader_tile_image` extension is particularly effective at reducing m
 
 2. *Eliminates Intermediate Memory Transfers*: Without this extension, multi-pass rendering requires writing results to main memory after each pass and reading them back for the next pass. With `VK_EXT_shader_tile_image`, these intermediate results can stay in tile memory, eliminating these costly transfers.
 
-3. *Bandwidth Savings Measurements*: Testing on various mobile GPUs has shown memory bandwidth reductions of up to 30% for complex rendering pipelines that use multiple passes, such as those involving post-processing effects.
+3. *Bandwidth Savings Measurements*: Testing on various mobile GPUs has shown meaningful bandwidth reductions for complex multi-pass pipelines; actual gains are workload- and GPU-dependent.
 
 4. *Practical Applications*:
    - *Image Processing Filters*: Applying multiple filters (blur, sharpen, color correction) can be done without leaving tile memory.
@@ -308,36 +308,35 @@ vk::Device device = physical_device.createDevice(device_create_info);
 // ...
 ----
 
-=== Vendor-Specific Extension Support
+=== Device Extension Support
 
-Different mobile vendors may have varying levels of support for Vulkan extensions. Understanding these differences can help you optimize your application for specific hardware.
+Different mobile vendors and devices vary in which Vulkan extensions they expose. Understanding per-device support helps you pick features safely at runtime.
 
-==== Vendor-Specific Extension Support Details
+==== Device Extension Support Details
 
 Different mobile GPU vendors have varying levels of support for Vulkan extensions:
 
 * *Dynamic Rendering Support*: Many mobile GPUs have optimized
 implementations of `VK_KHR_dynamic_rendering`. This can lead to significant performance improvements compared to traditional render passes, especially on tile-based renderers.
 
-* *Tile-Based Optimizations*: For devices with tile-based renderers
-(including Mali, PowerVR, and many others), extensions like `VK_EXT_shader_tile_image` and `VK_KHR_dynamic_rendering_local_read` are particularly effective. These extensions can reduce memory bandwidth by up to 30% in some scenarios.
+* *Tile-Based Optimizations*: On tile-based GPUs (e.g., Mali, PowerVR), `VK_EXT_shader_tile_image` and `VK_KHR_dynamic_rendering_local_read` are effective because they keep reads and writes in tile memory. See the extension sections above for details; benefits are workload- and GPU-dependent.
 
-* *Checking for Vendor-Specific Extension Support*:
+* *Checking for Extension Support (EXT/KHR) on the current device*:
 
 [source,cpp]
 ----
-// Common vendor IDs
+// Common vendor IDs (used here only for labeling/logging output)
 const uint32_t VENDOR_ID_QUALCOMM = 0x5143; // Adreno
 const uint32_t VENDOR_ID_ARM = 0x13B5;      // Mali
 const uint32_t VENDOR_ID_IMAGINATION = 0x1010; // PowerVR
 const uint32_t VENDOR_ID_HUAWEI = 0x19E5;   // Kirin
 const uint32_t VENDOR_ID_APPLE = 0x106B;    // Apple
 
-bool check_vendor_extension_support(vk::PhysicalDevice physical_device) {
+bool log_device_extension_support(vk::PhysicalDevice physical_device) {
     vk::PhysicalDeviceProperties props = physical_device.getProperties();
     std::string vendor_name;
 
-    // Identify vendor
+    // Identify vendor for display purposes only
     switch (props.vendorID) {
         case VENDOR_ID_QUALCOMM: vendor_name = "Qualcomm"; break;
         case VENDOR_ID_ARM: vendor_name = "ARM Mali"; break;
@@ -347,7 +346,7 @@ bool check_vendor_extension_support(vk::PhysicalDevice physical_device) {
         default: vendor_name = "Unknown"; break;
     }
 
-    // Check for extensions that work well on mobile devices
+    // Check for widely useful EXT/KHR extensions on this device
     auto available_extensions = physical_device.enumerateDeviceExtensionProperties();
     bool has_dynamic_rendering = false;
     bool has_dynamic_rendering_local_read = false;
@@ -374,7 +373,7 @@ bool check_vendor_extension_support(vk::PhysicalDevice physical_device) {
 }
 ----
 
-* *Vendor-Specific Optimizations*: When developing for mobile devices,
+* *Platform-Specific Optimizations*: When developing for mobile devices,
 consider these optimizations:
    - Prioritize the use of dynamic rendering over traditional render passes on tile-based renderers
    - Use tile-based extensions whenever available

en/Building_a_Simple_Engine/Mobile_Development/06_conclusion.adoc

@@ -4,61 +4,6 @@
 
 == Conclusion
 
-In this chapter, we've explored the key aspects of adapting your Vulkan engine for mobile platforms. Let's summarize what we've learned and discuss how to apply these techniques in your own projects.
-
-=== What We've Learned
-
-==== Platform Considerations for Android and iOS
-
-We started by examining the specific requirements and constraints of developing Vulkan applications for Android and iOS:
-
-* Setting up Vulkan on Android using the NDK
-* Using MoltenVK to bring Vulkan to iOS
-* Managing the complex lifecycle of mobile applications
-* Handling platform-specific input methods
-* Creating cross-platform abstractions to maintain a single codebase
-* Addressing vendor-specific considerations like custom Android versions and alternative app stores
-
-Understanding these platform-specific considerations is essential for creating a robust mobile application that behaves correctly across different devices and operating systems.
-
-==== Performance Optimizations for Mobile
-
-We then explored key performance optimizations for mobile hardware:
-
-* Using power-of-two textures for better hardware acceleration and memory alignment
-* Selecting efficient texture formats like ASTC, ETC2, and PVRTC
-* Minimizing memory allocations through pooling and suballocation
-* Reducing bandwidth usage with optimized vertex formats and smaller data types
-* Optimizing draw calls through instancing, batching, and LOD systems
-* Leveraging vendor-specific optimizations for different mobile GPU architectures
-
-These optimizations help address the limited resources available on mobile devices, ensuring your application runs smoothly while conserving battery life.
-
-==== Rendering Approaches: TBR vs IMR
-
-Next, we compared the two main rendering architectures found in mobile GPUs:
-
-* Tile-Based Rendering (TBR): How it works, its advantages, and specific optimizations
-* Immediate Mode Rendering (IMR): How it works, its advantages, and specific optimizations
-* Detecting the rendering architecture and adapting your engine accordingly
-* Best practices that work well for both architectures
-* Identifying TBR GPUs from major vendors including Qualcomm, PowerVR, ARM Mali, Apple, and Huawei
-
-Understanding these different rendering approaches allows you to optimize your engine for the specific hardware it's running on, maximizing performance across a wide range of devices.
-
-==== Vulkan Extensions for Mobile
-
-Finally, we explored Vulkan extensions that can significantly improve performance on mobile devices:
-
-* VK_KHR_dynamic_rendering: Simplifying the rendering workflow
-* VK_KHR_dynamic_rendering_local_read: Enabling efficient reads from attachments in tile memory
-* VK_EXT_shader_tile_image: Providing direct access to tile memory in shaders
-* Combining these extensions for maximum performance
-* Best practices for using extensions in a cross-platform engine
-* Vendor-specific extension support and how different mobile GPU vendors implement these extensions
-
-These extensions leverage the unique characteristics of mobile GPUs, particularly tile-based renderers, to achieve better performance and power efficiency.
-
 === Putting It All Together
 
 Let's see how all these components can work together in a complete mobile-optimized Vulkan application:
@@ -216,51 +161,38 @@ private:
 };
 ----
 
-=== Best Practices for Mobile Vulkan Development
-
-Based on what we've covered in this chapter, here are some best practices for mobile Vulkan development:
-
-1. *Design for Platform Differences*: Create abstractions that handle platform-specific differences while maintaining a single core codebase.
-
-2. *Optimize for Limited Resources*: Always consider the limited memory, bandwidth, and power available on mobile devices.
-
-3. *Adapt to the Rendering Architecture*: Optimize your rendering pipeline based on whether the device uses TBR or IMR.
+=== Ship-Ready Checklist
 
-4. *Use Hardware-Accelerated Formats*: Choose texture formats that are natively supported by the hardware.
+1. Feature detection and fallbacks: Probe EXT/KHR support at startup, enable conditionally, and maintain tested fallback paths.
+2. Render path selection: Switch between TBR-friendly and IMR-neutral paths at runtime based on a simple vendor/heuristic check.
+3. Framebuffer read policy: Prefer tile-local, per-pixel reads (input attachments or dynamic rendering local read). Avoid patterns that force external memory round-trips.
+4. Textures and assets: Use KTX2 as the container; prefer ASTC when available with ETC2/PVRTC fallbacks as needed. Generate mipmaps offline.
+5. Memory/attachments: Use transient attachments where results aren’t needed after the pass; suballocate to minimize fragmentation.
+6. Thermal/perf governor: Implement dynamic resolution or quality tiers and sensible FPS caps to keep thermals in check.
+7. Instrumentation: Add GPU markers/timestamps, frame-time histograms, and bandwidth proxies to track regressions.
+8. Device matrix: Maintain a small, representative device lab (different vendors/tiers) and run sanity scenes regularly.
 
-5. *Leverage Vulkan Extensions*: Take advantage of mobile-specific extensions when available.
+=== Validation and Profiling Playbook
 
-6. *Test on Real Devices*: Emulators and simulators don't accurately represent real-world performance.
+- Validate correctness:
+  * Swapchain details (present mode, min image count) per device.
+  * Layout transitions and access masks, especially when using local read.
+  * Synchronization between rendering scopes and compute/transfer work.
+- Profile efficiently:
+  * Use platform tools (e.g., Android GPU Inspector, RenderDoc, Xcode GPU Capture) to identify tile flushes, overdraw, and bandwidth hot spots.
+  * A/B test: classic render pass vs dynamic rendering, local read on/off, tile-image on/off.
+  * Track power and thermals over multi‑minute runs, not just single frames.
 
-7. *Monitor Performance Metrics*: Track frame times, memory usage, and power consumption to identify bottlenecks.
+=== Next Steps
 
-8. *Provide Quality Options*: Allow users to adjust quality settings based on their device's capabilities.
-
-=== Future Directions
-
-Mobile graphics hardware continues to evolve rapidly. Here are some trends to watch:
-
-* *Unified Memory Architectures*: More mobile SoCs are adopting unified memory, which can change how you optimize memory access.
-* *Ray Tracing on Mobile*: As ray tracing hardware becomes more common on mobile devices, new optimization techniques will emerge.
-* *AI-Enhanced Rendering*: Mobile GPUs are increasingly incorporating AI acceleration, which can be leveraged for rendering tasks.
-* *Cross-Platform Development*: Tools and frameworks for cross-platform development continue to improve, making it easier to target multiple platforms.
-* *Mobile GPU Innovations*: Mobile GPU vendors continue to advance their technologies with each generation, introducing new features and optimizations that can be leveraged through Vulkan.
-
-=== Final Thoughts
-
-Developing for mobile platforms presents unique challenges, but also offers exciting opportunities to reach a wider audience. By understanding the specific characteristics of mobile hardware and optimizing your Vulkan engine accordingly, you can create high-performance applications that provide a great user experience while efficiently using the limited resources available on mobile devices.
-
-Remember that mobile optimization is an ongoing process. As new devices, architectures, and extensions emerge, continue to refine your engine to take advantage of these advancements.
+- Integrate a capability layer that exposes feature bits (dynamic rendering, local read, tile image) to higher-level systems.
+- Add automated startup probes that dump device/feature info to logs for field telemetry.
+- Expand the regression scene suite to cover TBR‑sensitive and bandwidth‑heavy paths.
 
 === Code Examples
 
 The complete code for this chapter can be found in the following files:
 
-* `simple_engine/36_mobile_platform_integration.cpp`: Implementation of platform-specific integration for Android and iOS
-* `simple_engine/37_mobile_optimizations.cpp`: Implementation of performance optimizations for mobile
-* `simple_engine/38_tbr_optimizations.cpp`: Implementation of optimizations for tile-based renderers
-* `simple_engine/39_mobile_extensions.cpp`: Implementation of mobile-specific Vulkan extensions
-
 link:../../attachments/simple_engine/36_mobile_platform_integration.cpp[Mobile Platform Integration C{pp} code]
 link:../../attachments/simple_engine/37_mobile_optimizations.cpp[Mobile Optimizations C{pp} code]
 link:../../attachments/simple_engine/38_tbr_optimizations.cpp[TBR Optimizations C{pp} code]