Pros of DirectX-Graphics-Samples

• Comprehensive coverage of DirectX 12 features and techniques
• Official Microsoft samples, ensuring up-to-date and best practice implementations
• Extensive documentation and comments within the code

Cons of DirectX-Graphics-Samples

• Focused solely on DirectX, limiting cross-platform development options
• May have a steeper learning curve for beginners due to its advanced nature
• Less emphasis on performance optimization compared to Cauldron

Code Comparison

DirectX-Graphics-Samples (D3D12HelloTriangle.cpp):

ComPtr<ID3D12Resource> m_vertexBuffer;
D3D12_VERTEX_BUFFER_VIEW m_vertexBufferView;

// Create the vertex buffer.
{
    // Define the geometry for a triangle.
    Vertex triangleVertices[] =
    {
        { { 0.0f, 0.25f * m_aspectRatio, 0.0f }, { 1.0f, 0.0f, 0.0f, 1.0f } },
        { { 0.25f, -0.25f * m_aspectRatio, 0.0f }, { 0.0f, 1.0f, 0.0f, 1.0f } },
        { { -0.25f, -0.25f * m_aspectRatio, 0.0f }, { 0.0f, 0.0f, 1.0f, 1.0f } }
    };

Cauldron (TriangleVS.hlsl):

struct VSInput
{
    float3 Position : POSITION;
    float3 Color : COLOR;
};

struct VSOutput
{
    float4 Position : SV_POSITION;
    float3 Color : COLOR;
};

Pros of Vulkan-Samples

• Extensive collection of Vulkan samples covering a wide range of topics
• Official repository maintained by Khronos Group, ensuring up-to-date and accurate implementations
• Cross-platform support with builds for Windows, Linux, macOS, and Android

Cons of Vulkan-Samples

• Focused solely on Vulkan, lacking support for other graphics APIs
• May be overwhelming for beginners due to the large number of samples and advanced topics

Code Comparison

Vulkan-Samples (Initialization):

VkInstanceCreateInfo instance_info = {};
instance_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
instance_info.pApplicationInfo = &app_info;
vkCreateInstance(&instance_info, nullptr, &instance);

Cauldron (Initialization):

Device* pDevice = new Device();
pDevice->OnCreate("Cauldron", "Sample", false, nullptr);
SwapChain* pSwapChain = new SwapChain();
pSwapChain->OnCreate(pDevice, 1280, 720);

Cauldron provides a higher-level abstraction for device and swapchain creation, while Vulkan-Samples demonstrates raw Vulkan API usage. Cauldron's approach may be more accessible for beginners, but Vulkan-Samples offers more direct control over the Vulkan implementation.

Pros of Vulkan

• Extensive collection of Vulkan examples covering various techniques and features
• Well-documented code with detailed explanations for each example
• Actively maintained with frequent updates and community contributions

Cons of Vulkan

• Focused solely on Vulkan, lacking support for other graphics APIs
• May be overwhelming for beginners due to the large number of examples
• Less emphasis on creating a reusable framework compared to Cauldron

Code Comparison

Vulkan (Basic triangle rendering):

void buildCommandBuffers()
{
    VkCommandBufferBeginInfo cmdBufInfo = vks::initializers::commandBufferBeginInfo();
    VkClearValue clearValues[2];
    clearValues[0].color = defaultClearColor;
    clearValues[1].depthStencil = { 1.0f, 0 };
    VkRenderPassBeginInfo renderPassBeginInfo = vks::initializers::renderPassBeginInfo();
    renderPassBeginInfo.renderPass = renderPass;
    renderPassBeginInfo.renderArea.offset.x = 0;
    renderPassBeginInfo.renderArea.offset.y = 0;
    renderPassBeginInfo.renderArea.extent.width = width;
    renderPassBeginInfo.renderArea.extent.height = height;
    renderPassBeginInfo.clearValueCount = 2;
    renderPassBeginInfo.pClearValues = clearValues;
    // ...
}

Cauldron (Basic rendering setup):

void Sample::LoadScene()
{
    m_pGltfLoader = new GLTFCommon();
    if (m_pGltfLoader->Load(m_jsonConfigFile.c_str()) == false)
    {
        MessageBox(NULL, "The selected GLTF file is invalid or can't be found", "Cauldron Viewer", MB_ICONERROR);
        return;
    }
    // ...
}

Pros of bgfx

• More mature and widely adopted, with a larger community and ecosystem
• Supports a broader range of platforms and rendering APIs
• Offers more low-level control and flexibility for advanced graphics programming

Cons of bgfx

• Steeper learning curve due to its lower-level nature
• Less focus on modern rendering techniques and PBR workflows
• Requires more manual setup and configuration compared to Cauldron

Code Comparison

bgfx example:

bgfx::init(init);
bgfx::setViewClear(0, BGFX_CLEAR_COLOR | BGFX_CLEAR_DEPTH, 0x303030ff, 1.0f, 0);
bgfx::setViewRect(0, 0, 0, uint16_t(width), uint16_t(height));

Cauldron example:

Device* pDevice = new Device();
SwapChain* pSwapChain = new SwapChain(pDevice);
ResourceViewHeaps* pResourceViewHeaps = new ResourceViewHeaps(pDevice);

bgfx provides a more low-level API with direct control over rendering states, while Cauldron offers a higher-level abstraction with object-oriented design. bgfx requires more explicit setup of rendering parameters, whereas Cauldron handles many of these details internally.

Both libraries aim to simplify cross-platform graphics development, but they cater to different levels of abstraction and use cases. bgfx is better suited for developers who need fine-grained control and maximum performance, while Cauldron is designed for ease of use and rapid prototyping of modern rendering techniques.

Pros of Filament

• Cross-platform support: Android, iOS, Windows, macOS, Linux, and WebGL
• Extensive documentation and examples
• Active development and community support

Cons of Filament

• Steeper learning curve due to its comprehensive feature set
• Larger codebase and potentially higher resource usage
• Less focus on AMD-specific optimizations

Code Comparison

Filament (Material definition):

material {
    name : "MyMaterial",
    parameters : [
        { type : float3, name : "baseColor" }
    ],
    requires : [
        uv0
    ],
    shadingModel : unlit
}

Cauldron (Material definition):

MaterialInstance* pMaterial = MaterialInstance::CreateMaterialInstance(pDevice, "MyMaterial");
pMaterial->SetParameter("baseColor", float3(1.0f, 0.0f, 0.0f));
pMaterial->SetTexture("albedoMap", pTexture);

Both Filament and Cauldron provide powerful rendering capabilities, but Filament offers broader platform support and more extensive documentation. Cauldron, being developed by AMD, may have better optimizations for AMD hardware. The code examples show different approaches to material definition, with Filament using a more declarative style and Cauldron using a programmatic approach.

Pros of sokol

• Lightweight and minimalistic, focusing on simplicity and ease of use
• Supports multiple platforms (Windows, macOS, Linux, iOS, Android, and web)
• Single-file header-only libraries for easy integration

Cons of sokol

• Less comprehensive feature set compared to Cauldron
• May require more manual setup and configuration for complex rendering scenarios
• Limited built-in support for advanced graphics techniques

Code Comparison

Sokol (initializing a window and graphics context):

#include "sokol_app.h"
#include "sokol_gfx.h"

sapp_desc sokol_main(int argc, char* argv[]) {
    return (sapp_desc){ .width = 800, .height = 600, .init_cb = init, .frame_cb = frame };
}

Cauldron (initializing a window and graphics context):

#include "Application.h"
#include "Renderer.h"

int main(int argc, char* argv[]) {
    Application app;
    app.Init();
    Renderer renderer;
    renderer.Init(app.GetWindow());
    return app.Run();
}

The code comparison shows that sokol offers a more concise initialization process, while Cauldron provides a more structured approach with separate classes for application and renderer management.