LLGL Low-Level Graphics Abstraction Library

LLGL (Low Level Graphics Library) is a thin abstraction layer for modern and legacy rendering APIs across desktop and mobile platforms. It provides close coupling with underlying APIs to maintain a rich feature set while simplifying architectural hurdles.

Supported Languages:

• C++11 (Primary)
• C99
• C# 6.0
• Go
• WebGL

The examples/C99 directory contains several reference implementations for using LLGL in ISO-C99:

• Hello Triangle: A basic example illustrating fundamental interaction with the LLGL API in C.
• Texturing: Demonstrates image loading from file (utilizing the STB library), indexed-drawing, and management of dynamic resources.
• Offscreen: Demonstrates offscreen rendering where the output is rendered into a texture and saved to disk instead of being displayed on the screen.

To run the C++ examples provided in the repository, you must set the working directory of your executable to the specific example folder.

For example, if your LLGL repository is located at /Users/JohnDoe/LLGL, the working directory for the HelloTriangle example should be set to: /Users/JohnDoe/LLGL/examples/Cpp/HelloTriangle.

In version 0.03, the ShaderProgram interface was removed. Instead of creating a shader program and then a pipeline state, you now provide individual shaders directly to the GraphicsPipelineDescriptor and create the pipeline state using CreatePipelineState. Error reporting is now handled via the GetReport() method on the PipelineState object.

// Usage:
LLGL::GraphicsPipelineDescriptor myPSODesc;
myPSODesc.pipelineLayout = myPipelineLayout;
myPSODesc.renderPass = mySwapChain->GetRenderPass();
myPSODesc.vertexShader = myVertexShader;
myPSODesc.fragmentShader = myFragmentShader;
LLGL::PipelineState* myGraphicsPSO = myRenderer->CreatePipelineState(myPSODesc);
if (const LLGL::Report* myReport = myGraphicsPSO->GetReport())
{
    if (myReport->HasErrors())
        std::cerr << myReport->GetText() << std::endl;
}

The LLGL binding model is now fully abstracted; binding slots are defined exclusively in the PipelineLayout.

• ResetResourceSlots is deprecated: You can simply remove calls to this function.
• Automatic Unbinding: For the D3D11 backend, LLGL now automatically manages unbinding resources to prevent overlapping read-only and read-write resource views, making manual resets unnecessary.

In version 0.03, shader reflection has been updated. The ShaderReflectionDescriptor and its nested types have been renamed and moved to the LLGL namespace. Specifically:

• ShaderReflectionDescriptor $\rightarrow$ LLGL::ShaderReflection
• ShaderReflectionDescriptor::ResourceView $\rightarrow$ LLGL::ShaderResource
• ShaderReflectionDescriptor::Uniform $\rightarrow$ LLGL::ShaderUniform

Binding attributes in ShaderResource are now contained within a BindingDescriptor structure. Reflection no longer throws exceptions; instead, Shader::Reflect returns a bool indicating success.

LLGL::ShaderReflection reflection;
if (myShader->Reflect(reflection)) {
    /* Evaluate ... */
} else {
    /* Error ... */
}

When rendering tessellated geometry using an index buffer:

1. Clear Buffers: Use myCmdBuffer->Clear(LLGL::ClearFlags::ColorDepth) to clear both color and depth buffers simultaneously.
2. Bind Resources: Bind your vertex buffer, index buffer, and the ResourceHeap associated with your pipeline.
3. Draw: Use DrawIndexed instead of Draw. The number of indices must account for all control points in the patches (e.g., 6 patches with 4 control points each requires 24 indices).

myCmdBuffer->Clear(LLGL::ClearFlags::ColorDepth);

myCmdBuffer->SetVertexBuffer(*myVertexBuffer);
myCmdBuffer->SetIndexBuffer(*myIndexBuffer);
myCmdBuffer->SetResourceHeap(*myResourceHeap);

// Draw 6 patches with 4 control points each (24 indices)
myCmdBuffer->DrawIndexed(24, 0);

To implement your own renderer interface in LLGL, use the provided backend include files (*.inl). These files contain the declarations for all required functions for a specific interface. You must include the relevant .inl file inside your class definition to satisfy the interface requirements.

Note: These headers are only required when implementing a custom backend; they are not needed for standard LLGL usage.

#include <LLGL/CommandBuffer.h>

class MyOwnRenderer : public LLGL::CommandBuffer {
public:
    #include <LLGL/Backend/CommandBuffer.inl>
public:
    MyOwnRenderer();
    ~MyOwnRenderer();
private:
    MyRendererData privateData;
};