DiligentEngine

Diligent Engine is a light-weight cross-platform abstraction layer between the application and the platform-specific graphics API. Its main goal is to take advantages of the next-generation APIs such as Direct3D12 and Vulkan, but at the same time provide support for older platforms via Direct3D11, OpenGL and OpenGLES. Diligent Engine exposes common front-end for all supported platforms and provides interoperability with underlying native API.
Shader source code converter allows shaders authored in HLSL to be translated to GLSL and used on all supported platforms. The engine supports integration with Unity and is designed to be used as a graphics subsystem in a standalone game engine, Unity native plugin or any other 3D application. It is distributed under Apache 2.0 license and is free to use.

Features

Cross-platform
- Exact same client code for all supported platforms and rendering backends
  - No #if defined(_WIN32) ... #elif defined(LINUX) ... #elif defined(ANDROID) ...
  - No #if defined(D3D11) ... #elif defined(D3D12) ... #elif defined(OPENGL) ...
- Exact same HLSL shaders run on all platforms and all backends
Modular design
- Components are clearly separated logically and physically and can be used as needed
  - Only take what you need for your project (do not want to keep samples and tutorials in your codebase? Simply remove Samples submodule. Only need core functionality? Use only Core submodule)
  - No 15000 lines-of-code files
Clear object-based interface
- No global states
Key graphics features:
- Automatic shader resource binding designed to leverage the next-generation rendering APIs
- Multithreaded command buffer generation
  - 50,000 draw calls at 300 fps with D3D12 backend
- Descriptor, memory and resource state management
Modern c++ features to make code fast and reliable

Supported Plaforms and Low-Level Graphics APIs

Platform	APIs
Win32 (Windows desktop)	Direct3D11, Direct3D12, OpenGL4.2+
Universal Windows Platform	Direct3D11, Direct3D12
Android	OpenGLES3.0+
Linux	OpenGL4.2+
MacOS	OpenGL4.1 (No compute shaders)
iOS	OpenGLES3.0 (vertex and fragment shaders only)

Build Status

Platform	Status
Win32/Universal Windows
Linux/MacOS

Last Stable Release - v2.1.b

Clonning the Repository

This is the master repository that contains three submodules. To get the repository and all submodules, use the following command:

git clone --recursive https://github.com/DiligentGraphics/DiligentEngine.git

Alternatively, you can get master repository fisrt, and then individually clone all submodules into the engine's root folder.

To checkout the last stable release, run the following commands:

git checkout tags/v2.1.b
git submodule update --init --recursive

Repository Structure

Master repository includes the following submodules:

Core submodule provides basic engine functionality. It implements the engine API using Direct3D11, Direct3D12, and OpenGL/GLES. It also implements HLSL to GLSL source code converter. The module is self-contained and can be built by its own.
Tools submodule contains texture loading library and Render Script, a Lua-based run-time graphics resource managing system. Tools module depends on Core module.
Samples submodule contains several simple graphics applications intended to demonstrate the usage of the Diligent Engine API. The module depends on Core and Tools modules.

Build Instructions

Diligent Engine uses CMake as a cross-platform build tool. To start using cmake, download the latest release (3.10 or later is required for Windows build).

Win32

To generate build files for Windows desktop platform, use either CMake GUI or command line tool. For example, to generate Visual Studio 2017 64-bit solution and project files in cmk_build/Win64 folder, navigate to the engine's root folder and run the following command:

cmake -H. -B./cmk_build/Win64 -G "Visual Studio 15 2017 Win64"

WARNING! In current implementation, full path to cmake build folder must not contain white spaces. (If anybody knows a way to add quotes to CMake's custom commands, please let me know!)

Open DiligentEngine.sln file in cmk_build/Win64 folder, select the desired configuration and build the engine. By default, Asteroids demo will be set up as startup project.

Universal Windows Platform

To generate build files for Universal Windows platform, you need to define the following two cmake variables:

CMAKE_SYSTEM_NAME=WindowsStore
CMAKE_SYSTEM_VERSION=< Windows SDK Version >

For example, to generate Visual Studio 2017 64-bit solution and project files in cmk_build/UWP64 folder, run the following command from the engine's root folder:

cmake -D CMAKE_SYSTEM_NAME=WindowsStore -D CMAKE_SYSTEM_VERSION=10.0.15063.0 -H. -B./cmk_build/UWP64 -G "Visual Studio 15 2017 Win64"

Linux

Your Linux environment needs to be set up for c++ development. To configure my fresh Ubuntu 17.10, I installed the following packages:

gcc, make and other essential c/c++ tools:

sudo apt-get update
sudo apt-get upgrade
sudo apt-get install build-essential

cmake

sudo apt-get install cmake

Other required packages:

sudo apt-get install libx11-dev
sudo apt-get install mesa-common-dev
sudo apt-get install mesa-utils
sudo apt-get install libgl-dev

To generate make files for debug configuration, run the following CMake command from the engine's root folder:

cmake -H. -B./cmk_build/Linux64 -G "Unix Makefiles" -DCMAKE_BUILD_TYPE="Debug"

To build the engine, run the following command:

cmake --build ./cmk_build/Linux64

Android

Please make sure that your machine is set up for Android development. Download Android Studio, Android NDK and other required tools. To verify that your environment is properly set up, try building teapots sample.

Open DiligentSamples/Android or UnityPlugin/Android folders with Android Studio to build and run the engine samples and Unity emulator on Android.

MacOS

After you clone the repo, run the following command from the engine's root folder to generate XCode project (you need to have CMake installed on the system):

cmake -H. -B./cmk_build/MacOS -G "Xcode"

Open Xcode project file in cmk_build/MacOS folder and build the engine.

Tutorials

Tutorial 01 - Hello Triangle

This tutorial shows how to render a simple triangle using Diligent Engine API.

Tutorial 02 - Cube

This tutorial demonstrates how to render an actual 3D object, a cube. It shows how to load shaders from files, create and use vertex, index and uniform buffers.

Tutorial 03 - Texturing

This tutorial demonstrates how to apply a texture to a 3D object. It shows how to load a texture from file, create shader resource binding object and how to sample a texture in the shader.

Tutorial 04 - Instancing

This tutorial demonstrates how to use instancing to render multiple copies of one object using unique transformation matrix for every copy.

Tutorial 05 - Texture Array

This tutorial demonstrates how to combine instancing with texture arrays to use unique texture for every instance.

Tutorial 06 - Multithreading

This tutorial shows how to generate command lists in parallel from multiple threads.

Tutorial 07 - Geometry Shader

This tutorial shows how to use geometry shader to render smooth wireframe.

Tutorial 08 - Tessellation

This tutorial shows how to use hardware tessellation to implement simple adaptive terrain rendering algorithm.

Samples

Sample source code

AntTweakBar Sample

This sample demonstrates how to use AntTweakBar library to create simple user interface. It can also be thought of as Diligent Engine’s “Hello World” example.

Atmosphere Sample

The sample demonstrates how Diligent Engine can be used to implement various rendering tasks: loading textures from files, using complex shaders, rendering to textures, using compute shaders and unordered access views, etc.

Projects

Asteroids Performance Benchmark

This sample is designed to be a performance benchmark and is based on this demo developed by Intel. It renders 50,000 unique textured asteroids. Every asteroid is a combination of one of 1000 unique meshes and one of 10 unique textures. The sample uses original D3D11 and D3D12 native implementations, and adds implementation using Diligent Engine API to allow comparing performance of different rendering modes.

Unity Integration Demo

This project demonstrates integration of Diligent Engine with Unity

References

Diligent Engine on the Web

Diligent Engine on Twitter

Diligent Engine on Facebook

API Reference

Version History

Current Progress

Added MacOS support

v2.1.b

Removed legacy Visual Studio solution and project files
Added API reference
Added tutorials 1-8

v2.1.a

Refactored build system to use CMake and Gradle for Android
Added support for Linux platform

v2.1

New Features

Core

Interoperability with native API ** Accessing internal objects and handles ** Createing diligent engine buffers/textures from native resources ** Attaching to existing D3D11/D3D12 device or GL context ** Resource state and command queue synchronization for D3D12
Integraion with Unity
Geometry shader support
Tessellation support
Performance optimizations

HLSL->GLSL converter

Support for structured buffers
HLSL->GLSL conversion is now a two-stage process: ** Creating conversion stream ** Creating GLSL source from the stream
Geometry shader support
Tessellation control and tessellation evaluation shader support
Support for non-void shader functions
Allowing structs as input parameters for shader functions

v2.0 (alpha)

Alpha release of Diligent Engine 2.0. The engine has been updated to take advantages of Direct3D12:

Pipeline State Object encompasses all coarse-grain state objects like Depth-Stencil State, Blend State, Rasterizer State, shader states etc.
New shader resource binding model implemented to leverage Direct3D12
OpenGL and Direct3D11 backends
Alpha release is only available on Windows platform
Direct3D11 backend is very thoroughly optimized and has very low overhead compared to native D3D11 implementation
Direct3D12 implementation is preliminary and not yet optimized

v1.0.0

Initial release

License

Licensed under the Apache License, Version 2.0

diligentgraphics.com