You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
Copy file name to clipboardExpand all lines: en/Building_a_Simple_Engine/Tooling/01_introduction.adoc
+9-18Lines changed: 9 additions & 18 deletions
Display the source diff
Display the rich diff
Original file line number
Diff line number
Diff line change
@@ -1,13 +1,6 @@
1
-
::pp: {plus}{plus}
1
+
:pp: {plus}{plus}
2
2
3
3
= Tooling: Introduction
4
-
:doctype: book
5
-
:sectnums:
6
-
:sectnumlevels: 4
7
-
:toc: left
8
-
:icons: font
9
-
:source-highlighter: highlightjs
10
-
:source-language: c++
11
4
12
5
== Introduction to Engine Tooling
13
6
@@ -17,23 +10,21 @@ Effective tooling is critical for maintaining productivity, ensuring quality, an
17
10
18
11
=== What We'll Cover
19
12
20
-
In this chapter, we'll explore:
13
+
This chapter will equip you with the professional tooling ecosystem that transforms a working Vulkan application into a maintainable, debuggable, and deployable product. We'll begin by implementing a continuous integration and continuous deployment pipeline specifically designed for Vulkan's unique requirements. This foundation ensures that your application builds consistently across platforms while catching integration issues before they reach users.
21
14
22
-
* *CI/CD for Vulkan Projects*: We'll implement a continuous integration and continuous deployment pipeline specifically tailored for Vulkan applications, ensuring consistent builds and automated testing across different platforms.
15
+
Debugging Vulkan applications presents unique challenges that traditional debugging approaches can't address effectively. We'll master both Vulkan's built-in debugging extensions like VK_KHR_debug_utils and external tools like RenderDoc, creating a comprehensive debugging workflow that can diagnose everything from validation layer warnings to complex rendering pipeline issues.
23
16
24
-
* *Debugging with VK_KHR_debug_utils and RenderDoc*: We'll explore how to use Vulkan's debugging extensions and external tools like RenderDoc to identify and fix issues in your rendering pipeline.
17
+
Robust crash handling becomes crucial as your application moves toward production deployment. We'll implement systems that can gracefully handle unexpected failures, generate detailed minidumps for post-mortem analysis, and provide users with meaningful recovery options rather than abrupt terminations.
25
18
26
-
* *Crash Handling and Minidumps*: We'll implement robust crash handling mechanisms and learn how to generate and analyze minidumps to diagnose issues in production environments.
27
-
28
-
* *Vulkan Extensions for Robustness*: We'll explore extensions like VK_EXT_robustness2 that can help make your application more resilient to undefined behavior.
19
+
Finally, we'll explore Vulkan extensions designed specifically for application robustness, such as VK_EXT_robustness2, which help your application handle edge cases and undefined behavior gracefully. These extensions transform potential crashes into recoverable situations, improving the overall user experience.
29
20
30
21
=== Prerequisites
31
22
32
-
Before diving into this chapter, you should be familiar with:
23
+
This chapter assumes solid understanding of the Vulkan fundamentals and engine architecture we've built throughout the previous chapters. The tooling we'll implement needs to integrate with your existing systems—CI/CD pipelines must understand your project structure, debugging tools must work with your rendering pipeline, and crash handling must respect your engine's resource management patterns.
24
+
25
+
Experience with modern C++ concepts becomes particularly important here, as professional tooling often leverages advanced language features for reliability and maintainability. C++17 and C++20 features like structured bindings, concepts, and coroutines appear frequently in production tooling code, and understanding these patterns will help you implement robust solutions.
33
26
34
-
* The basics of Vulkan and our engine architecture from previous chapters
35
-
* Modern C++ concepts, particularly those introduced in C++17 and C++20
36
-
* Basic understanding of software development workflows and tools
27
+
A basic familiarity with software development workflows and tools will provide context for the systems we'll build. While we'll explain the specific implementations, understanding why continuous integration matters, how debugging fits into development cycles, and why crash reporting improves user experience will help you appreciate the architectural decisions we make throughout this chapter.
37
28
38
29
Let's begin by exploring how to set up a CI/CD pipeline for Vulkan projects.
Copy file name to clipboardExpand all lines: en/Building_a_Simple_Engine/Tooling/index.adoc
+1-8Lines changed: 1 addition & 8 deletions
Display the source diff
Display the rich diff
Original file line number
Diff line number
Diff line change
@@ -1,13 +1,6 @@
1
-
::pp: {plus}{plus}
1
+
:pp: {plus}{plus}
2
2
3
3
= Tooling
4
-
:doctype: book
5
-
:sectnums:
6
-
:sectnumlevels: 4
7
-
:toc: left
8
-
:icons: font
9
-
:source-highlighter: highlightjs
10
-
:source-language: c++
11
4
12
5
This chapter covers essential tooling and techniques for developing, debugging, and distributing Vulkan applications, with a focus on using modern C++20 modules and the vk::raii namespace.
0 commit comments