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. It also 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. The engine contains shader source code converter that allows shaders authored in HLSL to be translated to GLSL.
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.
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
- Samples submodule contains several simple graphics applications intended to demonstrate the usage of the Diligent Engine API.
- Tools submodule contains texture loading library and Render Script, a Lua-based run-time graphics resource managing system.
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).
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 folder, select the desired configuration and build the engine. By default, Asteroids demo will be set up as startup project.
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"
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.
There is a build subdirectory in each project’s directory that contains Visual Studio 2015 project files. These files are now deprecated and will be removed in future releases.
Open EngineAll.sln solution file located in build/Win32 folder, choose the desired configuration and build it.
Diligent engine is self-contained and does not have any external dependencies. Installing Visual Studio is all that is required to build the engine.
Tools module references core module and samples module references both core and tools modules. The modules must share the same parent directory, otherwise links in the project files will be broken.
Core module contains several property pages that define common build settings. The pages are located in diligentcore\Shared\Build subdirectory and are referenced by every project.
Navigate to build/UWP directory, open EngineAll.sln solution file and build the solution for the desired configuration.
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.
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.
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.
This project demonstrates integration of Diligent Engine with Unity
- 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
- 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
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
Initial release
Licensed under the Apache License, Version 2.0
Copyright 2015-2017 Egor Yusov