The engine consists of the following logical modules:
- Core module is the collection of libraries and platform utilities that provide all the key functionality. The module contains the following projects:
- GraphicsEngine (Graphics/GraphicsEngine) provides platform-independent base functionality
- GraphicsEngineD3DBase (Graphics/GraphicsEngineD3DBase) provides base functionality for D3D11/D3D12 implementations
- GraphicsEngineD3D11 (Graphics/GraphicsEngineD3D11) is the engine implementation with Direct3D11
- GraphicsEngineD3D12 (Graphics/GraphicsEngineD3D12) is the engine implementation with Direct3D12
- GraphicsEngineOpenGL (Graphics/GraphicsEngineOpenGL) is the engine implementation with OpenGL/OpenGLES
- GraphicsTools (Graphics/GraphicsTools) provides basic graphics utilities
- BasicPlatform (Platforms/BasicPlatform) defines interface for platform-specific routines and implements some common functionality
- AndroidPlatform (Platforms/Android) implements platform-specific routines on Android
- Win32Platform (Platforms/Win32) implements platform-specific routines on Win32 desktop
- UniversalWindowsPlatform (Platforms/UWP) implements platform-specific routines on Universal Windows Platform
- Common (Common) implements some common functionality such as file wrapper, debug utilities etc.
- Tools module implements additional utilities on top of the core library:
- RenderScript is the simple Lua-based script that facilitates graphics object creation and management.
- TextureLoader provides texture and image loading routines.
- Samples module contains simple applications that demonstrate the usage of the engine:
- SampleBase provides base functionality for all samples
- AntTweakBarSample demonstrates the usage of AntTweakBar library to create simple user interface
- AtmosphereSample renders atmospheric scattering effects
- TrickyCubeSample demonstrates various rendering techniques such as render to texture and compute shaders
The modules also contain the following 3rd party libraries and components (located in the External subdirectory):
- Core module:
- Tools module:
- libjpeg is a library for loading and writing jpeg files (project homepage)
- LibPng is a library for loading and writing png files (project homepage)
- LibTiff is a library for loading and writing tiff files (project homepage)
- zlib is a free losless data compression library (project homepage)
- Lua is an embedded scripting language (project homepage)
- Samples module:
Downloading the Engine
The engine source code is hosted on GitHub (https://github.com/diligentgraphics). Every module is kept in its own repository:
- Core: https://github.com/DiligentGraphics/DiligentCore
- Tools: https://github.com/DiligentGraphics/DiligentTools
- Samples: https://github.com/DiligentGraphics/DiligentSamples
Every module can be downloaded independently. Alternatively, there is a master repository that includes all three as submodules: https://github.com/DiligentGraphics/DiligentEngine.
Building the Engine
To build the engine for Win32 platform, Microsoft Visual Studio 2015 or later is required. Any edition including Visual Studio Community is sufficient. Open the solution file located in build\Win32 folder, choose the desired configuration and build it. Note that ARM platform is intended to build the engine for Android (see below).
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.
There is a build subdirectory in each project’s directory that contains Visual Studio project files.
GraphicsEngineD3D11, GraphicsEngineD3D12 and GraphicsEngineOpenGL projects can be built as either static or dynamic link library.
Universal Windows Platform
As with the Windows Desktop, Microsoft Visual Studio 2015 or later is required to build the engine for Universal Windows Platform platform. Again, any edition including Visual Studio Community is sufficient. Navigate to build\UWP directory, open solution file and build the solution for the desired configuration.
To build the engine for Android, you first need to set up your machine for Android development: download Android SDK (Android Studio is not required), Android NDK, Apache Ant and other required tools. There are two ways to build the engine for Android:
- Download and install Visual GDB plugin for Visual Studio, open Windows Desktop solution (located in build\Win32 folder), select ARM platform and build the solution as usual. Note that despite the name, you can build the application for both ARM and x86 Android platforms. You can then deploy and run your Android application directly from the IDE
- It is important to rebuild the app project for the first time
- To run the app from Visual Studio, go to Project Settings->Debugging and select Local Windows Debugger option in the Debugger to launch drop-down list. Then start the application
- In command line, navigate to the build\Win32 folder of the project you want to build and use ndk-build. In the folder you can fine android_build.txt file with detailed build instructions
Note that when building for Android, the engine root path must not contain white spaces.