address comments

Author: gpx1000

en/01_Overview.adoc

@@ -28,7 +28,7 @@ with the existing APIs somehow. This resulted in less than ideal abstractions
 Aside from these new features, the past decade also saw an influx of mobile
 and embedded devices with powerful graphics hardware. These mobile GPUs have
  different architectures based on their energy and space requirements.
-One such example is https://en.wikipedia.org/wiki/Tiled_rendering[tiled rendering], 
+One such example is https://en.wikipedia.org/wiki/Tiled_rendering[tiled rendering],
 which would benefit from improved performance by offering the
 programmer more control over this functionality.
 Another limitation originating from the age of these APIs is limited
@@ -320,7 +320,7 @@ _validation layers_.
 Validation layers are pieces of code that can be inserted between the API
 and the graphics driver to do things like running extra checks on function
 parameters and tracking memory management problems.
-The nice thing is that you can enable them during development and then
+An important benefit is that you can enable them during development and then
 completely disable them when releasing your application for zero overhead.
 Anyone can write their own validation layers, but the Vulkan SDK by LunarG
 provides a standard set of validation layers that we'll be using in this tutorial.

en/02_Development_environment.adoc

@@ -65,9 +65,9 @@ contains the libraries.
 Lastly, there's the `include` directory that contains the Vulkan headers.
 Feel free to explore the other files, but we won't need them for this tutorial.
 
-To automatically set the environment variables up that VulkanSDK will use to
-make life easier with the CMake project configuration and various other
-tooling, We recommend using the `setup-env` script. This can be added to
+To automatically set the environment variables that VulkanSDK will use, we
+recommend using the `setup-env` script. This makes life easier with the CMake
+project configuration and various other tooling. The script can be added to
 your auto-start for your terminal and IDE setup such that those environment
 variables work everywhere.
 
@@ -154,9 +154,9 @@ target_sources(VulkanCppModule
 )
 ----
 
-The VulkanCppModule target only needs to be defined once, then add it to the
-dependency of your consuming project, and it will be built automatically, and
-you won't need to also add Vulkan::Vulkan to your project.
+The VulkanCppModule target only needs to be defined once. Then add it to the
+dependency of your consuming project, and it will be built automatically.
+You won't need to also add Vulkan::Vulkan to your project.
 
 [,cmake]
 ----
@@ -245,7 +245,7 @@ GLFW on the https://www.glfw.org/download.html[official website].
 In this tutorial, we'll be using the 64-bit binaries, but you can of course also
 choose to build in 32-bit mode. In that case make sure to link with the Vulkan
 SDK binaries in the `Lib32` directory instead of `Lib`. After downloading it, extract the archive
-to a convenient location. I've chosen to create a `Libraries` directory in the
+to a convenient location. We've chosen to create a `Libraries` directory in the
 Visual Studio directory under documents.
 
 image::/images/glfw_directory.png[]
@@ -272,7 +272,7 @@ Now that you have installed all the dependencies, we can set up a basic
 CMake project for Vulkan and write a little bit of code to make sure that
 everything works.
 
-I will assume that you already have some basic experience with CMake, like
+We will assume that you already have some basic experience with CMake, like
 how variables and rules work. If not, you can get up to speed very quickly with https://cmake.org/cmake/help/book/mastering-cmake/cmake/Help/guide/tutorial/[this tutorial].
 
 You can now use the link:/attachments/[attachments] directory in this tutorial
@@ -410,7 +410,7 @@ Now that you have installed all the dependencies, we can set up a basic
 CMake project for Vulkan and write a little bit of code to make sure that
 everything works.
 
-I will assume that you already have some basic experience with CMake, like
+We will assume that you already have some basic experience with CMake, like
 how variables and rules work. If not, you can get up to speed very quickly with https://cmake.org/cmake/help/book/mastering-cmake/cmake/Help/guide/tutorial/[this tutorial].
 
 You can now use the link:/attachments/[attachments] directory in this tutorial as a template for your

en/Building_a_Simple_Engine/Engine_Architecture/02_architectural_patterns.adoc

@@ -70,8 +70,8 @@ image::../../../images/component_based_architecture_diagram.svg[Component-Based
 
 * *Boxes*: Blue boxes represent Entities, orange boxes represent Components, and green boxes represent Systems
 * *Line Types*:
-  ** Dashed lines show ownership/containment (Entities contain Components)
-  ** Solid lines show processing relationships (Systems process specific Components)
+** Dashed lines show ownership/containment (Entities contain Components)
+** Solid lines show processing relationships (Systems process specific Components)
 * *Text*: All text elements use dark colors for visibility in both light and dark modes
 * *Directional Flow*: Arrows indicate the direction of relationships between elements
 ====

en/Building_a_Simple_Engine/Lighting_Materials/01_introduction.adoc

@@ -2,6 +2,11 @@
 
 In this chapter, we'll explore the fundamentals of lighting and materials in 3D rendering, with a focus on Physically Based Rendering (PBR). Lighting is a crucial aspect of creating realistic and visually appealing 3D scenes. Without proper lighting, even the most detailed models can appear flat and lifeless.
 
+[NOTE]
+====
+*About PBR References*: Throughout this tutorial, you may encounter references to PBR (Physically Based Rendering) before reaching this chapter. PBR is a modern rendering approach that simulates how light interacts with surfaces based on physical principles. We'll cover PBR in detail in the sections that follow, so don't worry if you're not familiar with these concepts yet.
+====
+
 This chapter serves as the foundation for understanding how light interacts with different materials in a physically accurate way. The concepts you'll learn here will be applied in later chapters, including the Loading_Models chapter where we'll use this knowledge to render glTF models with PBR materials.
 
 Throughout our engine implementation, we'll be using vk::raii dynamic rendering and C++20 modules. The vk::raii namespace provides Resource Acquisition Is Initialization (RAII) wrappers for Vulkan objects, which helps with resource management and makes the code cleaner. Dynamic rendering simplifies the rendering process by eliminating the need for explicit render passes and framebuffers. C++20 modules improve code organization, compilation times, and encapsulation compared to traditional header files.