DiligentEngine
v2.5.6
Perpustakaan grafis 3D tingkat rendah lintas platform modern dan kerangka kerja rendering
Engine yang rajin adalah perpustakaan abstraksi grafis lintas-platform yang ringan dan kerangka kerja rendering. Ini dirancang untuk memanfaatkan sepenuhnya Direct3D12, Vulkan, Metal dan WebGPU, sambil mendukung platform yang lebih lama melalui Direct3D11, OpenGL, Opengles dan WebGL. Mesin yang rajin memaparkan API front-end umum dan menggunakan HLSL sebagai bahasa naungan universal di semua platform dan rendering belakang. Representasi shader spesifik platform (GLSL, MSL, DX Bytecode atau Spirv) dapat digunakan dengan back-end yang sesuai. Mesin ini dimaksudkan untuk digunakan sebagai subsistem grafis di mesin game atau aplikasi 3D lainnya. Ini didistribusikan di bawah lisensi Apache 2.0 dan bebas digunakan.
| Platform | D3D11 | D3D12 | OpenGL/GLES | Vulkan | Logam | Webgpu | Bangun status |
|---|---|---|---|---|---|---|---|
 Windows | ✔️ | ✔️ | ✔️ | ✔️ | - | ✔️ 3 |  |
 Windows universal | ✔️ | ✔️ | - | - | - | - | |
 Linux | - | - | ✔️ | ✔️ | - | ✔️ 3 |  |
 Android | - | - | ✔️ | ✔️ | - | - |  |
 MacOS | - | - | ✔️ | ✔️ 1 | ✔️ 2 | ✔️ 3 |  |
 iOS | - | - | ✔️ | ✔️ 1 | ✔️ 2 | - | |
 TVOS | - | - | - | ✔️ 1 | ✔️ 2 | - | |
 Emscripten | - | - | ✔️ | - | - | ✔️ |  |
1 Vulkan API tidak didukung secara alami pada platform MacOS, iOS dan TVOS dan membutuhkan implementasi portabilitas vulkan seperti moltenvk atau portabilitas GFX.
2 tersedia di bawah lisensi komersial - silakan hubungi kami untuk detailnya.
3 membutuhkan implementasi asli WebGPU, Dawn direkomendasikan.
#if defined(_WIN32) ... #elif defined(LINUX) ... #elif defined(ANDROID) ...#if defined(D3D11) ... #elif defined(D3D12) ... #elif defined(OPENGL) ...Versi API tingkat rendah yang didukung minimum:
Ini adalah repositori master yang berisi empat submodul. Untuk mendapatkan repositori dan semua submodul, gunakan perintah berikut:
git clone --recursive https://github.com/DiligentGraphics/DiligentEngine.git
Saat memperbarui repositori yang ada, jangan lupa untuk memperbarui semua submodul:
git pull
git submodule update --recursive
Ini juga merupakan ide yang baik untuk menjalankan kembali CMAKE dan melakukan pembangunan kembali yang bersih setelah mendapatkan versi terbaru.
Repositori Master termasuk submodul berikut:
Mesin yang rajin menggunakan cmake sebagai alat pembuatan lintas platform. Untuk mulai menggunakan CMake, unduh rilis terbaru (3,20 atau lebih baru diperlukan). Prasyarat build lainnya adalah interpreter Python (3,0 atau lebih baru diperlukan). Jika setelah mengikuti instruksi di bawah ini Anda memiliki masalah build/run, silakan lihat pemecahan masalah.
Bangun Prasyarat:
Dukungan .NET membutuhkan .NET SDK 6.0 atau lebih baru.
Gunakan CMake GUI atau alat baris perintah untuk menghasilkan file build. Misalnya, untuk menghasilkan solusi Visual Studio 2022 64-bit dan file proyek di folder build/win64 , navigasikan ke folder root mesin dan jalankan perintah berikut:
cmake -S . -B ./build/Win64 -G "Visual Studio 17 2022" -A x64
Anda dapat menghasilkan solusi Win32 yang menargetkan Win8.1 SDK menggunakan perintah berikut:
cmake -D CMAKE_SYSTEM_VERSION=8.1 -S . -B ./build/Win64_8.1 -G "Visual Studio 17 2022" -A x64
Jika Anda menggunakan MINGW, Anda dapat menghasilkan file Make menggunakan perintah di bawah ini (perhatikan bahwa fungsionalitasnya akan terbatas dan bahwa MINGW bukan cara yang disarankan untuk membangun mesin):
cmake -S . -B ./build/MinGW -D CMAKE_BUILD_TYPE=Release -G "MinGW Makefiles"
Untuk mengaktifkan lapisan validasi Vulkan, Anda perlu mengunduh Vulkan SDK dan menambahkan variabel lingkungan VK_LAYER_PATH yang berisi jalur ke direktori bin di folder instalasi VulkansDK.
Buka file diligentEngine.sln di folder build/win64 , pilih konfigurasi dan bangun mesin. Atur proyek yang diinginkan sebagai proyek startup (secara default, GLTF Viewer akan dipilih) dan menjalankannya.
Secara default, aplikasi sampel dan tutorial akan menampilkan kotak dialog pemilihan backend rendering. Gunakan opsi baris perintah berikut untuk memaksa D3D11, D3D12, OpenGL, atau Mode Vulkan: --mode D3D11 , -Mode D3D12 , - -Mode GL , atau - -Mode VK . Jika Anda ingin menjalankan aplikasi di luar lingkungan Visual Studio, folder aset aplikasi harus ditetapkan sebagai direktori kerja. (Untuk Visual Studio, ini secara otomatis dikonfigurasi oleh CMake). Atau, Anda dapat menavigasi ke folder Build Target atau menginstal dan menjalankan yang dapat dieksekusi dari sana.
Untuk menghasilkan file build untuk platform universal windows, Anda perlu menentukan dua variabel cmake berikut:
CMAKE_SYSTEM_NAME=WindowsStoreCMAKE_SYSTEM_VERSION=< Windows Version >Misalnya, untuk menghasilkan solusi Visual Studio 2022 64-bit dan file proyek di folder build/uwp64 , jalankan perintah berikut dari folder root mesin:
cmake -D CMAKE_SYSTEM_NAME=WindowsStore -D CMAKE_SYSTEM_VERSION=10.0 -S . -B ./build/UWP64 -G "Visual Studio 17 2022" -A x64
Atur proyek yang diinginkan sebagai proyek startup (secara default, GLTF Viewer akan dipilih) dan menjalankannya.
Secara default, aplikasi akan berjalan dalam mode D3D12. Anda dapat memilih D3D11 atau D3D12 menggunakan Opsi Baris Perintah berikut: - -Mode D3D11 , - -Mode D3D12 .
Catatan: Dimungkinkan untuk menghasilkan solusi yang menargetkan Windows 8.1 dengan mendefinisikan cmake_system_version = 8.1 variabel CMAKE, tetapi akan gagal membangun karena akan menggunakan alat Visual Studio 2013 (v120) yang tidak memiliki dukungan C ++ 14 yang tepat.
Lingkungan Linux Anda perlu diatur untuk pengembangan C ++. Jika sudah ada, pastikan alat C ++ Anda mutakhir karena mesin yang rajin menggunakan fitur C ++ modern (dentang 10 atau lebih baru direkomendasikan).
Anda mungkin perlu menginstal paket berikut:
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
Untuk mengonfigurasi vulkan, Anda juga perlu:
Untuk menghasilkan file membuat untuk konfigurasi debug, jalankan perintah cmake berikut dari folder root engine:
cmake -S . -B ./build -G "Unix Makefiles" -DCMAKE_BUILD_TYPE="Debug"
Untuk membangun mesin, jalankan perintah berikut:
cmake --build ./build
Pada Ubuntu 23 dan yang lebih baru, mungkin macet jika Anda tidak menginstal LIBTINFO5, Anda harus menambahkannya.
Folder root mesin berisi file pengaturan kode studio visual yang mengkonfigurasi IDE untuk membangun mesin. Anda dapat menjalankan aplikasi langsung dari IDE. Untuk menjalankan aplikasi dari baris perintah, folder aset aplikasi harus direktori saat ini.
Pastikan mesin Anda diatur untuk pengembangan Android. Unduh Android Studio, instal dan konfigurasikan NDK dan CMake dan alat yang diperlukan lainnya. NDK R24 atau lebih baru diperlukan. Jika Anda tidak menggunakan versi CMake yang dibundel dengan Android Studio, pastikan file build Anda dikonfigurasi dengan benar. Untuk memverifikasi bahwa lingkungan Anda sudah diatur dengan benar, cobalah membangun sampel teko serta tutorial Vulkan Android.
Buka folder DiligentSamples/Android dengan Android Studio untuk membangun dan menjalankan tutorial dan sampel di Android.
Secara default, aplikasi akan berjalan dalam mode Vulkan. Untuk menjalankannya dalam mode Vulkan, tambahkan flag peluncuran berikut: --es mode gles (di Android Studio, buka Run-> Edit Configurations Menu)
Prasyarat:
Setelah Anda mengkloning repo, jalankan perintah berikut dari folder root mesin untuk menghasilkan proyek XCODE:
cmake -S . -B ./build/MacOS -G "Xcode"
Proyek ini akan berlokasi di folder build/MacOS .
Perhatikan bahwa jika CMake gagal menemukan kompiler, Anda mungkin perlu menjalankan perintah berikut:
sudo xcode-select --reset
Secara default tidak ada implementasi Vulkan di macOS. Mesin yang rajin memuat vulkan secara dinamis dan dapat menggunakan implementasi portabilitas vulkan seperti moltenvk atau portabilitas GFX. Instal VulkansDK dan pastikan bahwa sistem Anda dikonfigurasi dengan benar seperti yang dijelaskan di sini. Secara khusus, Anda mungkin perlu mendefinisikan variabel lingkungan berikut (dengan asumsi bahwa Vulkan SDK dipasang di /Users/MyName/VulkanSDK/1.3.290.0 dan Anda ingin menggunakan 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
Perhatikan bahwa variabel lingkungan yang ditetapkan dalam shell tidak terlihat oleh aplikasi yang diluncurkan dari LaunchPad atau desktop GUI lainnya. Dengan demikian untuk memastikan bahwa aplikasi menemukan perpustakaan Vulkan, itu perlu dimulai dari baris perintah. Karena alasan yang sama, file proyek XCODE juga harus dibuka dari shell menggunakan perintah open . Dengan versi Xcode 7 dan yang lebih baru, perilaku ini mungkin perlu diaktifkan terlebih dahulu menggunakan perintah berikut:
defaults write com.apple.dt.Xcode UseSanitizedBuildSystemEnvironment -bool NO
Silakan merujuk ke halaman ini untuk detail lebih lanjut.
DYLD_LIBRARY_PATH dan LD_LIBRARY_PATH Variabel lingkungan diabaikan pada macOS kecuali jika perlindungan integritas sistem dinonaktifkan (yang umumnya tidak disarankan). Agar dapat dieksekusi untuk menemukan Perpustakaan Vulkan, itu harus di RPATH. Jika variabel lingkungan VULKAN_SDK diatur dan poin ke lokasi yang benar, mesin yang rajin akan mengonfigurasi RPATH untuk semua aplikasi secara otomatis.
Versi SDK Vulkan Teruji Terbaru: 1.3.290.0.
Prasyarat:
Jalankan perintah di bawah ini dari folder root engine untuk menghasilkan proyek XCODE yang dikonfigurasi untuk IOS Build:
cmake -S . -B ./build/iOS -DCMAKE_SYSTEM_NAME=iOS -G "Xcode"Jika diperlukan, Anda dapat memberikan target penyebaran iOS (13.0 atau yang lebih baru diperlukan) serta parameter lainnya, misalnya:
cmake -S . -B ./build/iOS -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_DEPLOYMENT_TARGET=13.0 -G "Xcode"iphonesimulator . Anda juga dapat menggunakan variabel CMAKE_OSX_ARCHITECTURES untuk menentukan arsitektur target, misalnya:
cmake -S . -B ./build/iOSSim -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphonesimulator -DCMAKE_OSX_ARCHITECTURES=arm64 -G "Xcode" Buka file proyek XCODE di folder build/IOS dan bangun mesin. Untuk menjalankan aplikasi pada perangkat iOS, Anda harus menetapkan tim pengembangan yang sesuai dalam pengaturan proyek.
Untuk mengaktifkan Vulkan di iOS, unduh dan instal vulkansdk. Tidak ada loader Vulkan di iOS, dan tautan mesin yang rajin secara langsung dengan moltenvk xcframework (lihat Panduan Instalasi Moltenvk) yang mengimplementasikan vulkan pada logam. Untuk mengaktifkan Vulkan dalam mesin yang rajin di iOS, tentukan jalur ke vulkan SDK saat menjalankan CMake, misalnya (dengan asumsi bahwa vulkan SDK dipasang di /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" Secara default, mesin terhubung dengan moltenvk xcframework yang terletak di Vulkan SDK. Jika ini tidak diinginkan atau aplikasi ingin menggunakan pustaka tertentu, itu dapat memberikan jalur lengkap ke perpustakaan melalui variabel CMAKE MOLTENVK_LIBRARY .
Lihat Panduan Pengguna MoltenVK untuk informasi lebih lanjut tentang pemasangan dan penggunaan MoltenVK.
Versi SDK Vulkan Teruji Terbaru: 1.3.290.0.
Bangun Prasyarat:
Untuk mengaktifkan jalur dan variabel lingkungan lainnya di terminal saat ini
source ${PATH_TO_EMSDK} /emsdk/emsdk_env.sh${PATH_TO_EMSDK}/emsdk/emsdk_env.bat bukan source ${PATH_TO_EMSDK}/emsdk/emsdk_env.sh
Untuk menghasilkan proyek, jalankan perintah cmake berikut dari folder root mesin:
emcmake cmake -S . -B ./build/Emscripten -G "Ninja"Untuk membangun mesin, jalankan perintah berikut:
cmake --build ./build/EmscriptenUntuk menguji aplikasi Emscripten, jalankan server web dasar
cd ./build/Emscripten
python https_server.py Buka browser dan navigasikan ke http://localhost
Misalnya, tutorial Hello Triangle akan tersedia di
http://localhost/DiligentSamples/Tutorials/Tutorial01_HelloTriangle/Tutorial01_HelloTriangle.html
Untuk mengakses server dari komputer lain di jaringan lokal, gunakan server HTTPS. Untuk mengaktifkan ini, pertama instal modul cryptography . Anda dapat melakukannya dengan menjalankan perintah berikut:
pip install cryptographyUntuk memulai server HTTPS, gunakan perintah berikut:
python https_server.py --mode=httpsGunakan protokol HTTPS untuk membuka halaman. Misalnya:
https://localhost/DiligentSamples/Tutorials/Tutorial01_HelloTriangle/Tutorial01_HelloTriangle.html
Saat menggunakan server HTTPS, tidak seperti dengan server HTTP, Anda dapat menemukan kesalahan berikut saat memuat halaman: net::ERR_CERT_AUTHORITY_INVALID .
Ada dua cara untuk menyelesaikan masalah ini:
Advanced dan kemudian pilih Proceed to localhost (unsafe) .python https_server.py --mode=https --register Kami menggunakan port default untuk protokol HTTP/HTTPS, masing -masing 80 dan 443 . Jika Anda sudah memiliki server yang berjalan di port tersebut, Anda dapat menentukan nomor port yang berbeda menggunakan argumen --port dan menyertakan nomor port yang sesuai di URL setelah alamat IP. Misalnya:
http://localhost:${YOUR_PORT}/DiligentSamples/Tutorials/Tutorial01_HelloTriangle/Tutorial01_HelloTriangle.html
Rajin memiliki struktur modular, jadi untuk proyek Anda, Anda hanya dapat menggunakan submodul yang mengimplementasikan fungsionalitas yang diperlukan. Diagram di bawah ini menunjukkan ketergantungan antar modul.
Core
|
+------>Tools----------.
| | |
| V |
+------->FX---------. |
| | |
| V V
'----------------->Samples
Jangan lupa untuk menginisialisasi submodules secara rekursif jika Anda menambahkan repo yang rajin sebagai submodul ke proyek Anda.
Jika proyek Anda menggunakan CMake, menambahkan mesin yang rajin hanya membutuhkan beberapa baris kode. Misalkan struktur direktori terlihat seperti ini:
|
+-DiligentCore
+-HelloDiligent.cpp
Maka langkah -langkah berikut perlu dilakukan:
add_subdirectory(DiligentCore)Di bawah ini adalah contoh file 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() adalah fungsi kenyamanan yang menyalin perpustakaan bersama di sebelah yang dapat dieksekusi sehingga sistem dapat menemukan dan memuatnya. Harap lihat juga tutorial memulai untuk Windows dan Linux.
Pada sebagian besar platform, perpustakaan mesin inti dibangun dalam versi statis dan dinamis (misalnya, Diligent-GraphicsEngineD3D12-static dan Diligent-GraphicsEngineD3D12-shared ). Anda dapat memilih versi mana yang akan ditautkan dengan mengubah nama target di perintah cmake target_link_libraries() . Saat menghubungkan dengan pustaka dinamis, makro ENGINE_DLL akan ditentukan, dan perpustakaan perlu dimuat saat runtime. Misalnya, untuk backend Direct3D12:
# if ENGINE_DLL
// Load the dll and import GetEngineFactoryD3D12() function
auto GetEngineFactoryD3D12 = LoadGraphicsEngineD3D12();
# endif
auto * pFactoryD3D12 = GetEngineFactoryD3D12(); Saat menggunakan tautan statis, makro ENGINE_DLL tidak akan ditentukan, dan fungsi GetEngineFactoryD3D12 akan secara statis terkait dengan yang dapat dieksekusi.
File sampleapp.cpp memberikan contoh cara menginisialisasi mesin pada platform yang berbeda menggunakan tautan statis atau dinamis.
Anda dapat menggunakan FetchContent untuk mengunduh modul mesin yang rajin. Satu -satunya peringatan adalah bahwa Anda perlu menentukan direktori sumber agar setiap modul sama dengan nama modul, sehingga file header dapat ditemukan. Di bawah ini adalah contoh file cmake yang menggunakan 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)Jika proyek Anda tidak menggunakan CMake, disarankan untuk membangun perpustakaan dengan CMake dan menambahkannya ke sistem build Anda. Anda dapat mengunduh artefak build terbaru dari GitHub.
Direktori Instalasi CMake Global dikendalikan oleh variabel CMAKE_INTALL_PREFIX. Perhatikan bahwa itu default ke /usr/local di unix dan c:/Program Files/${PROJECT_NAME} di windows, yang mungkin bukan yang Anda inginkan. Gunakan -D CMAKE_INSTALL_PREFIX=install untuk menggunakan folder install lokal sebagai gantinya:
cmake -S . -B ./build/Win64 -D CMAKE_INSTALL_PREFIX=install -G "Visual Studio 17 2022" -A x64
Untuk menginstal perpustakaan dan file header, jalankan perintah cmake berikut dari folder build:
cmake --build . --target installDirektori Instalasi DiligentCore akan berisi semua yang diperlukan untuk mengintegrasikan mesin:
Cara yang lebih mudah adalah menautkan dengan pustaka dinamis. Saat menghubungkan secara statis, Anda perlu mendaftar DiligentCore serta semua perpustakaan pihak ketiga yang digunakan oleh mesin. Selain itu, Anda juga perlu menentukan perpustakaan sistem platform khusus. Misalnya, untuk platform Windows, daftar perpustakaan yang perlu ditautkan oleh proyek Anda mungkin terlihat seperti ini:
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
Header mesin yang rajin memerlukan salah satu dari makro platform berikut untuk didefinisikan sebagai 1 : PLATFORM_WIN32 , PLATFORM_UNIVERSAL_WINDOWS , PLATFORM_ANDROID , PLATFORM_LINUX , PLATFORM_MACOS , PLATFORM_IOS .
Anda dapat mengontrol komponen mesin mana yang ingin Anda instal menggunakan opsi cmake berikut: DILIGENT_INSTALL_CORE , DILIGENT_INSTALL_FX , DILIGENT_INSTALL_SAMPLES , dan DILIGENT_INSTALL_TOOLS .
Cara lain untuk mengintegrasikan mesin adalah dengan menghasilkan file build (seperti proyek Visual Studio) dan menambahkannya ke sistem build Anda. Bangun kustomisasi yang dijelaskan di bawah ini dapat membantu mengubah pengaturan untuk kebutuhan spesifik Anda.
Opsi cmake yang tersedia dirangkum dalam tabel di bawah ini:
| Pilihan | Nilai default | Keterangan |
|---|---|---|
DILIGENT_NO_DIRECT3D11 | TIDAK | Jangan Membangun Backend Direct3d11 |
DILIGENT_NO_DIRECT3D12 | TIDAK | Jangan Bangun Backend Direct3D12 |
DILIGENT_NO_OPENGL | TIDAK | Jangan Membangun Backend OpenGL |
DILIGENT_NO_VULKAN | TIDAK | JANGAN BUILT BACKEND VARL |
DILIGENT_NO_METAL | TIDAK | Jangan membangun backend logam |
DILIGENT_NO_WEBGPU | TIDAK | Jangan Membangun Backend Webgpu |
DILIGENT_NO_ARCHIVER | TIDAK | Jangan Bangun Pengarsipan |
DILIGENT_NO_RENDER_STATE_PACKAGER | TIDAK | Jangan Membangun Alat Paket Negara Render |
DILIGENT_ENABLE_DRACO | TIDAK | Aktifkan Dukungan Kompresi Draco di GLTF Loader |
DILIGENT_USE_RAPIDJSON | TIDAK | Gunakan Parser RapidJson di GLTF Loader |
DILIGENT_BUILD_TOOLS | Ya | Bangun Modul Alat |
DILIGENT_BUILD_FX | Ya | Bangun Modul FX |
DILIGENT_BUILD_SAMPLES | Ya | Bangun modul sampel |
DILIGENT_BUILD_SAMPLE_BASE_ONLY | TIDAK | Bangun Proyek Contoh Hanya dan Tidak Ada Sampel/Tutorial Lainnya |
DILIGENT_BUILD_TESTS | TIDAK | Bangun tes unit |
DILIGENT_NO_GLSLANG | TIDAK | Jangan membangun Glslang dan spriv-tools |
DILIGENT_NO_HLSL | TIDAK | Nonaktifkan Dukungan HLSL di Backends Non-Direct3D |
DILIGENT_NO_FORMAT_VALIDATION | Ya | Nonaktifkan Validasi Pemformatan Kode Sumber |
DILIGENT_LOAD_PIX_EVENT_RUNTIME | TIDAK | Aktifkan Dukungan Acara Pix |
DILIGENT_NVAPI_PATH | Jalur ke nvapi sdk | |
DILIGENT_INSTALL_CORE | Ya | Instal Modul Inti |
DILIGENT_INSTALL_TOOLS | Ya | Instal Modul Alat |
DILIGENT_INSTALL_FX | Ya | Instal Modul FX |
DILIGENT_INSTALL_SAMPLES | Ya | Pasang modul sampel |
DILIGENT_INSTALL_PDB | TIDAK | Instal Program Debug Database |
DILIGENT_DEAR_IMGUI_PATH | Jalur opsional ke proyek IMGUI yang disediakan pengguna | |
DILIGENT_ARGS_DIR | Jalur opsional ke proyek ARG yang disediakan pengguna | |
DILIGENT_NUKLEAR_DIR | Jalur opsional ke proyek nuklear yang disediakan pengguna | |
DILIGENT_MSVC_COMPILE_OPTIONS | Opsi kompilasi MSVC tambahan untuk semua konfigurasi | |
DILIGENT_MSVC_DEBUG_COMPILE_OPTIONS | Opsi kompilasi MSVC tambahan untuk konfigurasi debug | |
DILIGENT_MSVC_RELEASE_COMPILE_OPTIONS | /GL /Arch: AVX2 | Opsi kompilasi MSVC tambahan untuk konfigurasi rilis |
DILIGENT_CLANG_COMPILE_OPTIONS | Opsi kompilasi klang tambahan untuk semua konfigurasi | |
DILIGENT_CLANG_DEBUG_COMPILE_OPTIONS | Opsi kompilasi clang tambahan untuk konfigurasi debug | |
DILIGENT_CLANG_RELEASE_COMPILE_OPTIONS | -mavx2 | Opsi kompilasi clang tambahan untuk konfigurasi rilis |
DILIGENT_USD_PATH | Folder Instalasi Jalur ke USD |
Secara default, semua back-end yang tersedia pada platform saat ini dibangun. Untuk menonaktifkan back-end tertentu, gunakan opsi berikut: DILIGENT_NO_DIRECT3D11 , DILIGENT_NO_DIRECT3D12 , DILIGENT_NO_OPENGL , DILIGENT_NO_VULKAN , DILIGENT_NO_METAL , DILIGENT_NO_WEBGPU . Backend WebGPU diaktifkan secara default saat membangun untuk web. Untuk mengaktifkannya di platform lain, gunakan DILIGENT_NO_WEBGPU=OFF . Opsi dapat diatur melalui CMake UI atau dari baris perintah seperti pada contoh di bawah ini:
cmake -D DILIGENT_NO_DIRECT3D11=TRUE -S . -B ./build/Win64 -G "Visual Studio 17 2022" -A x64
Selain itu, masing -masing komponen mesin dapat diaktifkan atau dinonaktifkan menggunakan opsi berikut: DILIGENT_BUILD_TOOLS , DILIGENT_BUILD_FX , DILIGENT_BUILD_SAMPLES . Jika Anda hanya ingin membangun proyek SampleBase , Anda dapat menggunakan opsi DILIGENT_BUILD_SAMPLE_BASE_ONLY .
Secara default vulkan back-end dihubungkan dengan Glslang yang memungkinkan menyusun hlsl dan shader glsl menjadi spirv pada waktu lari. Jika kompilasi run-time tidak diperlukan, GLSlang dapat dinonaktifkan dengan opsi cmake DILIGENT_NO_GLSLANG . Selain itu, dukungan HLSL dalam backends non-direktik3D dapat dinonaktifkan dengan opsi DILIGENT_NO_HLSL . Mengaktifkan opsi secara signifikan mengurangi ukuran binari vulkan dan backgl backgl, yang mungkin sangat penting untuk aplikasi seluler.
Mesin yang rajin menggunakan format klang untuk memastikan pemformatan yang konsisten di seluruh basis kode. Validasi dapat dinonaktifkan menggunakan opsi cmake DILIGENT_NO_FORMAT_VALIDATION . Perhatikan bahwa setiap permintaan tarik akan gagal jika masalah pemformatan ditemukan.
Mesin yang rajin menggunakan validasi ekstensif yang selalu diaktifkan dalam debug build. Beberapa cek dapat diaktifkan dalam konfigurasi rilis dengan mengatur opsi cmake DILIGENT_DEVELOPMENT .
Untuk mengaktifkan dukungan pix event, atur flag CMAKE DILIGENT_LOAD_PIX_EVENT_RUNTIME .
Untuk mengaktifkan beberapa fitur canggih pada NVIDIA GPU (seperti dukungan asli multi draw di Direct3D11), unduh NVAPI dan atur variabel CMAKE DILIGENT_NVAPI_PATH .
Mesin yang rajin menggunakan beberapa perpustakaan pihak ketiga. Jika file CMake aplikasi mendefinisikan salah satu perpustakaan itu, rajin akan menggunakan target yang ada. Aplikasi perlu memastikan bahwa pengaturan build kompatibel dengan rajin.
Mesin yang rajin memungkinkan klien untuk menyesuaikan pengaturan pembuatan dengan menyediakan file skrip konfigurasi yang mendefinisikan fungsi cmake opsional berikut:
custom_configure_build() - Menentukan properti build global seperti konfigurasi build, c/c ++ bendera kompilasi, bendera tautan dll.custom_pre_configure_target() - Menentukan pengaturan khusus untuk setiap target dalam build dan dipanggil sebelum sistem build mesin mulai mengkonfigurasi target.custom_post_configure_target() - Dipanggil setelah sistem build engine telah mengonfigurasi target untuk membiarkan klien mengganti properti yang ditetapkan oleh mesin. Jalur ke skrip konfigurasi harus disediakan melalui variabel BUILD_CONFIGURATION_FILE saat menjalankan cmake dan harus relatif ke folder root cmake, misalnya:
cmake -D BUILD_CONFIGURATION_FILE=BuildConfig.cmake -S . -B ./build/Win64 -G "Visual Studio 17 2022" -A x64
Jika didefinisikan, fungsi custom_configure_build() dipanggil sebelum target build ditambahkan. Secara default, CMake mendefinisikan empat konfigurasi berikut: Debug, Rilis, RelWithDebinfo, Minsizerel. Jika Anda mau, Anda dapat menentukan konfigurasi build Anda sendiri dengan mengatur variabel CMAKE_CONFIGURATION_TYPES . Misalnya, jika Anda hanya ingin memiliki dua konfigurasi: debug dan rilis, tambahkan baris berikut ke fungsi custom_configure_build() :
set (CMAKE_CONFIGURATION_TYPES Debug ReleaseMT CACHE STRING "Configuration types: Debug, ReleaseMT" FORCE ) Sistem build perlu mengetahui daftar konfigurasi debug dan rilis (dioptimalkan), sehingga dua variabel berikut juga harus diatur ketika variabel CMAKE_CONFIGURATION_TYPES didefinisikan:
set (DEBUG_CONFIGURATIONS DEBUG CACHE INTERNAL "" FORCE )
set (RELEASE_CONFIGURATIONS RELEASEMT CACHE INTERNAL "" FORCE ) Perhatikan bahwa karena spesifik CMake, nama konfigurasi yang tercantum dalam DEBUG_CONFIGURATIONS dan RELEASE_CONFIGURATIONS harus dikapitalisasi .
Jika Anda mendefinisikan konfigurasi apa pun selain dari empat yang cmake standar, Anda juga perlu mengatur variabel berikut, untuk setiap konfigurasi baru:
CMAKE_C_FLAGS_<Config> - c Bendera kompilasiCMAKE_CXX_FLAGS_<Config> - C ++ Compile FlagsCMAKE_EXE_LINKER_FLAGS_<Config> - Bendera tautan yang dapat dieksekusiCMAKE_SHARED_LINKER_FLAGS_<Config> - bendera tautan perpustakaan bersamaMisalnya:
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 )Di bawah ini adalah contoh fungsi 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 () Jika didefinisikan, custom_pre_configure_target() dipanggil untuk setiap target yang dibuat oleh sistem build dan memungkinkan mengonfigurasi properti spesifik target.
Secara default, sistem build menetapkan beberapa properti target. Jika custom_pre_configure_target() menetapkan semua properti yang diperlukan, dapat memberi tahu sistem build bahwa tidak ada pemrosesan lebih lanjut yang diperlukan dengan mengatur variabel lingkup induk TARGET_CONFIGURATION_COMPLETE ke TRUE
set (TARGET_CONFIGURATION_COMPLETE TRUE PARENT_SCOPE ) Berikut ini adalah contoh fungsi 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 () Jika klien hanya perlu mengganti beberapa pengaturan, itu dapat mendefinisikan fungsi custom_post_configure_target() yang dipanggil setelah mesin selesai mengkonfigurasi target, misalnya:
function (custom_post_configure_target TARGET )
set_target_properties ( ${TARGET} PROPERTIES
CXX_STANDARD 17
)
endfunction ()Silakan merujuk ke halaman ini. Juga, tutorial dan sampel yang tercantum di bawah ini adalah tempat yang baik untuk memulai.
Notasi keadaan render yang rajin adalah bahasa berbasis JSON yang menggambarkan shader, status pipa, tanda tangan sumber daya dan objek lain dalam bentuk yang nyaman, misalnya:
{
"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 "
}
]
}File JSON dapat diuraikan secara dinamis pada waktu berjalan. Atau, aplikasi dapat menggunakan alat Packager untuk preprocess deskripsi pipa (compile shader untuk platform target, tentukan tata letak sumber daya internal, dll.) Ke dalam arsip biner yang dioptimalkan untuk kinerja pemuatan run-time.
| Tutorial | Tangkapan layar | Keterangan |
|---|---|---|
| 01 - Hello Triangle |  | Tutorial ini menunjukkan cara membuat segitiga sederhana menggunakan API mesin yang rajin. |
| 02 - Kubus |  | Tutorial ini menunjukkan cara membuat objek 3D yang sebenarnya, sebuah kubus. Ini menunjukkan cara memuat shader dari file, membuat dan menggunakan buffer vertex, indeks dan seragam. |
| 03 - Tekstur |  | Tutorial ini menunjukkan cara menerapkan tekstur ke objek 3D. Ini menunjukkan cara memuat tekstur dari file, membuat objek pengikatan sumber daya shader dan cara mencicipi tekstur di shader. |
| 03 - Texturing -C | | Tutorial ini identik dengan tutorial03, tetapi diimplementasikan menggunakan C API. |
| 03 - Tekstur -Dotnet | | Tutorial ini menunjukkan cara menggunakan API mesin yang rajin di aplikasi .net. |
| 04 - Instancing |  | Tutorial ini menunjukkan cara menggunakan Instance untuk membuat banyak salinan dari satu objek menggunakan matriks transformasi unik untuk setiap salinan. |
| 05 - Array Tekstur |  | Tutorial ini menunjukkan cara menggabungkan instance dengan array tekstur untuk menggunakan tekstur unik untuk setiap contoh. |
| 06 - Multithreading |  | Tutorial ini menunjukkan cara menghasilkan daftar perintah secara paralel dari beberapa utas. |
| 07 - Geometry Shader |  | Tutorial ini menunjukkan cara menggunakan geometry shader untuk membuat wireframe yang halus. |
| 08 - Tessellation |  | Tutorial ini menunjukkan cara menggunakan tessellation perangkat keras untuk menerapkan algoritma rendering medan adaptif sederhana. |
| 09 - paha depan |  | Tutorial ini menunjukkan cara membuat beberapa quads 2D, sering beralih tekstur dan mode campuran. |
| 10 - Streaming Data |  | Tutorial ini menunjukkan strategi pemetaan buffer dinamis menggunakan MAP_FLAG_DISCARD dan MAP_FLAG_DO_NOT_SYNCHRONIZE flags untuk secara efisien mengalirkan berbagai jumlah data ke GPU. |
| 11 - Pembaruan Sumber Daya |  | Tutorial ini menunjukkan berbagai cara untuk memperbarui buffer dan tekstur di mesin yang rajin dan menjelaskan detail internal yang penting dan implikasi kinerja yang terkait dengan setiap metode. |
| 12 - Target Render |  | Tutorial ini menunjukkan cara membuat kubus 3D menjadi target render offscreen dan melakukan efek pasca pemrosesan sederhana. |
| 13 - Peta Bayangan |  | Tutorial ini menunjukkan cara membuat bayangan dasar menggunakan peta bayangan. |
| 14 - Hitung Shader |  | Tutorial ini menunjukkan cara menerapkan sistem simulasi partikel sederhana menggunakan compute shader. |
| 15 - Beberapa jendela |  | Tutorial ini menunjukkan cara menggunakan mesin yang rajin untuk diterjemahkan ke beberapa jendela. |
| 16 - Sumber Daya Bindless |  | Tutorial ini menunjukkan cara mengimplementasikan Bindless Resources, teknik yang memanfaatkan fitur pengindeksan sumber daya shader dinamis yang diaktifkan oleh API generasi berikutnya untuk secara signifikan meningkatkan kinerja rendering. |
| 17 - MSAA |  | Tutorial ini menunjukkan cara menggunakan multisample anti-aliasing (MSAA) untuk membuat tepi geometris terlihat lebih halus dan lebih stabil sementara. |
| 18 - kueri |  | Tutorial ini menunjukkan cara menggunakan kueri untuk mengambil berbagai informasi tentang operasi GPU, seperti jumlah primitif yang diberikan, durasi pemrosesan perintah, dll. |
| 19 - Render pass |  | Tutorial ini menunjukkan cara menggunakan API Render Pass untuk mengimplementasikan naungan yang ditangguhkan sederhana. |
| 20 - jala shader |  | Tutorial ini menunjukkan cara menggunakan amplifikasi dan shader mesh, tahap yang dapat diprogram baru, untuk mengimplementasikan pemotongan frustum view dan perhitungan LOD objek pada GPU. |
| 21 - Ray Tracing |  | Tutorial ini menunjukkan dasar -dasar menggunakan Ray Tracing API di mesin yang rajin. |
| 22 - rendering hibrida |  | Tutorial ini menunjukkan cara menerapkan renderer hibrida sederhana yang menggabungkan rasterisasi dengan penelusuran ray. |
| 23 - Antrian Perintah |  | Tutorial ini menunjukkan cara menggunakan beberapa antrian perintah untuk melakukan rendering secara paralel dengan operasi salinan dan komputasi. |
| 24 - Naungan laju variabel |  | Tutorial ini menunjukkan cara menggunakan naungan laju variabel untuk mengurangi beban naungan piksel. |
| 25 - Render State Packager |  | Tutorial ini menunjukkan cara membuat dan mengarsipkan status pipa dengan alat render state packagager off-line pada contoh pelacak jalur sederhana. |
| 26 - Render State Cache |  | Tutorial ini memperluas teknik penelusuran jalur yang diterapkan dalam tutorial sebelumnya dan menunjukkan cara menggunakan cache status render untuk menyimpan status pipa yang dibuat pada waktu berjalan dan memuatnya ketika aplikasi dimulai. |
| 27 - pasca -pemrosesan |  | Tutorial ini menunjukkan cara menggunakan efek pasca pemrosesan dari modul DiligentFX. |
| Mencicipi | Tangkapan layar | Keterangan |
|---|---|---|
| Sampel atmosfer |  | Sampel ini menunjukkan cara mengintegrasikan efek hamburan cahaya epipolar pasca-pemrosesan ke dalam aplikasi untuk membuat atmosfer berbasis fisik. |
| Demo GLFW |  | Mini-game labirin ini menunjukkan cara menggunakan GLFW untuk membuat jendela dan menangani input keyboard dan mouse. |
| GLTF Viewer |  | Sampel ini menunjukkan cara menggunakan aset loader dan renderer PBR untuk memuat dan membuat model GLTF. |
| Penampil USD |  | Sampel ini menunjukkan cara membuat file USD menggunakan hidrogen, implementasi Hydra Rendering API di mesin yang rajin. |
| Bayangan |  | Sampel ini menunjukkan cara menggunakan komponen bayangan untuk membuat bayangan berkualitas tinggi. |
| Demo Imgui yang terhormat |  | Sampel ini menunjukkan integrasi mesin dengan perpustakaan IMGUI UI yang terhormat. |
| Demo nuklear |  | Sampel ini menunjukkan integrasi mesin dengan perpustakaan UI nuklear. |
| Halo AR |  | Sampel ini menunjukkan cara menggunakan mesin yang rajin dalam aplikasi AR Android dasar. |
| Asteroid |  | Sampple ini adalah tolok ukur kinerja yang membuat 50.000 asteroid bertekstur unik dan memungkinkan membandingkan kinerja berbagai mode rendering. |
| Demo integrasi persatuan |  | Proyek ini menunjukkan integrasi mesin yang rajin dengan persatuan. |
Fungsi rendering tingkat tinggi diimplementasikan oleh modul DiligentFX. Komponen berikut sekarang tersedia:
 | |
 |  |
Anti-aliasing temporal
Utilitas shader pemetaan nada
Kami akan sangat menghargainya jika Anda dapat mengirimi kami tautan jika produk Anda menggunakan mesin yang rajin.
Sistem visualisasi medan skala besar untuk simulator pelatihan pilot oleh sistem elbit
LumenRT: A Visualization and Reality Modeling Software by Bentley Systems
Godus: An award-winning sandbox game by 22cans
Vrmac Graphics: A cross-platform graphics library for .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
