/github/workspace/main.cpp File Reference

#include <vulkan/vulkan_raii.hpp>
#include <cstdlib>
#include <iostream>
#include <stdexcept>
#include "GLFW/glfw3.h"
#include "dodo/core/App.hpp"

Include dependency graph for main.cpp:

Classes
class	HelloTriangleApplication
struct	Test< Features >

Functions
template<typename T >
void	printType ()
template<typename FirstFeature , typename... OtherFeatures>
void	testStructureChains (const vk::StructureChain< FirstFeature, OtherFeatures... > &features)
int	main ()

Variables
const std::vector< char const * >	validationLayers
constexpr bool	enableValidationLayers = true

Function Documentation

main()

int main

(

)

           {
    std::array<const char *, 1> vLayers {
        "VK_LAYER_KHRONOS_validation",
    };
 
 
    const vk::ApplicationInfo vkInfo {
        .pApplicationName   = "Hello Triangle",
        .applicationVersion = VK_MAKE_VERSION( 1, 0, 0 ),
        .pEngineName        = "No Engine",
        .engineVersion      = VK_MAKE_VERSION( 1, 0, 0 ),
        .apiVersion         = vk::ApiVersion13
    };
 
    const dodo::core::App::AppInfo appInfo {
        .width =  800,
        .height = 600,
        .title = "TestApplication"
    };
 
    vk::StructureChain<vk::PhysicalDeviceFeatures2,
                         vk::PhysicalDeviceVulkan13Features,
                         vk::PhysicalDeviceExtendedDynamicStateFeaturesEXT> featureChain = {
        {},                               // vk::PhysicalDeviceFeatures2 (empty for now)
        {.dynamicRendering = true },      // Enable dynamic rendering from Vulkan 1.3
        {.extendedDynamicState = true },   // Enable extended dynamic state from the extension
    };
 
    const dodo::core::VulkanContext::VulkanDebug debugInfo {
        .debugEnabled = true,
        .validationLayers = vLayers,
    };
 
     const dodo::core::VulkanContext::VulkanContextInfo<vk::PhysicalDeviceFeatures2,
                         vk::PhysicalDeviceVulkan13Features,
                         vk::PhysicalDeviceExtendedDynamicStateFeaturesEXT> vkCtxInfo {
        .vkInfo = vkInfo,
        .featureChain = featureChain,
        .debugInfo = debugInfo
    };
 
    auto ctx = dodo::core::DodoContext::createDodoContext(vkCtxInfo);
    auto app = dodo::core::App::createApp(*ctx, appInfo);
    if (app) {
        std::cout << "Success" << std::endl;
    } else {
        std::cout << app.error() << std::endl;
        return EXIT_FAILURE;
    }
    while (app->isRunning()) {
        app->pollEvents();
    }
    // HelloTriangleApplication app;
    // try {
    //     app.run();
    // } catch (const std::exception& e) {
    //     std::cerr << e.what() << std::endl;
    //     return EXIT_FAILURE;
    // }
    return EXIT_SUCCESS;
}

References dodo::core::App::createApp(), and dodo::core::DodoContext::createDodoContext().

Here is the call graph for this function:

printType()

template<typename T >

void printType

(

)

{
#if defined(__clang__) || defined(__GNUC__)
    std::cout << __PRETTY_FUNCTION__ << '\n';
#elif defined(_MSC_VER)
    std::cout << __FUNCSIG__ << '\n';
#endif
}

Referenced by testStructureChains().

Here is the caller graph for this function:

testStructureChains()

template<typename FirstFeature , typename... OtherFeatures>

void testStructureChains

(

const vk::StructureChain< FirstFeature, OtherFeatures... > &

features

)

                                                                                           {
    const auto &first = features.template get<FirstFeature>();
    printType<FirstFeature>();
 
    vk::DeviceCreateInfo deviceCreateInfo{
        .pNext = &first,
        .queueCreateInfoCount = 1,
        // .pQueueCreateInfos = &deviceQueueCreateInfo,
        // .enabledExtensionCount = static_cast<uint32_t>(deviceExtensions.size()),
        // .ppEnabledExtensionNames = deviceExtensions.data()
    };
}

References printType().

Here is the call graph for this function:

Variable Documentation

enableValidationLayers

bool enableValidationLayers = true

constexpr

Referenced by HelloTriangleApplication::createInstance().

validationLayers

const std::vector<char const*> validationLayers

Initial value:

= {
    "VK_LAYER_KHRONOS_validation"
}

                                                {
    "VK_LAYER_KHRONOS_validation"
};

Referenced by dodo::core::VulkanContext::checkRequiredLayers(), and HelloTriangleApplication::createInstance().