DiligentEngine
v2.5.6
Une bibliothèque graphique 3D multiplateforme moderne et un cadre de rendu
Le moteur diligent est une bibliothèque d'abstraction API graphique multiplateforme légère et un cadre de rendu. Il est conçu pour tirer pleinement parti de Direct3D12, Vulkan, Metal et WebGPU, tout en prenant en charge les plates-formes plus anciennes via Direct3D11, OpenGL, OpenGles et WebGL. Diligent Engine expose une API frontale commune et utilise HLSL comme langage d'ombrage universel sur toutes les plates-formes et les back-end de rendu. Les représentations de shader spécifiques à la plate-forme (GLSL, MSL, dx bytecode ou spirv) peuvent être utilisées avec des back-end correspondants. Le moteur est destiné à être utilisé comme sous-système graphique dans un moteur de jeu ou toute autre application 3D. Il est distribué sous la licence Apache 2.0 et est libre à utiliser.
| Plate-forme | D3d11 | D3d12 | OpenGl / GLES | Vulkan | Métal | Webgpu | Statut de construction |
|---|---|---|---|---|---|---|---|
 Fenêtre | ✔️ | ✔️ | ✔️ | ✔️ | - | ✔️ 3 |  |
 Fenêtres universelles | ✔️ | ✔️ | - | - | - | - | |
 Linux | - | - | ✔️ | ✔️ | - | ✔️ 3 |  |
 Androïde | - | - | ✔️ | ✔️ | - | - |  |
 Macos | - | - | ✔️ | ✔️ 1 | ✔️ 2 | ✔️ 3 |  |
 ios | - | - | ✔️ | ✔️ 1 | ✔️ 2 | - | |
 tvos | - | - | - | ✔️ 1 | ✔️ 2 | - | |
 Emscripten | - | - | ✔️ | - | - | ✔️ |  |
1 L'API Vulkan n'est pas prise en charge nativement sur les plates-formes macOS, iOS et TVOS et nécessite une mise en œuvre de portabilité Vulkan telle que MoltenVK ou GFX-Portabilité.
2 Disponible sous licence commerciale - Veuillez nous contacter pour plus de détails.
3 nécessite une implémentation native de WebGPU, Dawn est recommandé.
#if defined(_WIN32) ... #elif defined(LINUX) ... #elif defined(ANDROID) ...#if defined(D3D11) ... #elif defined(D3D12) ... #elif defined(OPENGL) ...Versions API de bas niveau à prise en charge minimale:
Il s'agit du référentiel maître qui contient quatre sous-modules. Pour obtenir le référentiel et tous les sous-modules, utilisez la commande suivante:
git clone --recursive https://github.com/DiligentGraphics/DiligentEngine.git
Lors de la mise à jour du référentiel existant, n'oubliez pas de mettre à jour tous les sous-modules:
git pull
git submodule update --recursive
C'est également une bonne idée de ré-cours Cmake et d'effectuer une reconstruction propre après avoir obtenu la dernière version.
Le référentiel Master comprend les sous-modules suivants:
Le moteur diligent utilise CMake comme outil de construction multiplateforme. Pour commencer à utiliser CMake, téléchargez la dernière version (3,20 ou plus tard est requise). Une autre construction de construction est un interprète Python (3.0 ou ultérieure est requis). Si après avoir suivi les instructions ci-dessous, vous avez des problèmes de construction / exécution, veuillez jeter un œil au dépannage.
Construire des conditions préalables:
La prise en charge .NET nécessite .NET SDK 6.0 ou version ultérieure.
Utilisez l'outil Cmake GUI ou la ligne de commande pour générer des fichiers de construction. Par exemple, pour générer une solution Visual Studio 2022 64 bits et des fichiers de projet dans le dossier build / win64 , accédez au dossier racine du moteur et exécutez la commande suivante:
cmake -S . -B ./build/Win64 -G "Visual Studio 17 2022" -A x64
Vous pouvez générer une solution Win32 qui cible Win8.1 SDK en utilisant la commande suivante:
cmake -D CMAKE_SYSTEM_VERSION=8.1 -S . -B ./build/Win64_8.1 -G "Visual Studio 17 2022" -A x64
Si vous utilisez MingW, vous pouvez générer les fichiers de fabrication à l'aide de la commande ci-dessous (notez cependant que la fonctionnalité sera limitée et que Mingw n'est pas un moyen recommandé de construire le moteur):
cmake -S . -B ./build/MinGW -D CMAKE_BUILD_TYPE=Release -G "MinGW Makefiles"
Pour activer les couches de validation Vulkan, vous devrez télécharger le SDK Vulkan et ajouter VK_LAYER_PATH de la variable d'environnement qui contient le chemin du répertoire de bac dans le dossier d'installation Vulkansdk.
Ouvrez le fichier diligentengine.sln dans le dossier build / win64 , sélectionnez la configuration et construisez le moteur. Définissez le projet de démarrage souhaité (par défaut, la visionneuse GLTF sera sélectionnée) et l'exécutera.
Par défaut, les applications d'échantillons et de didacticiel affichent la boîte de dialogue de sélection de backend de rendu. Utilisez les options de ligne de commande suivantes pour forcer le mode D3D11, D3D12, OpenGL ou Vulkan: - mode D3D11 , - mode D3D12 , - mode GL ou - mode VK . Si vous souhaitez exécuter une application en dehors de Visual Studio Environment, le dossier Assets de l'application doit être défini en tant que répertoire de travail. (Pour Visual Studio, cela est automatiquement configuré par CMake). Alternativement, vous pouvez accéder au dossier de la cible de build ou installer et exécuter l'exécutable à partir de là.
Pour générer des fichiers de construction pour la plate-forme Windows universelle, vous devez définir les deux variables CMake suivantes:
CMAKE_SYSTEM_NAME=WindowsStoreCMAKE_SYSTEM_VERSION=< Windows Version >Par exemple, pour générer une solution Visual Studio 2022 64 bits et des fichiers de projet dans le dossier build / uwp64 , exécutez la commande suivante à partir du dossier racine du moteur:
cmake -D CMAKE_SYSTEM_NAME=WindowsStore -D CMAKE_SYSTEM_VERSION=10.0 -S . -B ./build/UWP64 -G "Visual Studio 17 2022" -A x64
Définissez le projet de démarrage souhaité (par défaut, la visionneuse GLTF sera sélectionnée) et l'exécutera.
Par défaut, les applications s'exécuteront en mode D3D12. Vous pouvez sélectionner D3D11 ou D3D12 à l'aide des options de ligne de commande suivantes: - mode D3D11 , - mode D3d12 .
Remarque: Il est possible de générer une solution qui cible Windows 8.1 en définissant CMake_System_version = 8.1 cmake variable, mais il ne parviendra pas à construire car il utilisera le jeu d'outils Visual Studio 2013 (V120) qui manque de support C ++ 14 approprié.
Votre environnement Linux doit être configuré pour le développement C ++. Si c'est déjà le cas, assurez-vous que vos outils C ++ sont à jour car le moteur diligent utilise des fonctionnalités C ++ modernes (Clang 10 ou version ultérieure est recommandé).
Vous devrez peut-être installer les packages suivants:
sudo apt-get update
sudo apt-get upgrade
sudo apt-get install build-essential
sudo apt-get install cmake
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
sudo apt-get install python3-distutils
sudo apt-get install libgl1-mesa-dev
sudo apt-get install libxrandr-dev
sudo apt-get install libxinerama-dev
sudo apt-get install libxcursor-dev
sudo apt-get install libxi-dev
Pour configurer Vulkan, vous devrez également:
Pour générer des fichiers Make pour la configuration de débogage, exécutez la commande CMake suivante à partir du dossier racine du moteur:
cmake -S . -B ./build -G "Unix Makefiles" -DCMAKE_BUILD_TYPE="Debug"
Pour construire le moteur, exécutez la commande suivante:
cmake --build ./build
Sur Ubuntu 23 et plus récent, il peut s'écraser si vous n'avez pas installé libtinfo5, vous devrez l'ajouter.
Le dossier racine du moteur contient des fichiers de paramètres de code Visual Studio qui configurent l'IDE pour construire le moteur. Vous pouvez exécuter des applications directement à partir de l'IDE. Pour exécuter une application à partir de la ligne de commande, le dossier Assets de l'application doit être le répertoire actuel.
Veuillez vous assurer que votre machine est configurée pour le développement Android. Téléchargez Android Studio, installez et configurez le NDK et le CMake et d'autres outils requis. NDK R24 ou ultérieure est requis. Si vous n'utilisez pas la version CMake regroupée avec Android Studio, assurez-vous que vos fichiers de construction sont correctement configurés. Pour vérifier que votre environnement est correctement configuré, essayez de construire l'échantillon de théières ainsi que des tutoriels Android Vulkan.
Open Diligents Samples / Android Folder avec Android Studio pour créer et exécuter des tutoriels et des échantillons sur Android.
Par défaut, les applications s'exécuteront en mode Vulkan. Pour les exécuter en mode Vulkan, ajoutez les indicateurs de lancement suivants: --es mode gles (dans Android Studio, allez dans> Modifier le menu Configurations)
Prérequis:
Après avoir cloné le dépôt, exécutez la commande suivante à partir du dossier racine du moteur pour générer le projet Xcode:
cmake -S . -B ./build/MacOS -G "Xcode"
Le projet sera situé dans le dossier build/MacOS .
Notez que si Cmake ne trouve pas le compilateur, vous devrez peut-être exécuter la commande suivante:
sudo xcode-select --reset
Par défaut, il n'y a pas d'implémentation Vulkan sur MacOS. Le moteur diligent charge de la vulkan dynamiquement et peut utiliser une mise en œuvre de portabilité Vulkan telle que MoltenVK ou GFX-Portabilité. Installez Vulkansdk et assurez-vous que votre système est correctement configuré comme décrit ici. En particulier, vous devrez peut-être définir les variables d'environnement suivantes (en supposant que le SDK Vulkan est installé sur /Users/MyName/VulkanSDK/1.3.290.0 et vous souhaitez utiliser Moltenvk):
export VULKAN_SDK=/Users/MyName/VulkanSDK/1.3.290.0/macOS
export PATH=$VULKAN_SDK/bin:$PATH
export DYLD_LIBRARY_PATH=$VULKAN_SDK/lib:$DYLD_LIBRARY_PATH
export VK_ADD_LAYER_PATH=$VULKAN_SDK/share/vulkan/explicit_layer.d
export VK_ICD_FILENAMES=$VULKAN_SDK/share/vulkan/icd.d/MoltenVK_icd.json
export VK_DRIVER_FILES=$VULKAN_SDK/share/vulkan/icd.d/MoltenVK_icd.json
Notez que les variables d'environnement définies dans le shell ne sont pas vues par les applications lancées à partir de LaunchPad ou d'une autre interface graphique de bureau. Ainsi, pour s'assurer qu'une application trouve des bibliothèques Vulkan, elle doit être démarrée à partir de la ligne de commande. Pour la même raison, le fichier du projet Xcode doit également être ouvert à partir du shell à l'aide de la commande open . Avec les versions Xcode 7 et ultérieurement, ce comportement peut devoir être activé d'abord en utilisant la commande suivante:
defaults write com.apple.dt.Xcode UseSanitizedBuildSystemEnvironment -bool NO
Veuillez vous référer à cette page pour plus de détails.
DYLD_LIBRARY_PATH et LD_LIBRARY_PATH Les variables d'environnement sont ignorées sur MacOS à moins que la protection de l'intégrité du système ne soit désactivée (ce qui n'est généralement pas recommandé). Pour que les exécutables trouvent la bibliothèque Vulkan, elle doit être dans RPATH. Si la variable d'environnement VULKAN_SDK est définie et pointe vers un emplacement correct, Diligent Engine configurera automatiquement le RPATH pour toutes les applications.
Dernière version SDK Vulkan testée: 1.3.290.0.
Prérequis:
Exécutez la commande ci-dessous à partir du dossier racine du moteur pour générer le projet Xcode configuré pour iOS Build:
cmake -S . -B ./build/iOS -DCMAKE_SYSTEM_NAME=iOS -G "Xcode"Si nécessaire, vous pouvez fournir une cible de déploiement iOS (13.0 ou ultérieure est requise) ainsi que d'autres paramètres, par exemple:
cmake -S . -B ./build/iOS -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_DEPLOYMENT_TARGET=13.0 -G "Xcode"iphonesimulator . Vous pouvez également utiliser la variable CMAKE_OSX_ARCHITECTURES pour spécifier l'architecture cible, par exemple:
cmake -S . -B ./build/iOSSim -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphonesimulator -DCMAKE_OSX_ARCHITECTURES=arm64 -G "Xcode" Ouvrez le fichier de projet Xcode dans le dossier build/IOS et construisez le moteur. Pour exécuter les applications sur un appareil iOS, vous devrez définir l'équipe de développement appropriée dans les paramètres du projet.
Pour activer Vulkan sur iOS, téléchargez et installez le vulkansdk. Il n'y a pas de chargeur Vulkan sur iOS et les liens diligents du moteur directement avec MOLTENVK XCFramework (voir le guide d'installation MoltenVK) qui implémente Vulkan sur le métal. Pour activer Vulkan dans Diligent Engine sur iOS, spécifiez le chemin du SDK Vulkan lors de l'exécution de CMake, par exemple (en supposant que le SDK Vulkan est installé sur /Users/MyName/VulkanSDK/1.3.290.0 ):
cmake -DCMAKE_SYSTEM_NAME=iOS -DVULKAN_SDK=/Users/MyName/VulkanSDK/1.3.290.0 -S . -B ./build/iOS -G "Xcode" Par défaut, le moteur est lié à MoltenVK XCFramework situé dans Vulkan SDK. Si cela n'est pas souhaité ou si une application souhaite utiliser une bibliothèque spécifique, elle peut fournir le chemin complet de la bibliothèque via la variable MOLTENVK_LIBRARY CMake.
Reportez-vous au Guide de l'utilisateur MoltenVK pour plus d'informations sur l'installation et l'utilisation de Moltenvk.
Dernière version SDK Vulkan testée: 1.3.290.0.
Construire des conditions préalables:
Pour activer le chemin et les autres variables d'environnement dans le terminal actuel
source ${PATH_TO_EMSDK} /emsdk/emsdk_env.sh${PATH_TO_EMSDK}/emsdk/emsdk_env.bat au lieu de source ${PATH_TO_EMSDK}/emsdk/emsdk_env.sh
Pour générer un projet, exécutez la commande CMake suivante à partir du dossier racine du moteur:
emcmake cmake -S . -B ./build/Emscripten -G "Ninja"Pour construire le moteur, exécutez la commande suivante:
cmake --build ./build/EmscriptenPour tester les applications EMScripten, exécutez un serveur Web de base
cd ./build/Emscripten
python https_server.py Ouvrez un navigateur et accédez à http://localhost
Par exemple, le tutoriel Hello Triangle sera disponible à
http://localhost/DiligentSamples/Tutorials/Tutorial01_HelloTriangle/Tutorial01_HelloTriangle.html
Pour accéder au serveur à partir d'un autre ordinateur sur le réseau local, utilisez le serveur HTTPS. Pour activer cela, installez d'abord le module cryptography . Vous pouvez le faire en exécutant la commande suivante:
pip install cryptographyPour démarrer le serveur HTTPS, utilisez la commande suivante:
python https_server.py --mode=httpsUtilisez le protocole HTTPS pour ouvrir les pages. Par exemple:
https://localhost/DiligentSamples/Tutorials/Tutorial01_HelloTriangle/Tutorial01_HelloTriangle.html
Lorsque vous utilisez le serveur HTTPS, contrairement au serveur HTTP, vous pouvez rencontrer l'erreur suivante lors du chargement de la page: net::ERR_CERT_AUTHORITY_INVALID .
Il existe deux façons de résoudre ce problème:
Advanced , puis sélectionnez Proceed to localhost (unsafe) .python https_server.py --mode=https --register Nous utilisons les ports par défaut pour les protocoles HTTP / HTTPS, 80 et 443 respectivement. Si vous avez déjà un serveur exécuté sur ces ports, vous pouvez spécifier un autre numéro de port à l'aide de l'argument --port et inclure le numéro de port correspondant dans l'URL après l'adresse IP. Par exemple:
http://localhost:${YOUR_PORT}/DiligentSamples/Tutorials/Tutorial01_HelloTriangle/Tutorial01_HelloTriangle.html
Diligent a une structure modulaire, donc pour votre projet, vous ne pouvez utiliser que les sous-modules qui implémentent les fonctionnalités requises. Le diagramme ci-dessous montre les dépendances entre les modules.
Core
|
+------>Tools----------.
| | |
| V |
+------->FX---------. |
| | |
| V V
'----------------->Samples
N'oubliez pas d'initialiser récursivement les sous-modules si vous ajoutez des reposs diligents sous forme de sous-modules à votre projet.
Si votre projet utilise Cmake, l'ajout de moteur diligent ne nécessite que quelques lignes de code. Supposons que la structure du répertoire ressemble à ceci:
|
+-DiligentCore
+-HelloDiligent.cpp
Ensuite, les étapes suivantes doivent être effectuées:
add_subdirectory(DiligentCore)Vous trouverez ci-dessous un exemple de fichier cmake:
cmake_minimum_required ( VERSION 3.6)
project (HelloDiligent CXX)
add_subdirectory (DiligentCore)
add_executable (HelloDiligent WIN32 HelloDiligent.cpp)
target_compile_options (HelloDiligent PRIVATE -DUNICODE)
target_link_libraries (HelloDiligent
PRIVATE
Diligent-GraphicsEngineD3D11-shared
Diligent-GraphicsEngineOpenGL-shared
Diligent-GraphicsEngineD3D12-shared
Diligent-GraphicsEngineVk-shared
)
copy_required_dlls(HelloDiligent) copy_required_dlls() est une fonction de commodité qui copie les bibliothèques partagées à côté de l'exécutable afin que le système puisse les trouver et les charger. Veuillez également jeter un coup d'œil aux tutoriels de démarrage pour Windows et Linux.
Sur la plupart des plates-formes, les bibliothèques de moteurs de base sont construites dans des versions statiques et dynamiques (par exemple, Diligent-GraphicsEngineD3D12-static et Diligent-GraphicsEngineD3D12-shared ). Vous pouvez choisir la version avec laquelle vous lier en modifiant le nom cible dans target_link_libraries() CMake Commande. Lors du lien avec les bibliothèques dynamiques, la macro ENGINE_DLL sera définie et les bibliothèques devront être chargées au moment de l'exécution. Par exemple, pour le backend Direct3D12:
# if ENGINE_DLL
// Load the dll and import GetEngineFactoryD3D12() function
auto GetEngineFactoryD3D12 = LoadGraphicsEngineD3D12();
# endif
auto * pFactoryD3D12 = GetEngineFactoryD3D12(); Lorsque vous utilisez une liaison statique, la macro ENGINE_DLL ne sera pas définie et la fonction GetEngineFactoryD3D12 sera liée statiquement à l'exécutable.
Le fichier SampleApp.cpp fournit un exemple de la façon d'initialiser le moteur sur différentes plates-formes à l'aide de liaisons statiques ou dynamiques.
Vous pouvez utiliser FetchContent pour télécharger des modules de moteur diligent. La seule mise en garde est que vous devez spécifier le répertoire source pour que chaque module soit le même que le nom du module, afin que les fichiers d'en-tête soient trouvés. Vous trouverez ci-dessous un exemple de fichier CMake qui utilise FetchContent:
cmake_minimum_required ( VERSION 3.6)
project (HelloDiligent CXX)
include (FetchContent)
FetchContent_Declare(
DiligentCore
GIT_REPOSITORY https://github.com/DiligentGraphics/DiligentCore.git
SOURCE_DIR _deps/DiligentCore
)
FetchContent_Declare(
DiligentTools
GIT_REPOSITORY https://github.com/DiligentGraphics/DiligentTools.git
SOURCE_DIR _deps/DiligentTools
)
FetchContent_Declare(
DiligentFX
GIT_REPOSITORY https://github.com/DiligentGraphics/DiligentFX.git
SOURCE_DIR _deps/DiligentFX
)
FetchContent_MakeAvailable(DiligentCore DiligentTools DiligentFX)
add_executable (HelloDiligent WIN32 HelloDiligent.cpp)
target_include_directories (HelloDiligent
PRIVATE
${diligentcore_SOURCE_DIR}
${diligenttools_SOURCE_DIR}
${diligentfx_SOURCE_DIR}
)
target_compile_definitions (HelloDiligent PRIVATE UNICODE)
target_link_libraries (HelloDiligent
PRIVATE
Diligent-BuildSettings
Diligent-GraphicsEngineD3D11-shared
Diligent-GraphicsEngineD3D12-shared
Diligent-GraphicsEngineOpenGL-shared
Diligent-GraphicsEngineVk-shared
DiligentFX
)
copy_required_dlls(HelloDiligent)Si votre projet n'utilise pas CMake, il est recommandé de créer des bibliothèques avec CMake et de les ajouter à votre système de construction. Vous pouvez télécharger les derniers artefacts de construction à partir de GitHub.
Le répertoire d'installation CMake global est contrôlé par la variable CMake_intall_prefix. Notez qu'il est par défaut /usr/local sur UNIX et c:/Program Files/${PROJECT_NAME} sur Windows, qui peut ne pas être ce que vous voulez. Use -D CMAKE_INSTALL_PREFIX=install pour utiliser le dossier install local à la place:
cmake -S . -B ./build/Win64 -D CMAKE_INSTALL_PREFIX=install -G "Visual Studio 17 2022" -A x64
Pour installer des bibliothèques et des fichiers d'en-tête, exécutez la commande CMake suivante dans le dossier de construction:
cmake --build . --target installLe répertoire d'installation de Diligentcore contiendra tout ce qui est nécessaire pour intégrer le moteur:
Un moyen plus facile consiste à créer un lien avec les bibliothèques dynamiques. Lors du lien statiquement, vous devrez énumérer DiligentCore ainsi que toutes les bibliothèques tierces utilisées par le moteur. En plus de cela, vous devrez également spécifier des bibliothèques système spécifiques à la plate-forme. Par exemple, pour la plate-forme Windows, la liste des bibliothèques à laquelle votre projet devra lier peut ressembler à ceci:
DiligentCore.lib glslang.lib HLSL.lib OGLCompiler.lib OSDependent.lib spirv-cross-core.lib SPIRV.lib SPIRV-Tools-opt.lib SPIRV-Tools.lib glew-static.lib GenericCodeGen.lib MachineIndependent.lib dxgi.lib d3d11.lib d3d12.lib d3dcompiler.lib opengl32.lib
Les en-têtes de moteur diligents nécessitent que l'une des macros de plate-forme suivantes soit définie comme 1 : PLATFORM_WIN32 , PLATFORM_UNIVERSAL_WINDOWS , PLATFORM_ANDROID , PLATFORM_LINUX , PLATFORM_MACOS , PLATFORM_IOS .
Vous pouvez contrôler les composants du moteur que vous souhaitez installer en utilisant les options CMake suivantes: DILIGENT_INSTALL_CORE , DILIGENT_INSTALL_FX , DILIGENT_INSTALL_SAMPLES et DILIGENT_INSTALL_TOOLS .
Une autre façon d'intégrer le moteur est de générer des fichiers de construction (tels que des projets Visual Studio) et de les ajouter à votre système de construction. La personnalisation de construction décrite ci-dessous peut aider à modifier les paramètres de vos besoins spécifiques.
Les options CMake disponibles sont résumées dans le tableau ci-dessous:
| Option | Valeur par défaut | Description |
|---|---|---|
DILIGENT_NO_DIRECT3D11 | Non | Ne construisez pas le backend direct3d11 |
DILIGENT_NO_DIRECT3D12 | Non | Ne construisez pas le backend direct3d12 |
DILIGENT_NO_OPENGL | Non | Ne construisez pas le backend OpenGl |
DILIGENT_NO_VULKAN | Non | Ne construisez pas le backend Vulkan |
DILIGENT_NO_METAL | Non | Ne construisez pas le backend métallique |
DILIGENT_NO_WEBGPU | Non | Ne créez pas de backend webgpu |
DILIGENT_NO_ARCHIVER | Non | Ne construisez pas d'archiver |
DILIGENT_NO_RENDER_STATE_PACKAGER | Non | Ne construisez pas l'outil de packageur d'état de rendu |
DILIGENT_ENABLE_DRACO | Non | Activer le support de compression Draco dans le chargeur GLTF |
DILIGENT_USE_RAPIDJSON | Non | Utilisez un analyseur RapidJson dans le chargeur GLTF |
DILIGENT_BUILD_TOOLS | Oui | Module de création d'outils |
DILIGENT_BUILD_FX | Oui | Construire le module FX |
DILIGENT_BUILD_SAMPLES | Oui | Construire le module des échantillons |
DILIGENT_BUILD_SAMPLE_BASE_ONLY | Non | Créez uniquement un projet d'échantillons et aucun autre échantillon / tutoriel |
DILIGENT_BUILD_TESTS | Non | Construire des tests unitaires |
DILIGENT_NO_GLSLANG | Non | Ne construisez pas de glslang et de spriv-tools |
DILIGENT_NO_HLSL | Non | Désactiver le support HLSL dans les backends non direct3d |
DILIGENT_NO_FORMAT_VALIDATION | Oui | Désactiver la validation du formatage du code source |
DILIGENT_LOAD_PIX_EVENT_RUNTIME | Non | Activer la prise en charge de l'événement PIX |
DILIGENT_NVAPI_PATH | Chemin vers NVAPI SDK | |
DILIGENT_INSTALL_CORE | Oui | Installer le module de base |
DILIGENT_INSTALL_TOOLS | Oui | Installer le module des outils |
DILIGENT_INSTALL_FX | Oui | Installer le module FX |
DILIGENT_INSTALL_SAMPLES | Oui | Installer le module des échantillons |
DILIGENT_INSTALL_PDB | Non | Installer la base de données de débogage du programme |
DILIGENT_DEAR_IMGUI_PATH | Chemin facultatif vers un projet cher IMGUI fourni par l'utilisateur | |
DILIGENT_ARGS_DIR | Chemin facultatif vers un projet ARGS fourni par l'utilisateur | |
DILIGENT_NUKLEAR_DIR | Chemin facultatif vers un projet Nuklear fourni par l'utilisateur | |
DILIGENT_MSVC_COMPILE_OPTIONS | Options de compilation MSVC supplémentaires pour toutes les configurations | |
DILIGENT_MSVC_DEBUG_COMPILE_OPTIONS | Options de compilation MSVC supplémentaires pour la configuration de débogage | |
DILIGENT_MSVC_RELEASE_COMPILE_OPTIONS | / Gl / arch: avx2 | Options de compilation MSVC supplémentaires pour les configurations de version |
DILIGENT_CLANG_COMPILE_OPTIONS | Options de compilation Clang supplémentaires pour toutes les configurations | |
DILIGENT_CLANG_DEBUG_COMPILE_OPTIONS | Options supplémentaires de compilation de Clang pour la configuration de débogage | |
DILIGENT_CLANG_RELEASE_COMPILE_OPTIONS | -Mavx2 | Options de compilation de Clang supplémentaires pour les configurations de version |
DILIGENT_USD_PATH | Chemin vers le dossier d'installation USD |
Par défaut, tous les back-end disponibles sur la plate-forme actuelle sont construits. Pour désactiver les back-finds spécifiques, utilisez les options suivantes: DILIGENT_NO_DIRECT3D11 , DILIGENT_NO_DIRECT3D12 , DILIGENT_NO_OPENGL , DILIGENT_NO_VULKAN , DILIGENT_NO_METAL , DILIGENT_NO_WEBGPU . Le backend WebGPU est activé par défaut lors de la création pour le Web. Pour l'activer sur d'autres plates-formes, utilisez DILIGENT_NO_WEBGPU=OFF . Les options peuvent être définies via Cmake UI ou à partir de la ligne de commande comme dans l'exemple ci-dessous:
cmake -D DILIGENT_NO_DIRECT3D11=TRUE -S . -B ./build/Win64 -G "Visual Studio 17 2022" -A x64
De plus, les composants du moteur individuels peuvent être activés ou désactivés à l'aide des options suivantes: DILIGENT_BUILD_TOOLS , DILIGENT_BUILD_FX , DILIGENT_BUILD_SAMPLES . Si vous souhaitez uniquement construire un projet SampleBase , vous pouvez utiliser l'option DILIGENT_BUILD_SAMPLE_BASE_ONLY .
Par défaut, le back-end Vulkan est lié à GLSLang qui permet à la compilation de Shaders HLSL et GLSL de SPURV au moment de l'exécution. Si la compilation d'exécution n'est pas requise, GLSLANG peut être désactivé avec l'option DILIGENT_NO_GLSLANG CMake. De plus, la prise en charge de HLSL dans les backends non direct3d peut être désactivée avec l'option DILIGENT_NO_HLSL . L'activation des options réduit considérablement la taille des binaires back-end Vulkan et OpenGL, ce qui peut être particulièrement important pour les applications mobiles.
Le moteur diligent utilise le format de clang pour assurer un formatage cohérent dans toute la base de code. La validation peut être désactivée en utilisant l'option DILIGENT_NO_FORMAT_VALIDATION cmake. Notez que toute demande de traction échouera si des problèmes de formatage sont trouvés.
Le moteur diligent utilise une validation approfondie qui est toujours activée dans la construction de débogage. Certaines vérifications peuvent être activées dans les configurations de publication en définissant l'option DILIGENT_DEVELOPMENT CMake.
Pour activer la prise en charge des événements PIX, définissez DILIGENT_LOAD_PIX_EVENT_RUNTIME Cmake Indicateur.
Pour activer certaines fonctionnalités avancées sur NVIDIA GPUS (telles que la prise en charge indirecte multi-tir native dans Direct3d11), téléchargez NVAPI et définissez la variable DILIGENT_NVAPI_PATH CMake.
Diligent Engine utilise plusieurs bibliothèques tierces. Si le fichier CMake d'une application définit l'une de ces bibliothèques, Diligent utilisera des cibles existantes. L'application devra s'assurer que les paramètres de construction sont compatibles avec diligents.
Diligent Engine permet aux clients de personnaliser les paramètres de construction en fournissant un fichier de script de configuration qui définit les fonctions CMake en option suivantes:
custom_configure_build() - Définit les propriétés globales de construction telles que les configurations de construction, les indicateurs de compilation C / C ++, les indicateurs de liaison, etc.custom_pre_configure_target() - définit les paramètres personnalisés pour chaque cible de la construction et est appelé avant que le système de construction du moteur ne commence à configurer la cible.custom_post_configure_target() - appelé après que le système de construction du moteur a configuré la cible pour permettre au client de remplacer les propriétés définies par le moteur. Le chemin d'accès au script de configuration doit être fourni via la variable BUILD_CONFIGURATION_FILE lors de l'exécution de CMake et doit être relatif au dossier racine CMake, par exemple:
cmake -D BUILD_CONFIGURATION_FILE=BuildConfig.cmake -S . -B ./build/Win64 -G "Visual Studio 17 2022" -A x64
S'il est défini, la fonction custom_configure_build() est appelée avant que toute cible de construction ne soit ajoutée. Par défaut, CMake définit les quatre configurations suivantes: Debug, Release, RelWithDebinfo, Minsizerel. Si vous le souhaitez, vous pouvez définir vos propres configurations de construction en définissant la variable CMAKE_CONFIGURATION_TYPES . Par exemple, si vous souhaitez avoir seulement deux configurations: débogage et releasemt, ajoutez la ligne suivante à la fonction custom_configure_build() :
set (CMAKE_CONFIGURATION_TYPES Debug ReleaseMT CACHE STRING "Configuration types: Debug, ReleaseMT" FORCE ) Le système de construction doit connaître la liste des configurations de débogage et de libération (optimisées), de sorte que les deux variables suivantes doivent également être définies lorsque la variable CMAKE_CONFIGURATION_TYPES est définie:
set (DEBUG_CONFIGURATIONS DEBUG CACHE INTERNAL "" FORCE )
set (RELEASE_CONFIGURATIONS RELEASEMT CACHE INTERNAL "" FORCE ) Notez qu'en raison des spécificités CMake, les noms de configuration répertoriés dans DEBUG_CONFIGURATIONS et RELEASE_CONFIGURATIONS doivent être capitalisés .
Si vous définissez une configuration autres que quatre cmake standard, vous devez également définir les variables suivantes, pour chaque nouvelle configuration:
CMAKE_C_FLAGS_<Config> - C compiler les indicateursCMAKE_CXX_FLAGS_<Config> - Faculteurs de compilation C ++CMAKE_EXE_LINKER_FLAGS_<Config> - Indicateurs de liaison exécutableCMAKE_SHARED_LINKER_FLAGS_<Config> - Indicateurs de liaison de bibliothèque partagéePar exemple:
set (CMAKE_C_FLAGS_RELEASEMT "/MT" CACHE INTERNAL "" FORCE )
set (CMAKE_CXX_FLAGS_RELEASEMT "/MT" CACHE INTERNAL "" FORCE )
set (CMAKE_EXE_LINKER_FLAGS_RELEASEMT "/OPT:REF" CACHE INTERNAL "" FORCE )
set (CMAKE_SHARED_LINKER_FLAGS_RELEASEMT "/OPT:REF" CACHE INTERNAL "" FORCE )Vous trouverez ci-dessous un exemple de fonction Custom_Configure_Build ():
function (custom_configure_build)
if (CMAKE_CONFIGURATION_TYPES)
# Debug configurations
set (DEBUG_CONFIGURATIONS DEBUG CACHE INTERNAL "" FORCE )
# Release (optimized) configurations
set (RELEASE_CONFIGURATIONS RELEASEMT CACHE INTERNAL "" FORCE )
# CMAKE_CONFIGURATION_TYPES variable defines build configurations generated by cmake
set (CMAKE_CONFIGURATION_TYPES Debug ReleaseMT CACHE STRING "Configuration types: Debug, ReleaseMT" FORCE )
set (CMAKE_CXX_FLAGS_RELEASEMT "/MT" CACHE INTERNAL "" FORCE )
set (CMAKE_C_FLAGS_RELEASEMT "/MT" CACHE INTERNAL "" FORCE )
set (CMAKE_EXE_LINKER_FLAGS_RELEASEMT "/OPT:REF" CACHE INTERNAL "" FORCE )
set (CMAKE_SHARED_LINKER_FLAGS_RELEASEMT "/OPT:REF" CACHE INTERNAL "" FORCE )
endif ()
endfunction () S'il est défini, custom_pre_configure_target() est appelé pour chaque cible créée par le système de construction et permet de configurer les propriétés spécifiques de la cible.
Par défaut, le système de construction définit certaines propriétés cibles. Si custom_pre_configure_target() définit toutes les propriétés requises, il peut indiquer au système de construction qu'aucun traitement supplémentaire n'est requis en définissant TARGET_CONFIGURATION_COMPLETE Parent Scope Variable à TRUE :
set (TARGET_CONFIGURATION_COMPLETE TRUE PARENT_SCOPE ) Ce qui suit est un exemple de fonction custom_pre_configure_target() :
function (custom_pre_configure_target TARGET )
set_target_properties ( ${TARGET} PROPERTIES
STATIC_LIBRARY_FLAGS_RELEASEMT /LTCG
)
set (TARGET_CONFIGURATION_COMPLETE TRUE PARENT_SCOPE )
endfunction () Si le client n'a besoin que de remplacer certains paramètres, il peut définir la fonction custom_post_configure_target() qui est appelée une fois le moteur terminé la configuration de la cible, par exemple:
function (custom_post_configure_target TARGET )
set_target_properties ( ${TARGET} PROPERTIES
CXX_STANDARD 17
)
endfunction ()Veuillez vous référer à cette page. En outre, les tutoriels et les échantillons répertoriés ci-dessous sont un bon point de départ.
La notation de l'état de rendu diligent est une langue basée sur JSON qui décrit les shaders, les états de pipeline, les signatures de ressources et autres objets sous une forme pratique, par exemple:
{
"Shaders" : [
{
"Desc" : {
"Name" : " My Vertex shader " ,
"ShaderType" : " VERTEX "
},
"SourceLanguage" : " HLSL " ,
"FilePath" : " cube.vsh "
},
{
"Desc" : {
"Name" : " My Pixel shader " ,
"ShaderType" : " PIXEL "
},
"SourceLanguage" : " HLSL " ,
"FilePath" : " cube.psh " ,
}
],
"Pipeleines" : [
{
"GraphicsPipeline" : {
"DepthStencilDesc" : {
"DepthEnable" : true
},
"RTVFormats" : {
"0" : " RGBA8_UNORM_SRGB "
},
"RasterizerDesc" : {
"CullMode" : " FRONT "
},
"BlendDesc" : {
"RenderTargets" : {
"0" : {
"BlendEnable" : true
}
}
}
},
"PSODesc" : {
"Name" : " My Pipeline State " ,
"PipelineType" : " GRAPHICS "
},
"pVS" : " My Vertex shader " ,
"pPS" : " My Pixel shader "
}
]
}Les fichiers JSON peuvent être analysés dynamiquement au moment de l'exécution. Alternativement, une application peut utiliser l'outil Packager pour prétraiter les descriptions de pipelines (compiler les shaders pour les plates-formes cibles, définir les dispositions de ressources internes, etc.) dans une archive binaire optimisée pour les performances de chargement du temps d'exécution.
| Tutoriel | Capture d'écran | Description |
|---|---|---|
| 01 - Bonjour triangle |  | Ce tutoriel montre comment rendre un triangle simple à l'aide de l'API de moteur diligent. |
| 02 - Cube |  | Ce tutoriel montre comment rendre un véritable objet 3D, un cube. Il montre comment charger des shaders à partir de fichiers, créer et utiliser des sommets, index et tampons uniformes. |
| 03 - Texturation |  | Ce tutoriel montre comment appliquer une texture à un objet 3D. Il montre comment charger une texture à partir du fichier, créer un objet de liaison des ressources de shader et comment goûter une texture dans le shader. |
| 03 - Texturation-C | | Ce tutoriel est identique à Tutorial03, mais est implémenté à l'aide de l'API C. |
| 03 - Texturation-Dotnet | | Ce didacticiel montre comment utiliser l'API du moteur diligent dans les applications .NET. |
| 04 - instance |  | Ce didacticiel montre comment utiliser l'instances pour rendre plusieurs copies d'un objet en utilisant une matrice de transformation unique pour chaque copie. |
| 05 - Tableau de texture |  | Ce tutoriel montre comment combiner l'instances avec des tableaux de texture pour utiliser une texture unique pour chaque instance. |
| 06 - Multithreading |  | Ce tutoriel montre comment générer des listes de commandes en parallèle à partir de plusieurs threads. |
| 07 - Shader de géométrie |  | Ce tutoriel montre comment utiliser le shader de géométrie pour rendre le filon lisse. |
| 08 - Tessellation |  | Ce didacticiel montre comment utiliser une tessellation matérielle pour implémenter un algorithme de rendu adaptatif de terrain adaptatif. |
| 09 - Quads |  | Ce tutoriel montre comment rendre plusieurs quads 2D, changeant fréquemment de textures et modes de mélange. |
| 10 - Streaming de données |  | Ce didacticiel affiche une stratégie de mappage de tampon dynamique à l'aide de MAP_FLAG_DISCARD et MAP_FLAG_DO_NOT_SYNCHRONIZE Flags pour diffuser efficacement des quantités variables de données vers le GPU. |
| 11 - Mises à jour des ressources |  | Ce tutoriel montre différentes façons de mettre à jour les tampons et les textures dans le moteur diligent et explique des détails internes importants et des implications de performances liées à chaque méthode. |
| 12 - Rendre l'objectif |  | Ce tutoriel montre comment rendre un cube 3D dans une cible de rendu hors écran et effectuer un effet post-traitement simple. |
| 13 - Carte d'ombre |  | Ce tutoriel montre comment rendre les ombres de base à l'aide d'une carte d'ombre. |
| 14 - Shader de calcul |  | Ce tutoriel montre comment implémenter un système de simulation de particules simples à l'aide de shaders de calcul. |
| 15 - plusieurs fenêtres |  | Ce tutoriel montre comment utiliser le moteur diligent pour rendre à plusieurs fenêtres. |
| 16 - Ressources sans liaison |  | Ce didacticiel montre comment implémenter des ressources sans liaison, une technique qui tire parti de la fonction d'indexation des ressources de shader dynamique activée par les API de prochaine génération pour améliorer considérablement les performances de rendu. |
| 17 - MSAA |  | Ce didacticiel montre comment utiliser l'anti-aliasing multi-échantillons (MSAA) pour rendre les bords géométriques plus lisses et plus temporairement stables. |
| 18 - requêtes |  | Ce didacticiel montre comment utiliser les requêtes pour récupérer diverses informations sur l'opération GPU, telles que le nombre de primitives rendues, la durée de traitement de commande, etc. |
| 19 - Rendre les laissez-passer |  | Ce didacticiel montre comment utiliser l'API des passes de rendu pour implémenter un ombrage différé simple. |
| 20 - shader en maillage |  | Ce didacticiel montre comment utiliser l'amplification et les shaders de maillage, les nouvelles étapes programmables, pour implémenter le calcul de la vue et le calcul de l'objet LOD sur le GPU. |
| 21 - Tracage des rayons |  | Ce didacticiel montre les bases de l'utilisation de l'API de traçage des rayons dans le moteur diligent. |
| 22 - rendu hybride |  | Ce didacticiel montre comment implémenter un rendu hybride simple qui combine la rasterisation avec le traçage des rayons. |
| 23 - files d'attente de commande |  | Ce didacticiel montre comment utiliser plusieurs files d'attente de commandes pour effectuer le rendu parallèlement aux opérations de copie et de calcul. |
| 24 - ombrage à taux variable |  | Ce tutoriel montre comment utiliser l'ombrage variable pour réduire la charge d'ombrage des pixels. |
| 25 - Render State Packager |  | Ce tutoriel montre comment créer et archiver les états de pipeline avec l'outil hors ligne de Render State Packager sur l'exemple d'un traceur de chemin simple. |
| 26 - Rendez le cache d'état |  | Ce didacticiel étend la technique de traçage de chemin implémentée dans le tutoriel précédent et montre comment utiliser le cache d'état de rendu pour enregistrer les états de pipeline créés au moment de l'exécution et les charger lorsque l'application démarre. |
| 27 - post-traitement |  | Ce didacticiel montre comment utiliser les effets post-traitement du module DiligentFX. |
| Échantillon | Capture d'écran | Description |
|---|---|---|
| Échantillon d'atmosphère |  | Cet échantillon montre comment intégrer l'effet post-traitement de la diffusion de la lumière épipolaire dans une application pour rendre l'atmosphère physiquement basée physique. |
| Démo GLFW |  | Ce mini-jeu de labyrinthes montre comment utiliser GLFW pour créer une fenêtre et gérer l'entrée du clavier et de la souris. |
| Visionneuse GLTF |  | Cet échantillon montre comment utiliser le chargeur d'actifs et le rendu PBR pour charger et rendre les modèles GLTF. |
| Visionneuse USD |  | Cet échantillon montre comment rendre les fichiers USD à l'aide d'hydrogents, une implémentation de l'API de rendu HYDRA dans un moteur diligent. |
| Ombres |  | Cet échantillon montre comment utiliser le composant d'observation pour rendre les ombres de haute qualité. |
| Cher démo imgui |  | Cet échantillon démontre l'intégration du moteur avec une bibliothèque UI IMGui chère. |
| Démo nuklear |  | Cet échantillon montre l'intégration du moteur avec bibliothèque d'interface utilisateur Nuklear. |
| Bonjour ar |  | Cet échantillon montre comment utiliser le moteur diligent dans une application Android AR de base. |
| Astéroïdes |  | Ce Sampple est une référence de performance qui rend 50 000 astéroïdes texturés uniques et permet de comparer les performances de différents modes de rendu. |
| Démo d'intégration d'unité |  | Ce projet démontre l'intégration d'un moteur diligent avec unité. |
La fonctionnalité de rendu de haut niveau est implémentée par le module DiligentFX. Les composants suivants sont maintenant disponibles:
 | |
 |  |
Anti-aliasing temporel
Utilitaires de shader de cartographie de tonalité
Nous apprécierions que vous puissiez nous envoyer un lien au cas où votre produit utilise un moteur diligent.
Système de visualisation du terrain à grande échelle pour les simulators de formation pilote par les systèmes Elbit
Lumenrt: un logiciel de visualisation et de modélisation de la réalité par Bentley Systems
GODUS: Un jeu de sandbox primé de 22Cans
Graphiques VRMAC: une bibliothèque graphique multiplateforme pour .NET 
Diligent Engine is an open project that may be freely used by everyone. We started it to empower the community and help people achieve their goals. Sadly enough, not everyone's goals are worthy. Please don't associate us with suspicious projects you may find on the Web that appear to be using Diligent Engine. We neither can possibly track all such uses nor can we really do anything about them because our permissive license does not give us a lot of leverage.
See Apache 2.0 license.
Each module has some third-party dependencies, each of which may have independent licensing:
To contribute your code, submit a Pull Request to this repository. Diligent Engine is licensed under the Apache 2.0 license that guarantees that content in the DiligentEngine repository is free of Intellectual Property encumbrances. In submitting any content to this repository, you license that content under the same terms, and you agree that the content is free of any Intellectual Property claims and you have the right to license it under those terms.
Diligent Engine uses clang-format to ensure consistent source code style throughout the code base. The format is validated by CI for each commit and pull request, and the build will fail if any code formatting issue is found. Please refer to this page for instructions on how to set up clang-format and automatic code formatting.
Coding Guidelines
Performance Best Practices
Code Formatting
See Release History
diligentgraphics.com
