DiligentEngine | modern cross-platform low | Game Engine library

Diligent Engine uses CMake as a cross-platform build tool. To start using cmake, download the latest release (3.16 or later is required). Another build prerequisite is Python interpreter (3.0 or later is required). If after following the instuctions below you have build/run issues, please take a look at troubleshooting.
By default there is no Vulkan implementation on MacOS. Diligent Engine loads Vulkan dynamically and can use a Vulkan Portability implementation such as MoltenVK or gfx-portability. Install VulkanSDK and make sure that your system is properly configured as described here. In particular, you may need to define the following environment variables (assuming that Vulkan SDK is installed at ~/LunarG/vulkansdk-macos and you want to use MoltenVK):.
To enable Vulkan on iOS, download and install VulkanSDK. There is no Vulkan loader on iOS, and Diligent Engine links directly with MoltenVK XCFramework (see MoltenVk install guide) that implements Vulkan on Metal. To enable Vulkan in Diligent Engine on iOS, specify the path to Vulkan SDK when running CMake, for example (assuming that Vulkan SDK is installed at /LunarG/vulkansdk-macos):. By default, the engine links with MoltenVK XCFramework located in LunarG SDK. If this is not desired or an application wants to use a framework from a specific location, it can provide the full path to the framework via MoltenVK_FRAMEWORK CMake variable. Refer to MoltenVK user guide for more information about MoltenVK installation and usage. Last tested LunarG SDK version: 1.2.176.1.
By default, all back-ends available on current platform are built. To disable specific back-ends, use the following options: DILIGENT_NO_DIRECT3D11, DILIGENT_NO_DIRECT3D12, DILIGENT_NO_OPENGL, DILIGENT_NO_VULKAN, DILIGENT_NO_METAL. The options can be set through cmake UI or from the command line as in the example below:. Additionally, individual engine components can be enabled or disabled using the following options: DILIGENT_BUILD_TOOLS, DILIGENT_BUILD_FX, DILIGENT_BUILD_SAMPLES, DILIGENT_BUILD_DEMOS, DILIGENT_BUILD_UNITY_PLUGIN. If you only want to build SampleBase project, you can use DILIGENT_BUILD_SAMPLE_BASE_ONLY option. By default Vulkan back-end is linked with glslang that enables compiling HLSL and GLSL shaders to SPIRV at run time. If run-time compilation is not required, glslang can be disabled with DILIGENT_NO_GLSLANG cmake option. Additionally, HLSL support in non-Direct3D backends can be disabled with DILIGENT_NO_HLSL option. Enabling the options significantly reduces the size of Vulkan and OpenGL back-end binaries, which may be especially important for mobile applications. Diligent Engine uses clang-format to ensure consistent formatting throughout the code base. The validation can be disabled using DILIGENT_NO_FORMAT_VALIDATION CMake option. Note that any pull request will fail if formatting issues are found. Diligent Engine uses extensive validation that is always enabled in Debug build. Some of the checks may be enabled in release configurations by setting DILIGENT_DEVELOPMENT CMake option. To enable PIX events support, download WinPixEventRuntime and set DILIGENT_PIX_EVENT_RUNTIME_PATH CMake variable to the root folder of the package.
Diligent Engine allows clients to customize build settings by providing configuration script file that defines the following optional cmake functions:.
custom_configure_build() - defines global build properties such as build configurations, c/c++ compile flags, link flags etc.
custom_pre_configure_target() - defines custom settings for every target in the build and is called before the engine's build system starts configuring the target.
custom_post_configure_target() - called after the engine's build system has configured the target to let the client override properties set by the engine.
If defined, custom_configure_build() function is called before any build target is added. By default, cmake defines the following four configurations: Debug, Release, RelWithDebInfo, MinSizeRel. If you want, you can define your own build configurations by setting CMAKE_CONFIGURATION_TYPES variable. For instance, if you want to have only two configuration: Debug and ReleaseMT, add the following line to the custom_configure_build() function:.
CMAKE_C_FLAGS_<Config> - c compile flags
CMAKE_CXX_FLAGS_<Config> - c++ compile flags
CMAKE_EXE_LINKER_FLAGS_<Config> - executable link flags
CMAKE_SHARED_LINKER_FLAGS_<Config> - shared library link flags
Please refer to this page. Also, tutorials and samples listed below is a good place to start. This tutorial shows how to render simple triangle using Diligent Engine API. 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. 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. This tutorial is identical to Tutorial03, but is implemented using C API. This tutorial demonstrates how to use instancing to render multiple copies of one object using unique transformation matrix for every copy. This tutorial demonstrates how to combine instancing with texture arrays to use unique texture for every instance. This tutorial shows how to generate command lists in parallel from multiple threads. This tutorial shows how to use geometry shader to render smooth wireframe. This tutorial shows how to use hardware tessellation to implement simple adaptive terrain rendering algorithm. This tutorial shows how to render multiple 2D quads, frequently switching textures and blend modes. This tutorial shows dynamic buffer mapping strategy using MAP_FLAG_DISCARD and MAP_FLAG_DO_NOT_SYNCHRONIZE flags to efficiently stream varying amounts of data to GPU. This tutorial demonstrates different ways to update buffers and textures in Diligent Engine and explains important internal details and performance implications related to each method. This tutorial demonstrates how to render a 3d cube into an offscreen render target and do a simple post-processing effect. This tutorial demonstrates how to render basic shadows using a shadow map. This tutorial shows how to implement a simple particle simulation system using compute shaders. This tutorial demonstrates how to use Diligent Engine to render to multiple windows. This tutorial shows how to implement bindless resources, a technique that leverages dynamic shader resource indexing feature enabled by the next-gen APIs to significantly improve rendering performance. This tutorial demonstrates how to use multisample anti-aliasing (MSAA) to make geometrical edges look smoother and more temporarily stable. This tutorial demonstrates how to use queries to retrieve various information about the GPU operation, such as the number of primitives rendered, command processing duration, etc. This tutorial demonstrates how to use the render passes API to implement simple deferred shading. This tutorial demonstrates how to use amplification and mesh shaders, the new programmable stages, to implement view frustum culling and object LOD calculation on the GPU. This tutorial demonstrates the basics of using ray tracing API in Diligent Engine.