DiligentEngine
v2.5.6
Eine moderne plattformübergreifende 3D-Grafikbibliothek auf niedriger Ebene und Rendering-Framework
Fleißiger Engine ist eine leichte plattformübergreifende Grafik-API-Abstraktionsbibliothek und Rendering-Framework. Es ist so konzipiert, dass es Direct3D12, Vulkan, Metal und WebGPU voll ausnutzen und gleichzeitig ältere Plattformen über Direct3D11, OpenGL, OpenGles und WebGL unterstützt. Die fleißige Engine enthält eine gemeinsame Front-End-API und verwendet HLSL als universelle Schattierungssprache auf allen Plattformen und die Rendern von Rückenlendungen. Plattformspezifische Shader-Darstellungen (GLSL, MSL, DX-Bytecode oder Spirv) können mit entsprechenden Back-Ends verwendet werden. Die Engine soll als Grafik -Subsystem in einer Game Engine oder einer anderen 3D -Anwendung verwendet werden. Es ist unter Apache 2.0 -Lizenz verteilt und kann kostenlos verwendet werden.
| Plattform | D3D11 | D3D12 | OpenGL/Gles | Vulkan | Metall | Webgpu | Status erstellen |
|---|---|---|---|---|---|---|---|
 Fenster | ✔️ | ✔️ | ✔️ | ✔️ | - - | ✔️ 3 |  |
 Universelle Fenster | ✔️ | ✔️ | - - | - - | - - | - - | |
 Linux | - - | - - | ✔️ | ✔️ | - - | ✔️ 3 |  |
 Android | - - | - - | ✔️ | ✔️ | - - | - - |  |
 Macos | - - | - - | ✔️ | ✔️ 1 | ✔️ 2 | ✔️ 3 |  |
 iOS | - - | - - | ✔️ | ✔️ 1 | ✔️ 2 | - - | |
 tvos | - - | - - | - - | ✔️ 1 | ✔️ 2 | - - | |
 Emscripten | - - | - - | ✔️ | - - | - - | ✔️ |  |
1 Vulkan-API wird nicht nativ auf MacOS-, iOS- und TVOS-Plattformen unterstützt und erfordert eine Implementierung der Vulkan-Portabilität wie Moltenvk oder GFX-Portabilität.
2 Im Rahmen der kommerziellen Lizenz verfügbar - Bitte kontaktieren Sie uns für Einzelheiten.
3 erfordert eine native Implementierung von WebGPU, Dawn wird empfohlen.
#if defined(_WIN32) ... #elif defined(LINUX) ... #elif defined(ANDROID) ...#if defined(D3D11) ... #elif defined(D3D12) ... #elif defined(OPENGL) ...Minimum unterstützte API-Versionen auf niedriger Ebene:
Dies ist das Master -Repository, das vier Submodule enthält. Verwenden Sie den folgenden Befehl, um das Repository und alle Submodules zu erhalten:
git clone --recursive https://github.com/DiligentGraphics/DiligentEngine.git
Vergessen Sie bei der Aktualisierung des vorhandenen Repository nicht, alle Submodules zu aktualisieren:
git pull
git submodule update --recursive
Es ist auch eine gute Idee, CMAKE erneut auszuführen und Clean Rebuild durchzuführen, nachdem die neueste Version erstellt wurde.
Das Master -Repository enthält die folgenden Submodules:
Fleißiger Motor verwendet CMake als plattformübergreifendes Build-Tool. Um CMAKE zu verwenden, laden Sie die neueste Version (3.20 oder höher sind erforderlich) herunter. Eine andere Bauvoraussetzung ist der Python -Dolmetscher (3.0 oder höher ist erforderlich). Wenn Sie nach der Befolgung der folgenden Anweisungen Probleme mit Erstellung/Ausführen haben, sehen Sie sich die Fehlerbehebung an.
Voraussetzungen bauen:
Der .NET -Support erfordert .NET SDK 6.0 oder höher.
Verwenden Sie entweder CMake -GUI oder Befehlszeilen -Tool, um Build -Dateien zu generieren. Um beispielsweise Visual Studio 2022 64-Bit-Lösung und Projektdateien im Build/Win64 -Ordner zu generieren, navigieren Sie zum Root-Ordner der Engine und führen Sie den folgenden Befehl aus:
cmake -S . -B ./build/Win64 -G "Visual Studio 17 2022" -A x64
Sie können eine Win32 -Lösung erstellen, die mit dem folgenden Befehl Win8.1 SDK abzielt:
cmake -D CMAKE_SYSTEM_VERSION=8.1 -S . -B ./build/Win64_8.1 -G "Visual Studio 17 2022" -A x64
Wenn Sie Mingw verwenden, können Sie die Dateien mit dem folgenden Befehl erstellen (beachten Sie jedoch, dass die Funktionalität begrenzt ist und Mingw keine empfohlene Möglichkeit zum Erstellen der Engine ist):
cmake -S . -B ./build/MinGW -D CMAKE_BUILD_TYPE=Release -G "MinGW Makefiles"
Um Vulkan -Validierungsebenen zu aktivieren, müssen Sie den Vulkan SDK herunterladen und Umgebungsvariable VK_LAYER_PATH hinzufügen, der den Pfad zum Bin -Verzeichnis in der Installationsordner von Vulkansdk enthält.
Öffnen Sie die Datei DiligentEngine.sln in Build/Win64 -Ordner, wählen Sie die Konfiguration und erstellen Sie den Motor. Legen Sie das gewünschte Projekt als Startprojekt fest (standardmäßig wird der GLTF -Viewer ausgewählt) und führen Sie es aus.
Standardmäßig zeigen Beispiel- und Tutorial -Anwendungen das Dialogfeld "Rendering Backend Selection" angezeigt. Verwenden Sie die folgenden Befehlszeilenoptionen, um D3D11, D3D12, OpenGL oder Vulkan -Modus zu erzwingen: -Mode D3D11 , - -Mode D3D12 , -modus GL oder - -Mode VK . Wenn Sie eine Anwendung außerhalb der Visual Studio -Umgebung ausführen möchten, muss der Ordner der Anwendung als Arbeitsverzeichnis festgelegt werden. (Für Visual Studio wird dies automatisch durch CMAKE konfiguriert). Alternativ können Sie zum Build -Ziel- oder Installationsordner navigieren und die ausführbare Datei von dort aus ausführen.
Um Build -Dateien für die universelle Windows -Plattform zu generieren, müssen Sie die folgenden zwei CMake -Variablen definieren:
CMAKE_SYSTEM_NAME=WindowsStoreCMAKE_SYSTEM_VERSION=< Windows Version >Um beispielsweise Visual Studio 2022 64-Bit-Lösung und Projektdateien in Build/UWP64 -Ordner zu generieren, führen Sie den folgenden Befehl aus dem Root-Ordner der Engine aus:
cmake -D CMAKE_SYSTEM_NAME=WindowsStore -D CMAKE_SYSTEM_VERSION=10.0 -S . -B ./build/UWP64 -G "Visual Studio 17 2022" -A x64
Legen Sie das gewünschte Projekt als Startprojekt fest (standardmäßig wird der GLTF -Viewer ausgewählt) und führen Sie es aus.
Standardmäßig werden Anwendungen im D3D12 -Modus ausgeführt. Sie können D3D11 oder D3D12 unter Verwendung der folgenden Befehlszeilenoptionen auswählen: -Mode D3D11 , -Mode D3D12 .
Hinweis: Es ist möglich, Lösung zu generieren, die auf Windows 8.1 abzielt, indem CMake_System_Version = 8.1 CMAKE -Variable definiert wird. Es wird jedoch nicht erstellt, da es Visual Studio 2013 (V120) Toolset verwendet, das die richtige C ++ - 14 -Unterstützung fehlt.
Ihre Linux -Umgebung muss für die C ++ - Entwicklung eingerichtet werden. Wenn dies bereits der Fall ist, stellen Sie sicher, dass Ihre C ++ - Tools auf dem neuesten Stand sind, da die fleißige Motor moderne C ++ - Funktionen verwendet (Clang 10 oder höher wird empfohlen).
Möglicherweise müssen Sie die folgenden Pakete installieren:
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
Um Vulkan zu konfigurieren, müssen Sie auch:
Um Dateien für die Debug -Konfiguration zu generieren, führen Sie den folgenden CMAKE -Befehl aus dem Stammordner der Engine aus:
cmake -S . -B ./build -G "Unix Makefiles" -DCMAKE_BUILD_TYPE="Debug"
Führen Sie den folgenden Befehl aus, um den Motor zu bauen:
cmake --build ./build
Bei Ubuntu 23 und neuer kann es abstürzen, wenn Sie keine LibtInfo5 installiert haben, müssen Sie es hinzufügen.
Der Root -Ordner der Engine enthält Visual Studio -Code -Einstellungsdateien, die die IDE zum Erstellen der Engine konfigurieren. Sie können Anwendungen direkt aus der IDE ausführen. Um eine Anwendung aus der Befehlszeile auszuführen, muss der Ordner der App der App ein aktuelles Verzeichnis sein.
Bitte stellen Sie sicher, dass Ihre Maschine für Android -Entwicklung eingerichtet ist. Laden Sie Android Studio herunter, installieren und konfigurieren Sie NDK und CMAKE sowie andere erforderliche Tools. NDK R24 oder höher ist erforderlich. Wenn Sie CMAKE -Version nicht mit Android Studio verwenden, stellen Sie sicher, dass Ihre Build -Dateien ordnungsgemäß konfiguriert sind. Um zu überprüfen, ob Ihre Umgebung ordnungsgemäß eingerichtet ist, bauen Sie die Teekannen sowie Vulkan -Android -Tutorials auf.
Öffnen Sie Sorgentssamples/Android -Ordner mit Android Studio, um Tutorials und Proben auf Android zu erstellen und auszuführen.
Standardmäßig werden Anwendungen im Vulkan -Modus ausgeführt. Um sie im Vulkan-Modus auszuführen, fügen Sie die folgenden Startflags hinzu: --es mode gles (in Android Studio finden Sie in Run-> Konfigurationsmenü).
Voraussetzungen:
Führen Sie nach dem Klonen des Repo den folgenden Befehl aus dem Root -Ordner des Motors aus, um das Xcode -Projekt zu generieren:
cmake -S . -B ./build/MacOS -G "Xcode"
Das Projekt befindet sich im build/MacOS -Ordner.
Beachten Sie, dass Sie möglicherweise den folgenden Befehl ausführen müssen, wenn CMake den Compiler nicht findet:
sudo xcode-select --reset
Standardmäßig gibt es keine Vulkan -Implementierung auf macOS. DILIGENT Engine lädt Vulkan dynamisch und kann eine Implementierung der Vulkan-Portabilität wie Moltenvk oder GFX-Portabilität verwenden. Installieren Sie Vulkansdk und stellen Sie sicher, dass Ihr System wie hier beschrieben ordnungsgemäß konfiguriert ist. Insbesondere müssen Sie möglicherweise die folgenden Umgebungsvariablen definieren (vorausgesetzt, Vulkan SDK ist unter /Users/MyName/VulkanSDK/1.3.290.0 installiert und Sie möchten Moltenvk verwenden):
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
Beachten Sie, dass die in der Shell festgelegten Umgebungsvariablen nicht von den Anwendungen von LaunchPad oder anderen Desktop -GUI angezeigt werden. Um sicherzustellen, dass eine Anwendung Vulkan -Bibliotheken findet, muss sie aus der Befehlszeile gestartet werden. Aus dem gleichen Grund sollte die XCode -Projektdatei auch über den Befehl open aus der Shell geöffnet werden. Mit Xcode -Versionen 7 und später muss dieses Verhalten möglicherweise zunächst mit dem folgenden Befehl aktiviert werden:
defaults write com.apple.dt.Xcode UseSanitizedBuildSystemEnvironment -bool NO
Weitere Informationen finden Sie auf dieser Seite.
DYLD_LIBRARY_PATH UND LD_LIBRARY_PATH -Umgebungsvariablen werden auf MacOS ignoriert, es sei denn, der Schutz der Systemintegrität ist deaktiviert (was im Allgemeinen nicht empfohlen wird). Damit ausführbare Ausführungen die Vulkan -Bibliothek finden können, muss sie in RPATH sein. Wenn die Umgebungsvariable VULKAN_SDK festgelegt und auf den korrekten Standort festgelegt wird, konfiguriert die sorgfältige Engine den RPATH für alle Anwendungen automatisch.
Neueste getestete Vulkan SDK -Version: 1.3.290.0.
Voraussetzungen:
Führen Sie den Befehl unten aus dem Root -Ordner der Engine aus, um das für iOS -Build konfigurierte Xcode -Projekt zu generieren:
cmake -S . -B ./build/iOS -DCMAKE_SYSTEM_NAME=iOS -G "Xcode"Bei Bedarf können Sie iOS -Bereitstellungsziel (13.0 oder höher sind erforderlich) sowie andere Parameter angeben, z. B.:
cmake -S . -B ./build/iOS -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_DEPLOYMENT_TARGET=13.0 -G "Xcode"iphonesimulator -Systemwurzel. Sie können auch die Variable CMAKE_OSX_ARCHITECTURES verwenden, um die Zielarchitektur anzugeben, z. B.:
cmake -S . -B ./build/iOSSim -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphonesimulator -DCMAKE_OSX_ARCHITECTURES=arm64 -G "Xcode" Öffnen Sie die Xcode -Projektdatei im build/IOS -Ordner und erstellen Sie den Motor. Um die Anwendungen auf einem iOS -Gerät auszuführen, müssen Sie das geeignete Entwicklungsteam in den Projekteinstellungen festlegen.
Um Vulkan auf iOS zu aktivieren, laden Sie die Vulkansdk herunter und installieren Sie sie. Es gibt keinen Vulkan -Lader auf iOS, und sorgfältiger Motorverbindungen links direkt mit Moltenvk XCFramework (siehe Moltenvk Install -Handbuch), die Vulkan auf Metall implementiert. Um Vulkan in fleißiger Motor auf iOS zu aktivieren, geben Sie beispielsweise den Pfad zu Vulkan SDK an (unter der Annahme, dass Vulkan SDK unter /Users/MyName/VulkanSDK/1.3.290.0 installiert ist):
cmake -DCMAKE_SYSTEM_NAME=iOS -DVULKAN_SDK=/Users/MyName/VulkanSDK/1.3.290.0 -S . -B ./build/iOS -G "Xcode" Standardmäßig verbindet der Motor mit Moltenvk XCFramework in Vulkan SDK. Wenn dies nicht erwünscht ist oder eine Anwendung eine bestimmte Bibliothek verwenden möchte, kann sie über MOLTENVK_LIBRARY CMake -Variable den vollständigen Pfad zur Bibliothek bereitstellen.
Weitere Informationen zur MoltenVK -Installation und -verwendung finden Sie unter Moltenvk -Benutzerhandbuch.
Neueste getestete Vulkan SDK -Version: 1.3.290.0.
Voraussetzungen bauen:
Pfad und andere Umgebungsvariablen im aktuellen Terminal aktivieren
source ${PATH_TO_EMSDK} /emsdk/emsdk_env.sh${PATH_TO_EMSDK}/emsdk/emsdk_env.bat anstelle von source ${PATH_TO_EMSDK}/emsdk/emsdk_env.sh
Führen Sie zum Generieren von Projekten den folgenden CMAKE -Befehl aus dem Root -Ordner des Motors aus:
emcmake cmake -S . -B ./build/Emscripten -G "Ninja"Führen Sie den folgenden Befehl aus, um den Motor zu bauen:
cmake --build ./build/EmscriptenFühren Sie einen grundlegenden Webserver aus, um EMSCIPTEN -Anwendungen zu testen
cd ./build/Emscripten
python https_server.py Öffnen Sie einen Browser und navigieren Sie zu http://localhost
Zum Beispiel wird das Hello Triangle -Tutorial bei erhältlich sein
http://localhost/DiligentSamples/Tutorials/Tutorial01_HelloTriangle/Tutorial01_HelloTriangle.html
Verwenden Sie den HTTPS -Server, um auf den Server von einem anderen Computer auf dem lokalen Netzwerk zuzugreifen. Um dies zu aktivieren, installieren Sie zuerst das cryptography -Modul. Sie können dies tun, indem Sie den folgenden Befehl ausführen:
pip install cryptographyVerwenden Sie den folgenden Befehl, um den HTTPS -Server zu starten:
python https_server.py --mode=httpsVerwenden Sie das HTTPS -Protokoll, um die Seiten zu öffnen. Zum Beispiel:
https://localhost/DiligentSamples/Tutorials/Tutorial01_HelloTriangle/Tutorial01_HelloTriangle.html
Bei Verwendung des HTTPS -Servers können Sie im Rahmen des HTTP -Servers beim Laden der Seite auf den folgenden Fehler stoßen, wenn Sie die Seite geladen haben: net::ERR_CERT_AUTHORITY_INVALID .
Es gibt zwei Möglichkeiten, dieses Problem zu lösen:
Advanced und wählen Proceed to localhost (unsafe) .python https_server.py --mode=https --register Wir verwenden die Standardports für HTTP/HTTPS -Protokolle 80 bzw. 443 . Wenn Sie bereits über einen Server auf diesen Ports ausgeführt werden, können Sie eine andere Portnummer mit dem Argument --port angeben und die entsprechende Portnummer nach der IP -Adresse in die URL aufnehmen. Zum Beispiel:
http://localhost:${YOUR_PORT}/DiligentSamples/Tutorials/Tutorial01_HelloTriangle/Tutorial01_HelloTriangle.html
Fleißig verfügt über eine modulare Struktur. Für Ihr Projekt können Sie daher nur die Submodule verwenden, die die erforderliche Funktionalität implementieren. Das folgende Diagramm zeigt die Abhängigkeiten zwischen Modulen.
Core
|
+------>Tools----------.
| | |
| V |
+------->FX---------. |
| | |
| V V
'----------------->Samples
Vergessen Sie nicht, Submodule rekursiv zu initialisieren, wenn Sie Ihrem Projekt fleißige Repos als Submodul hinzufügen.
Wenn Ihr Projekt CMAKE verwendet, erfordert das Hinzufügen eines fleißigen Engine nur wenige Codezeilen. Nehmen wir an, dass die Verzeichnisstruktur so aussieht:
|
+-DiligentCore
+-HelloDiligent.cpp
Dann müssen die folgenden Schritte ausgeführt werden:
add_subdirectory(DiligentCore) aufUnten finden Sie ein Beispiel für eine CMake -Datei:
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() ist eine Komfortfunktion, die freigegebene Bibliotheken neben der ausführbaren Datei kopiert, damit das System sie finden und laden kann. Bitte werfen Sie auch einen Blick auf die Tutorials für Windows und Linux.
Auf den meisten Plattformen sind Kernbibliotheken sowohl in statischen als auch in dynamischen Versionen aufgebaut (z. B. Diligent-GraphicsEngineD3D12-static Diligent-GraphicsEngineD3D12-shared ). Sie können auswählen, mit welcher Version Sie den Zielnamen in target_link_libraries() cmake -Befehl ändern sollen. Bei der Verknüpfung mit dynamischen Bibliotheken wird das ENGINE_DLL -Makro definiert und die Bibliotheken müssen zur Laufzeit geladen werden. Zum Beispiel für Direct3D12 Backend:
# if ENGINE_DLL
// Load the dll and import GetEngineFactoryD3D12() function
auto GetEngineFactoryD3D12 = LoadGraphicsEngineD3D12();
# endif
auto * pFactoryD3D12 = GetEngineFactoryD3D12(); Bei Verwendung der statischen Verknüpfung wird das ENGINE_DLL -Makro nicht definiert, und die Funktion GetEngineFactoryD3D12 wird statisch mit der ausführbaren Datei verknüpft.
Die SampleApp.cpp -Datei bietet ein Beispiel für die Initialisierung der Engine auf verschiedenen Plattformen mithilfe einer statischen oder dynamischen Verknüpfung.
Sie können FetchContent verwenden, um fleißige Motormodule herunterzuladen. Die einzige Einschränkung ist, dass Sie das Quellverzeichnis für jedes Modul so angeben müssen, dass sie dem Modulnamen übereinstimmen, damit Header -Dateien gefunden werden können. Nachfolgend finden Sie ein Beispiel für eine CMake -Datei, in der FetchContent verwendet wird:
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)Wenn Ihr Projekt CMAKE nicht verwendet, wird empfohlen, Bibliotheken mit CMake zu erstellen und zu Ihrem Build -System hinzuzufügen. Sie können die neuesten Build -Artefakte von GitHub herunterladen.
Das globale CMake -Installationsverzeichnis wird von der Variablen cmake_intall_prefix gesteuert. Beachten Sie, dass es auf Unix und c:/Program Files/${PROJECT_NAME} unter Windows standardmäßig /usr/local ist, was möglicherweise nicht das ist, was Sie wollen. Verwenden Sie -D CMAKE_INSTALL_PREFIX=install , um stattdessen den lokalen install zu verwenden:
cmake -S . -B ./build/Win64 -D CMAKE_INSTALL_PREFIX=install -G "Visual Studio 17 2022" -A x64
Führen Sie den folgenden CMAKE -Befehl aus dem Build -Ordner aus, um Bibliotheken und Header -Dateien zu installieren:
cmake --build . --target installDas DiligentCore -Installationsverzeichnis enthält alles, was zur Integration des Motors erforderlich ist:
Ein einfacherer Weg ist die Verbindung mit dynamischen Bibliotheken. Wenn Sie statisch verlinken, müssen Sie DiligentCore sowie alle von der Motor verwendeten Bibliotheken von Drittanbietern auflisten. Außerdem müssen Sie plattformspezifische Systembibliotheken angeben. Zum Beispiel muss für Windows Platform die Liste der Bibliotheken, gegen die Ihr Projekt verlinken muss, wie folgt aussehen:
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
DILIGENT Engine Header erfordern, dass eines der folgenden Plattform -Makros als 1 : PLATFORM_WIN32 , PLATFORM_UNIVERSAL_WINDOWS , PLATFORM_ANDROID , PLATFORM_LINUX , PLATFORM_MACOS , PLATFORM_IOS definiert werden.
Sie können steuern, welche Komponenten des Motors Sie mit den folgenden CMAKE -Optionen installieren möchten: DILIGENT_INSTALL_CORE , DILIGENT_INSTALL_FX , DILIGENT_INSTALL_SAMPLES und DILIGENT_INSTALL_TOOLS .
Eine andere Möglichkeit, die Engine zu integrieren, besteht darin, Build -Dateien (z. B. Visual Studio -Projekte) zu generieren und in Ihr Build -System hinzuzufügen. Erstellen Sie die unten beschriebenen Anpassungen können dazu beitragen, die Einstellungen für Ihre spezifischen Anforderungen zu optimieren.
Die verfügbaren CMake -Optionen sind in der folgenden Tabelle zusammengefasst:
| Option | Standardwert | Beschreibung |
|---|---|---|
DILIGENT_NO_DIRECT3D11 | NEIN | Erstellen Sie nicht Direct3D11 -Backend |
DILIGENT_NO_DIRECT3D12 | NEIN | Bauen Sie Direct3D12 Backend nicht |
DILIGENT_NO_OPENGL | NEIN | Bauen Sie kein OpenGL -Backend auf |
DILIGENT_NO_VULKAN | NEIN | Bauen Sie kein Vulkan -Backend auf |
DILIGENT_NO_METAL | NEIN | Bauen Sie kein Metall -Backend auf |
DILIGENT_NO_WEBGPU | NEIN | Erstellen Sie kein WebGPU -Backend |
DILIGENT_NO_ARCHIVER | NEIN | Nicht Archiver bauen |
DILIGENT_NO_RENDER_STATE_PACKAGER | NEIN | Erstellen Sie das Render State Packager -Tool nicht |
DILIGENT_ENABLE_DRACO | NEIN | Aktivieren Sie die Draco -Kompressionsunterstützung im GLTF -Lader |
DILIGENT_USE_RAPIDJSON | NEIN | Verwenden Sie Rapidjson Parser im GLTF -Lader |
DILIGENT_BUILD_TOOLS | Ja | Werkzeugmodul erstellen |
DILIGENT_BUILD_FX | Ja | FX -Modul erstellen |
DILIGENT_BUILD_SAMPLES | Ja | Probenmodul erstellen |
DILIGENT_BUILD_SAMPLE_BASE_ONLY | NEIN | Erstellen Sie nur ein Beispielbasis -Projekt und keine anderen Proben/Tutorials |
DILIGENT_BUILD_TESTS | NEIN | Einheitstests bauen |
DILIGENT_NO_GLSLANG | NEIN | Bauen Sie keine GLSlang- und Spriv-Tools |
DILIGENT_NO_HLSL | NEIN | Deaktivieren Sie die HLSL-Unterstützung in nicht-direkten Backends |
DILIGENT_NO_FORMAT_VALIDATION | Ja | Deaktivieren Sie die Validierung des Quellcode -Formatierung |
DILIGENT_LOAD_PIX_EVENT_RUNTIME | NEIN | Aktivieren Sie die PIX -Event -Unterstützung |
DILIGENT_NVAPI_PATH | Weg zu NVAPI SDK | |
DILIGENT_INSTALL_CORE | Ja | Installieren Sie das Kernmodul |
DILIGENT_INSTALL_TOOLS | Ja | Installieren Sie das Tools -Modul |
DILIGENT_INSTALL_FX | Ja | Installieren Sie das FX -Modul |
DILIGENT_INSTALL_SAMPLES | Ja | Probenmodul installieren |
DILIGENT_INSTALL_PDB | NEIN | Installieren Sie die Debug -Datenbank für Programme |
DILIGENT_DEAR_IMGUI_PATH | Optionaler Weg zu einem von Benutzer bereitgestellten Dear IMGui-Projekt | |
DILIGENT_ARGS_DIR | Optionaler Pfad zu einem von Benutzer bereitgestellten Args-Projekt | |
DILIGENT_NUKLEAR_DIR | Optionaler Pfad zu einem von Benutzer bereitgestellten Nuklear-Projekt | |
DILIGENT_MSVC_COMPILE_OPTIONS | Zusätzliche MSVC -Kompilieroptionen für alle Konfigurationen | |
DILIGENT_MSVC_DEBUG_COMPILE_OPTIONS | Zusätzliche MSVC -Kompilierungsoptionen für die Debug -Konfiguration | |
DILIGENT_MSVC_RELEASE_COMPILE_OPTIONS | /GL /Arch: AVX2 | Zusätzliche MSVC -Kompilieroptionen für Release -Konfigurationen |
DILIGENT_CLANG_COMPILE_OPTIONS | Zusätzliche Clang -Kompilieroptionen für alle Konfigurationen | |
DILIGENT_CLANG_DEBUG_COMPILE_OPTIONS | Zusätzliche Clang -Kompilieroptionen für die Debug -Konfiguration | |
DILIGENT_CLANG_RELEASE_COMPILE_OPTIONS | -Mavx2 | Zusätzliche Clang -Kompilieroptionen für Release -Konfigurationen |
DILIGENT_USD_PATH | Pfad zum USD -Installationsordner |
Standardmäßig werden alle auf der aktuellen Plattform verfügbaren Backends erstellt. Verwenden Sie die folgenden Optionen, um spezifische Back-Ends zu deaktivieren: DILIGENT_NO_DIRECT3D11 , DILIGENT_NO_DIRECT3D12 , DILIGENT_NO_OPENGL , DILIGENT_NO_VULKAN , DILIGENT_NO_METAL , DILIGENT_NO_WEBGPU . Das WebGPU -Backend ist standardmäßig beim Erstellen für das Web aktiviert. Um es auf anderen Plattformen zu aktivieren, verwenden Sie DILIGENT_NO_WEBGPU=OFF . Die Optionen können über die CMAKE -UI oder aus der Befehlszeile wie im folgenden Beispiel eingestellt werden:
cmake -D DILIGENT_NO_DIRECT3D11=TRUE -S . -B ./build/Win64 -G "Visual Studio 17 2022" -A x64
Zusätzlich können einzelne Motorkomponenten mit den folgenden Optionen aktiviert oder deaktiviert werden: DILIGENT_BUILD_TOOLS , DILIGENT_BUILD_FX , DILIGENT_BUILD_SAMPLES . Wenn Sie nur SampleBase -Projekt erstellen möchten, können Sie die Option DILIGENT_BUILD_SAMPLE_BASE_ONLY verwenden.
Standardmäßig ist das Back-End von Vulkan mit GLSlang verknüpft, mit dem HLSL- und GLSL-Shader zur Laufzeit zum Spirv zum Spirepilieren ermöglicht werden können. Wenn keine Laufzeitkompilierung erforderlich ist, kann GLSlang mit der Option DILIGENT_NO_GLSLANG CMAKE deaktiviert werden. Zusätzlich kann die HLSL-Unterstützung in nicht-direkten Backends mit der Option DILIGENT_NO_HLSL deaktiviert werden. Das Ermöglichen der Optionen reduziert die Größe von Vulkan- und OpenGL-Back-End-Binärdateien erheblich, was für mobile Anwendungen besonders wichtig sein kann.
Die sorgfältige Engine verwendet Clang-Format, um eine konsistente Formatierung in der gesamten Codebasis zu gewährleisten. Die Validierung kann mit der CMAKE -Option DILIGENT_NO_FORMAT_VALIDATION deaktiviert werden. Beachten Sie, dass eine Pull -Anfrage fehlschlägt, wenn Probleme mit der Formatierung gefunden werden.
Fleißiger Motor verwendet eine umfangreiche Validierung, die im Debug -Build immer aktiviert ist. Einige der Überprüfungen können in Release -Konfigurationen aktiviert werden, indem die CMAKE -Option DILIGENT_DEVELOPMENT festgelegt wird.
Um die Unterstützung von PIX -Ereignissen zu aktivieren, setzen Sie DILIGENT_LOAD_PIX_EVENT_RUNTIME CMAKE -Flag.
So laden Sie die NVAPI herunter und setzen Sie die Variable DILIGENT_NVAPI_PATH , um einige erweiterte Funktionen für NVIDIA -GPUs (z. B. indirekte Unterstützung in Direct3D11) zu aktivieren (z.
DILIGENT Engine verwendet mehrere Bibliotheken von Drittanbietern. Wenn die CMAKE -Datei einer Anwendung eine dieser Bibliotheken definiert, verwendet sorgfältig vorhandene Ziele. Die Anwendung muss sicherstellen, dass die Build -Einstellungen mit fleißig kompatibel sind.
Mit sorgfältiger Engine können Clients Build -Einstellungen durch Bereitstellung von Konfigurationsskriptdateien anpassen, die die folgenden optionalen CMAKE -Funktionen definieren:
custom_configure_build() - Definiert globale Build -Eigenschaften wie Build -Konfigurationen, C/C ++ -Kompile -Flags, Link -Flags usw.custom_pre_configure_target() - definiert benutzerdefinierte Einstellungen für jedes Ziel im Build und wird aufgerufen, bevor das Build -System der Engine mit der Konfiguration des Ziels beginnt.custom_post_configure_target() - Aufgerufen nach dem Build -System der Engine hat das Ziel so konfiguriert, dass die Client -Überschreibungseigenschaften vom Engine festgelegt werden können. Der Pfad zum Konfigurationsskript sollte bei der Ausführung von CMake BUILD_CONFIGURATION_FILE bereitgestellt werden und muss relativ zum CMake -Root -Ordner sein, zum Beispiel:
cmake -D BUILD_CONFIGURATION_FILE=BuildConfig.cmake -S . -B ./build/Win64 -G "Visual Studio 17 2022" -A x64
Wenn definiert, wird die Funktion custom_configure_build() aufgerufen, bevor ein Build -Ziel hinzugefügt wird. Standardmäßig definiert CMake die folgenden vier Konfigurationen: Debug, Release, relwithdebinfo, MinSizerel. Wenn Sie möchten, können Sie Ihre eigenen Build -Konfigurationen definieren, indem Sie die Variable CMAKE_CONFIGURATION_TYPES einstellen. Wenn Sie beispielsweise nur zwei Konfiguration haben möchten: Debuggen und Releasemt, fügen Sie die folgende Zeile zur Funktion custom_configure_build() hinzu:
set (CMAKE_CONFIGURATION_TYPES Debug ReleaseMT CACHE STRING "Configuration types: Debug, ReleaseMT" FORCE ) Das Build -System muss die Liste der Debug- und Release -Konfigurationen (optimiert) kennen. Daher müssen auch die folgenden zwei Variablen festgelegt werden, wenn die Variable CMAKE_CONFIGURATION_TYPES definiert ist:
set (DEBUG_CONFIGURATIONS DEBUG CACHE INTERNAL "" FORCE )
set (RELEASE_CONFIGURATIONS RELEASEMT CACHE INTERNAL "" FORCE ) Beachten Sie, dass aufgrund von CMAKE -Einzelheiten Konfigurationsnamen, die in DEBUG_CONFIGURATIONS und RELEASE_CONFIGURATIONS aufgeführt sind, aktiviert werden müssen .
Wenn Sie eine andere Konfiguration als vier Standard -CMAKE -CMAKE definieren, müssen Sie auch die folgenden Variablen für jede neue Konfiguration festlegen:
CMAKE_C_FLAGS_<Config> - c Kompilierflags kompilierenCMAKE_CXX_FLAGS_<Config> - c ++ kompile FlagsCMAKE_EXE_LINKER_FLAGS_<Config> - Ausführbare Link -FlagsCMAKE_SHARED_LINKER_FLAGS_<Config> - Shared Library Link FlagsZum Beispiel:
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 )Unten finden Sie ein Beispiel für die Funktion 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 () Wenn Sie definiert sind, ist custom_pre_configure_target() für jedes vom Build-System erstellte Ziel aufgerufen und ermöglicht das Konfigurieren von zielspezifischen Eigenschaften.
Standardmäßig legt das Build -System einige Zieleigenschaften fest. Wenn custom_pre_configure_target() alle erforderlichen Eigenschaften festlegt, kann das Build -System angegeben, dass keine weitere Verarbeitung erforderlich ist, indem die TRUE Variable TARGET_CONFIGURATION_COMPLETE über die übergeordnete Umfangsvariable eingestellt ist:
set (TARGET_CONFIGURATION_COMPLETE TRUE PARENT_SCOPE ) Das Folgende ist ein Beispiel für die Funktion 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 () Wenn der Client nur einige Einstellungen überschreiben muss, kann er die Funktion custom_post_configure_target() definieren, die aufgerufen wird, nachdem die Engine das Konfigurieren des Ziels abgeschlossen hat, z. B.:
function (custom_post_configure_target TARGET )
set_target_properties ( ${TARGET} PROPERTIES
CXX_STANDARD 17
)
endfunction ()Bitte beachten Sie diese Seite. Außerdem sind Tutorials und Muster, die unten aufgeführt sind, ein guter Ausgangspunkt.
Fleißige Render-Status-Notation ist eine JSON-basierte Sprache, die Shader, Pipeline-Zustände, Ressourcensignaturen und andere Objekte in bequemer Form beschreibt, z. B.:
{
"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 "
}
]
}JSON -Dateien können zur Laufzeit dynamisch analysiert werden. Alternativ kann eine Anwendung das Packager-Tool verwenden, um Pipeline-Beschreibungen (Shader für Zielplattformen kompilieren, interne Ressourcenlayouts usw. zu definieren) in ein für die Ladeleistung der Laufzeit optimiertes binäres Archiv vorzubereiten.
| Tutorial | Screenshot | Beschreibung |
|---|---|---|
| 01 - Hallo Dreieck |  | Dieses Tutorial zeigt, wie ein einfaches Dreieck mit fleißiger Motor -API rendert. |
| 02 - Würfel |  | Dieses Tutorial zeigt, wie ein tatsächliches 3D -Objekt, einen Würfel, rendert. Es zeigt, wie Shader aus Dateien geladen, Scheitelpunkte, Index- und Uniformpuffer erstellt und verwendet werden. |
| 03 - Texturierung |  | Dieses Tutorial zeigt, wie eine Textur auf ein 3D -Objekt angewendet wird. Es zeigt, wie eine Textur aus der Datei geladen wird, Shader Resource -Bindungsobjekt erstellt und wie eine Textur im Shader probiert wird. |
| 03 - Texturing -C | | Dieses Tutorial ist identisch mit Tutorial03, wird jedoch mit C API implementiert. |
| 03 - Texturing -Dotnet | | Dieses Tutorial zeigt, wie die fleißige Engine -API in .NET -Anwendungen verwendet wird. |
| 04 - Instanz |  | In diesem Tutorial wird gezeigt, wie Sie Instancieren verwenden, um mehrere Kopien eines Objekts mit einer eindeutigen Transformationsmatrix für jede Kopie zu rendern. |
| 05 - Texturarray |  | In diesem Tutorial wird gezeigt, wie Sie Instanze mit Textur -Arrays kombinieren, um für jede Instanz eindeutige Textur zu verwenden. |
| 06 - Multithreading |  | Dieses Tutorial zeigt, wie Sie Befehlslisten parallel von mehreren Threads generieren. |
| 07 - Geometrie -Shader |  | In diesem Tutorial wird angezeigt, wie Sie Geometrie -Shader verwenden, um glattes Wireframe zu rendern. |
| 08 - Tessellation |  | Dieses Tutorial zeigt, wie Sie Hardware -Tessellation verwenden, um einen einfachen adaptiven Gelände -Rendering -Algorithmus zu implementieren. |
| 09 - Quads |  | In diesem Tutorial wird angezeigt, wie mehrere 2D -Quads rendern und die Texturen häufig wechseln und Modi mischen. |
| 10 - Datenstreaming |  | Dieses Tutorial zeigt eine dynamische Buffer -Mapping -Strategie mit MAP_FLAG_DISCARD und MAP_FLAG_DO_NOT_SYNCHRONIZE -Flags, um variierende Datenmengen an GPU effizient zu streamen. |
| 11 - Ressourcenaktualisierungen |  | Dieses Tutorial zeigt verschiedene Möglichkeiten, Puffer und Texturen in fleißiger Engine zu aktualisieren, und erläutert wichtige interne Details und Leistungsimplikationen für jede Methode. |
| 12 - Ziel rendern |  | In diesem Tutorial wird gezeigt, wie ein 3D-Würfel in ein Off-Screen-Rendernziel gerendert und einen einfachen Nachbearbeitungseffekt durchführt. |
| 13 - Schattenkarte |  | Dieses Tutorial zeigt, wie man grundlegende Schatten mithilfe einer Schattenkarte rendert. |
| 14 - Shader berechnen |  | In diesem Tutorial wird angezeigt, wie ein einfaches Partikelsimulationssystem mit Compute Shaders implementiert wird. |
| 15 - Mehrere Fenster |  | In diesem Tutorial wird gezeigt, wie man mit sorgfältigem Engine zu mehreren Fenstern verwendet wird. |
| 16 - bindlose Ressourcen |  | Dieses Tutorial zeigt, wie Bindless-Ressourcen implementiert werden, eine Technik, die die Dynamic Shader-Ressourcenindexierungsfunktion nutzt, die von den APIs der nächsten Generation aktiviert ist, um die Renderung der Renderung erheblich zu verbessern. |
| 17 - MSAA |  | Dieses Tutorial zeigt, wie man Multisample Anti-Aliasing (MSAA) verwendet, damit geometrische Kanten glatter und vorübergehend stabiler aussehen. |
| 18 - Abfragen |  | In diesem Tutorial wird gezeigt, wie Sie Abfragen verwenden, um verschiedene Informationen über den GPU -Vorgang abzurufen, z. |
| 19 - Renderpässe |  | In diesem Tutorial wird gezeigt, wie die API -Render -Pässe verwendet wird, um eine einfache aufgeschobene Schattierung zu implementieren. |
| 20 - Mesh Shader |  | In diesem Tutorial wird gezeigt, wie Sie Verstärker- und Maschen -Shader, die neuen programmierbaren Phasen, verwenden, um die Ansicht frustum -Culling und Objekt -LOD -Berechnung der GPU zu implementieren. |
| 21 - Strahlenverfolgung |  | Dieses Tutorial zeigt die Grundlagen für die Verwendung von API -Verfolgung von Strahlen in fleißiger Motor. |
| 22 - Hybridwiedergabe |  | Dieses Tutorial zeigt, wie ein einfacher Hybrid -Renderer implementiert wird, der die Rasterisierung mit Strahlenverfolgung kombiniert. |
| 23 - Befehlswarteschlangen |  | Dieses Tutorial zeigt, wie mehrere Befehlswarteschlangen verwendet werden, um das Rendering parallel zu Kopier- und Berechnung von Vorgängen durchzuführen. |
| 24 - Variable Rate Shading |  | In diesem Tutorial wird gezeigt, wie die Schattierung variabler Rate verwendet wird, um die Pixelschattierungslast zu reduzieren. |
| 25 - State Packager rendern |  | Dieses Tutorial zeigt, wie Pipeline-Zustände mit dem Off-Line-Tool von Render State Packager auf dem Beispiel eines einfachen Pfad-Tracers erstellt und archiviert werden. |
| 26 - State Cache rendern |  | Dieses Tutorial erweitert die im vorherige Tutorial implementierte Pfadverfolgungstechnik und zeigt, wie der Render -Status -Cache verwendet wird, um Pipeline -Zustände zu speichern, die zum Laufzeit erstellt wurden, und sie zu laden, wenn die Anwendung startet. |
| 27 - Nachbearbeitung |  | Dieses Tutorial zeigt, wie die Nachbearbeitungseffekte aus dem Modul Diligentfx verwendet werden. |
| Probe | Screenshot | Beschreibung |
|---|---|---|
| Atmosphäre Probe |  | Diese Probe zeigt, wie die Nachbearbeitungseffekte der epipolaren Lichtstreuung in eine Anwendung zur physikalisch basierten Atmosphäre integriert werden kann. |
| GLFW -Demo |  | Dieses Maze-Mini-Spiel zeigt, wie GLFW verwendet wird, um Fenster zu erstellen und Tastatur- und Mauseingaben zu behandeln. |
| GLTF -Betrachter |  | Diese Probe zeigt, wie Sie den Asset Loader und PBR Renderer zum Laden und Rendern von Gltf -Modellen verwenden. |
| USD Zuschauer |  | Diese Probe zeigt, wie USD -Dateien mithyrogent, eine Implementierung der Hydra -Rendering -API in fleißiger Engine, rendern. |
| Schatten |  | Diese Probe zeigt, wie die Schattenkomponente verwendet wird, um qualitativ hochwertige Schatten zu rendern. |
| Liebe Imgui Demo |  | Diese Stichprobe zeigt die Integration des Motors in die Dear IMGui UI -Bibliothek. |
| Nuklear -Demo |  | Diese Probe zeigt die Integration des Motors in die Nuklear -UI -Bibliothek. |
| Hallo ar |  | Diese Probe zeigt, wie man fleißige Motor in einer grundlegenden Android -AR -Anwendung verwendet. |
| Asteroiden |  | Dieser Sampple ist ein Leistungsbenchmark, der 50.000 einzigartige texturierte Asteroiden macht und die Leistung verschiedener Rendering -Modi vergleichen kann. |
| Einheitsintegration Demo |  | Dieses Projekt zeigt die Integration von fleißiger Motor mit Einheit. |
Die Rendering-Funktionalität auf hoher Ebene wird vom Diligentfx-Modul implementiert. Die folgenden Komponenten sind jetzt verfügbar:
 | |
 |  |
Temporale Anti-Aliasing
Tone Mapping Shader Utilities
Wir würden uns freuen, wenn Sie uns einen Link senden könnten, falls Ihr Produkt fleißige Motor verwendet.
Großes Terrain-Visualisierungssystem für Pilottrainingsimulatoren durch Elbit Systems
Lumenrt: Eine Software zur Visualisierungs- und Reality -Modellierung von Bentley Systems
Godus: Ein preisgekröntes Sandbox-Spiel von 22Cans
VRMAC-Grafik: Eine plattformübergreifende Grafikbibliothek für .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
