Update tutorial to be compatible with Daxa master

Author: GabeRundlett

docs/01_Installing_dependencies.md

@@ -6,7 +6,7 @@ This page will explain how to install all the necessary tools to compile the Dax
 
 ### Visual Studio
 
-In this tutorial, we will be using Clang as our compiler. Clang relies on the Microsoft STL, which we can get most easily by installing [Visual Studio](https://visualstudio.microsoft.com/de/vs/community/) and selecting the C++ desktop development component during installation
+In this tutorial, ~~we will be using Clang as our compiler~~ (EDIT: For now, there are some issues with Clang on Windows, so ). Clang relies on the Microsoft STL, which we can get most easily by installing [Visual Studio](https://visualstudio.microsoft.com/de/vs/community/) and selecting the C++ desktop development component during installation
 
 ### Clang & Ninja
 

docs/03_Getting_started/00_Creating_a_window.md

@@ -4,19 +4,20 @@ The first thing when developing a graphics application is to open a blank window
 
 ## Creating a header file
 
-In this tutorial, we will create a new header file `window.hpp` that is responsible for interfacing and abstracting the windowing library of our choice GLFW.
+In this tutorial, we will create a new header file `src/window.hpp` that is responsible for interfacing and abstracting the windowing library of our choice GLFW.
 
 ```cpp
 #pragma once
 
-struct Window{
+struct AppWindow{
 };
 ```
 
 Next, we need to include the libraries. Since we need the native window handle later, we also need the native GLFW headers. Since those libraries are platform dependant though, we need some extra preprocessor magic.
 
 ```cpp
 #include <daxa/daxa.hpp>
+// For things like `u32`. Not necessary of course.
 using namespace daxa::types;
 
 #include <GLFW/glfw3.h>
@@ -43,7 +44,7 @@ bool swapchain_out_of_date = false;
 We can now create a constructor and a destructor for the window.
 
 ```cpp
-explicit Window(char const * window_name, u32 sx = 800, u32 sy = 600) : width{sx}, height{sy} {
+explicit AppWindow(char const * window_name, u32 sx = 800, u32 sy = 600) : width{sx}, height{sy} {
     // Initialize GLFW
     glfwInit();
 
@@ -59,19 +60,16 @@ explicit Window(char const * window_name, u32 sx = 800, u32 sy = 600) : width{sx
     // Set the user pointer to this window
     glfwSetWindowUserPointer(glfw_window_ptr, this);
 
-    // Enable vsync (To limit the framerate to the refresh rate of the monitor)
-    glfwSwapInterval(1);
-
     // When the window is resized, update the width and height and mark the swapchain as out of date
-    glfwSetWindowContentScaleCallback(glfw_window_ptr, [](GLFWwindow* window, float xscale, float yscale){
-        auto* win = static_cast<Window*>(glfwGetWindowUserPointer(window));
-        win->width = static_cast<u32>(xscale);
-        win->height = static_cast<u32>(yscale);
+    glfwSetWindowSizeCallback(glfw_window_ptr, [](GLFWwindow *window, int size_x, int size_y) {
+        auto* win = static_cast<AppWindow*>(glfwGetWindowUserPointer(window));
+        win->width = static_cast<u32>(size_x);
+        win->height = static_cast<u32>(size_y);
         win->swapchain_out_of_date = true;
     });
 }
 
-~Window() {
+~AppWindow() {
     glfwDestroyWindow(glfw_window_ptr);
     glfwTerminate();
 }
@@ -145,18 +143,10 @@ We can now go ahead and open our window for the first time. We therefore need to
 ```cpp
 #include "window.hpp"
 
-#include <iostream>
-
-#include <daxa/daxa.hpp>
-#include <daxa/utils/pipeline_manager.hpp>
-#include <daxa/utils/task_graph.hpp>
-
-using namespace daxa::types;
-
 int main(int argc, char const *argv[])
 {
     // Create a window
-    auto window = Window("Learn Daxa", 860, 640);
+    auto window = AppWindow("Learn Daxa", 860, 640);
 
     // Daxa code goes here...
 

docs/03_Getting_started/02_Choosing_a_device.md

@@ -2,25 +2,10 @@
 
 A PC can have multiple graphics cards. Unlike OpenGL, you need to manually select which GPU you want to use to perform calculations. Since each GPU is different Daxa provides a simple system to select the GPU best suited for your application. You can choose the considered parameters yourself and change how they are weighed against each other.
 
-Below is a sample code to select a GPU based on location & VRAM.
+Below is sample code that selects the first device provided by the Vulkan driver (so long as it supports all of Daxa's required features). This means that if the user sets a device override in an application such as NVIDIA control panel, said device will be selected.
 
 ```cpp
-daxa::Device device = instance.create_device({
-    .selector = [](daxa::DeviceProperties const & device_props) -> daxa::i32
-    {
-        daxa::i32 score = 0;
-        switch (device_props.device_type)
-        {
-        case daxa::DeviceType::DISCRETE_GPU: score += 10000; break;
-        case daxa::DeviceType::VIRTUAL_GPU: score += 1000; break;
-        case daxa::DeviceType::INTEGRATED_GPU: score += 100; break;
-        default: break;
-        }
-        score += static_cast<daxa::i32>(device_props.limits.max_memory_allocation_count / 100000);
-        return score;
-    },
-    .name = "my device",
-});
+daxa::Device device = instance.create_device_2(instance.choose_device({}, {}));
 ```
 
-The struct daxa::DeviceProperties has many fields indicating different GPU attributes, such as Vulkan version, device type, ray tracing capabilities, ... ([Code reference](https://github.com/Ipotrick/Daxa/blob/master/include/daxa/device.hpp#L188))
+Usually, this is the desired behavior. If you want more control over device selection, see how this is done in [The device creation sample in the Daxa repository](https://github.com/Ipotrick/Daxa/blob/master/tests/2_daxa_api/2_device/main.cpp)

docs/03_Getting_started/03_Creating_a_swapchain.md

@@ -29,22 +29,18 @@ daxa::Swapchain swapchain = device.create_swapchain({
 });
 ```
 
-In the sample code, the native window handle can be obtained by the `Window#get_native_handle` and `Window#get_native_platform`
+In the sample code, the native window handle can be obtained by 2 of the helper-functions we created `AppWindow::get_native_handle()` and `AppWindow::get_native_platform()`
 
 ### daxa::PresentMode
 
-This defines how the rendered images are supplied to your screen. `daxa::PresentMode::MAILBOX` is the recommended default option for most use cases.
+This defines how the rendered images are supplied to your screen. `daxa::PresentMode::FIFO` is the recommended default option for most use cases.
 
 | mode | meaning |
 | --- | --- |
 | daxa::PresentMode::IMMEDIATE | Images submitted by your application are transferred to the screen right away, which may result in tearing |
 | daxa::PresentMode::FIFO | The swapchain is a queue where the display takes an image from the front of the queue when the display is refreshed and the program inserts rendered images at the back of the queue. If the queue is full then the program has to wait. This is most similar to vertical sync as found in modern games. The moment that the display is refreshed is known as "vertical blank". |
 | daxa::PresentMode::FIFO_RELAXED | This mode only differs from the previous one if the application is late and the queue was empty at the last vertical blank. Instead of waiting for the next vertical blank, the image is transferred right away when it finally arrives. This may result in visible tearing. |
-| daxa::PresentMode::MAILBOX | This is another variation of the second mode. Instead of blocking the application when the queue is full, the images that are already queued are simply replaced with the newer ones. This mode can be used to render frames as fast as possible while still avoiding tearing, resulting in fewer latency issues than standard vertical sync. This is commonly known as "triple buffering", although the existence of three buffers alone does not necessarily mean that the framerate is unlocked. |
-
-### daxa::Format
-
-This defines the color space for the swapchain images. (`R8G8B8A8_UINT` is the default 256-bit RGBA color space most displays use).
+| daxa::PresentMode::MAILBOX | This is another variation of the second mode. Instead of blocking the application when the queue is full, the images that are already queued are simply replaced with the newer ones. This mode can be used to render frames as fast as possible while still avoiding tearing, resulting in fewer latency issues than standard vertical sync. This is commonly known as "triple buffering", although the existence of three buffers alone does not necessarily mean that the framerate is unlocked. Although this may be desirable, it has limited support on AMD devices |
 
 ## Swapchain usage
 
@@ -61,59 +57,19 @@ If all swapchain images are used in queued submissions to the GPU, the present c
 ```cpp
 #include "window.hpp"
 
-#include <iostream>
-
-#include <daxa/daxa.hpp>
-#include <daxa/utils/pipeline_manager.hpp>
-#include <daxa/utils/task_graph.hpp>
-
-using namespace daxa::types;
-
 int main(int argc, char const *argv[])
 {
     // Create a window
-    auto window = Window("Learn Daxa", 860, 640);
+    auto window = AppWindow("Learn Daxa", 860, 640);
 
     daxa::Instance instance = daxa::create_instance({});
 
-    daxa::Device device = instance.create_device({
-        .selector = [](daxa::DeviceProperties const &device_props) -> i32
-        {
-            i32 score = 0;
-            switch (device_props.device_type)
-            {
-            case daxa::DeviceType::DISCRETE_GPU:
-                score += 10000;
-                break;
-            case daxa::DeviceType::VIRTUAL_GPU:
-                score += 1000;
-                break;
-            case daxa::DeviceType::INTEGRATED_GPU:
-                score += 100;
-                break;
-            default:
-                break;
-            }
-            score += static_cast<i32>(device_props.limits.max_memory_allocation_count / 100000);
-            return score;
-        },
-        .name = "my device",
-    });
+    daxa::Device device = instance.create_device_2(instance.choose_device({}, {}));
 
     daxa::Swapchain swapchain = device.create_swapchain({
         .native_window = window.get_native_handle(),
         .native_window_platform = window.get_native_platform(),
-        .surface_format_selector = [](daxa::Format format)
-        {
-            switch (format)
-            {
-            case daxa::Format::R8G8B8A8_UINT:
-                return 100;
-            default:
-                return daxa::default_format_score(format);
-            }
-        },
-        .present_mode = daxa::PresentMode::MAILBOX,
+        .present_mode = daxa::PresentMode::FIFO,
         .image_usage = daxa::ImageUsageFlagBits::TRANSFER_DST,
         .name = "my swapchain",
     });

docs/03_Getting_started/04_Push_constants.md

@@ -5,7 +5,7 @@ The Vulkan spec defines Push Constants as:
 
 ## Implementation
 
-To use push constants in our demo project, we need to create a new file: `shader/shared.inl` which will be a shared file between our main program and our shader file. Since Glsl is more or less a superset of basic C, we can use some code snippets in both languages.
+To use push constants in our demo project, we need to create a new file: `src/shader/shared.inl` which will be a shared file between our main program and our shader file. Since Glsl is more or less a superset of basic C, we can use some code snippets in both languages.
 
 Since this document is treated as a header file in our C++ code, we can simply insert `#pragma once` at the top to make sure it's only included once. We also need to include the Daxa (Shader) API directly beneath it: `#include <daxa/daxa.inl>`.