except134 / llgl

Low Level Graphics Library (LLGL) is a thin abstraction layer for the modern graphics APIs OpenGL, Direct3D, Vulkan, and Metal

Low Level Graphics Library (LLGL)

License

3-Clause BSD License

Documentation

• Version: 0.03 Beta (see ChangeLog)
• Getting Started with LLGL (PDF) with Introduction, Hello Triangle Tutorial, and Extensibility Example with GLFW
• LLGL Reference Manual (PDF)
• LLGL Coding Conventions (PDF)
• Examples and Tutorials for C++
• Examples for C#

Platform Support

Platform	Remarks	CI	D3D12	D3D11	Vulkan	OpenGL	Metal
Windows	Tested on Windows 10		✔️	✔️	✔️	✔️	N/A
GNU/Linux	Tested on Kubuntu 16		N/A	N/A	✔️	✔️	N/A
macOS	Tested on macOS Sierra		N/A	N/A	N/A	✔️	✔️
iOS	Tested on macOS Mojave		N/A	N/A	N/A	✖️	✔️

Language Binding	Progress	Remarks
C#	30%	Experimental state

Build Notes

Windows

Visual Studio 2015 or later is required to build LLGL on Windows.

macOS

Xcode 9 or later is required to build LLGL on macOS.

GNU/Linux

The following development libraries are required to build LLGL on GNU/Linux:

• X11: libx11-dev
• xf86vidmode: libxxf86vm-dev
• Xrandr: libxrandr-dev

Thin Abstraction Layer

// Unified Interface:
CommandBuffer::DrawIndexed(std::uint32_t numIndices, std::uint32_t firstIndex);

// OpenGL Implementation:
void GLCommandBuffer::DrawIndexed(std::uint32_t numIndices, std::uint32_t firstIndex) {
    const GLintptr indices = (renderState_.indexBufferOffset + firstIndex * renderState_.indexBufferStride);
    glDrawElements(
        renderState_.drawMode,
        static_cast<GLsizei>(numIndices),
        renderState_.indexBufferDataType,
        reinterpret_cast<const GLvoid*>(indices)
    );
}

// Direct3D 11 Implementation
void D3D11CommandBuffer::DrawIndexed(std::uint32_t numIndices, std::uint32_t firstIndex) {
    context_->DrawIndexed(numIndices, firstIndex, 0);
}

// Direct3D 12 Implementation
void D3D12CommandBuffer::DrawIndexed(std::uint32_t numIndices, std::uint32_t firstIndex) {
    commandList_->DrawIndexedInstanced(numIndices, 1, firstIndex, 0, 0);
}

// Vulkan Implementation
void VKCommandBuffer::DrawIndexed(std::uint32_t numIndices, std::uint32_t firstIndex) {
    vkCmdDrawIndexed(commandBuffer_, numIndices, 1, firstIndex, 0, 0);
}

// Metal implementation
void MTCommandBuffer::DrawIndexed(std::uint32_t numIndices, std::uint32_t firstIndex) {
    if (numPatchControlPoints_ > 0) {
        [renderEncoder_
            drawIndexedPatches:             numPatchControlPoints_
            patchStart:                     static_cast<NSUInteger>(firstIndex) / numPatchControlPoints_
            patchCount:                     static_cast<NSUInteger>(numIndices) / numPatchControlPoints_
            patchIndexBuffer:               nil
            patchIndexBufferOffset:         0
            controlPointIndexBuffer:        indexBuffer_
            controlPointIndexBufferOffset:  indexTypeSize_ * (static_cast<NSUInteger>(firstIndex))
            instanceCount:                  1
            baseInstance:                   0
        ];
    } else {
        [renderEncoder_
            drawIndexedPrimitives:  primitiveType_
            indexCount:             static_cast<NSUInteger>(numIndices)
            indexType:              indexType_
            indexBuffer:            indexBuffer_
            indexBufferOffset:      indexTypeSize_ * static_cast<NSUInteger>(firstIndex)
        ];
    }
}