DiligentEngine
v2.5.6
Una moderna biblioteca de gráficos 3D de bajo nivel multiplataforma y marco de renderizado
Diligent Engine es una biblioteca de abstracción API de gráficos multiplataforma ligera y marco de representación. Está diseñado para aprovechar al máximo Direct3D12, Vulkan, Metal y WebGPU, mientras admite plataformas más antiguas a través de Direct3D11, OpenGL, OpenGles y WebGL. El motor diligente expone una API front-end común y utiliza HLSL como lenguaje de sombreado universal en todas las plataformas y retrasos en los back-end. Las representaciones de sombreador específicas de la plataforma (GLSL, MSL, DX Bytecode o SpirV) se pueden usar con los back-end correspondientes. El motor está destinado a usarse como subsistema de gráficos en un motor de juego o en cualquier otra aplicación 3D. Se distribuye bajo la licencia Apache 2.0 y es de uso gratuito.
| Plataforma | D3D11 | D3D12 | OpenGL/GLES | Vulkan | Metal | WebGPU | Estado de construcción |
|---|---|---|---|---|---|---|---|
 Windows | ✔️ | ✔️ | ✔️ | ✔️ | - | ✔️ 3 |  |
 Ventanas universales | ✔️ | ✔️ | - | - | - | - | |
 Linux | - | - | ✔️ | ✔️ | - | ✔️ 3 |  |
 Androide | - | - | ✔️ | ✔️ | - | - |  |
 Macosa | - | - | ✔️ | ✔️ 1 | ✔️ 2 | ✔️ 3 |  |
 iOS | - | - | ✔️ | ✔️ 1 | ✔️ 2 | - | |
 tvos | - | - | - | ✔️ 1 | ✔️ 2 | - | |
 Emscripten | - | - | ✔️ | - | - | ✔️ |  |
1 API Vulkan no es compatible de forma nativa en las plataformas MacOS, iOS y TVOS y requiere una implementación de portabilidad de Vulkan, como la portabilidad Moltenvk o GFX.
2 Disponible bajo licencia comercial: contáctenos para obtener más detalles.
3 requiere una implementación nativa de WebGPU, se recomienda Dawn.
#if defined(_WIN32) ... #elif defined(LINUX) ... #elif defined(ANDROID) ...#if defined(D3D11) ... #elif defined(D3D12) ... #elif defined(OPENGL) ...Versiones API de bajo nivel mínimas:
Este es el repositorio maestro que contiene cuatro submódulos. Para obtener el repositorio y todos los submódulos, use el siguiente comando:
git clone --recursive https://github.com/DiligentGraphics/DiligentEngine.git
Al actualizar el repositorio existente, no olvide actualizar todos los submódulos:
git pull
git submodule update --recursive
También es una buena idea volver a ejecutar CMake y realizar una reconstrucción limpia después de obtener la última versión.
El repositorio maestro incluye los siguientes submódulos:
Diligent Engine utiliza Cmake como una herramienta de compilación multiplataforma. Para comenzar a usar CMake, descargue la última versión (se requiere 3.20 o posterior). Otro requisito previo de compilación es el intérprete de Python (se requiere 3.0 o posterior). Si después de seguir las instrucciones a continuación, tiene problemas de construcción/ejecución, eche un vistazo a la solución de problemas.
Construir requisitos previos:
El soporte .NET requiere .NET SDK 6.0 o posterior.
Use la GUI CMake o la herramienta de línea de comandos para generar archivos de compilación. Por ejemplo, para generar una solución Visual Studio 2022 de 64 bits y archivos de proyecto en la carpeta Build/Win64 , navegue a la carpeta raíz del motor y ejecute el siguiente comando:
cmake -S . -B ./build/Win64 -G "Visual Studio 17 2022" -A x64
Puede generar una solución Win32 que se dirige a Win8.1 SDK usando el siguiente comando:
cmake -D CMAKE_SYSTEM_VERSION=8.1 -S . -B ./build/Win64_8.1 -G "Visual Studio 17 2022" -A x64
Si usa MingW, puede generar los archivos Make utilizando el comando a continuación (tenga en cuenta que la funcionalidad será limitada y que MingW no es una forma recomendada de construir el motor):
cmake -S . -B ./build/MinGW -D CMAKE_BUILD_TYPE=Release -G "MinGW Makefiles"
Para habilitar las capas de validación de Vulkan, deberá descargar la variable de entorno Vulkan y agregar la variable de entorno VK_LAYER_PATH que contiene la ruta al directorio bin en la carpeta de instalación de Vulkansdk.
Abra el archivo DiligentEngine.sln en la carpeta Build/Win64 , seleccione Configuración y cree el motor. Establezca el proyecto deseado como proyecto de inicio (de forma predeterminada, se seleccionará el visor GLTF) y ejecutarlo.
Por defecto, las aplicaciones de muestra y tutoriales mostrarán el cuadro de diálogo Selección de backend de representación. Use las siguientes opciones de línea de comando para forzar el modo D3D11, D3D12, OpenGL o Vulkan: - -Mode D3D11 , - -Mode D3D12 , - -Mode GL o - -Mode VK . Si desea ejecutar una aplicación fuera del entorno Visual Studio, la carpeta de activos de la aplicación debe establecerse como directorio de trabajo. (Para Visual Studio, esto está configurado automáticamente por CMake). Alternativamente, puede navegar a la carpeta de destino o instalación de compilación y ejecutar el ejecutable desde allí.
Para generar archivos de compilación para la plataforma Universal Windows, debe definir las siguientes dos variables CMake:
CMAKE_SYSTEM_NAME=WindowsStoreCMAKE_SYSTEM_VERSION=< Windows Version >Por ejemplo, para generar una solución Visual Studio 2022 de 64 bits y archivos de proyecto en la carpeta Build/UWP64 , ejecute el siguiente comando desde la carpeta raíz del motor:
cmake -D CMAKE_SYSTEM_NAME=WindowsStore -D CMAKE_SYSTEM_VERSION=10.0 -S . -B ./build/UWP64 -G "Visual Studio 17 2022" -A x64
Establezca el proyecto deseado como proyecto de inicio (de forma predeterminada, se seleccionará el visor GLTF) y ejecutarlo.
Por defecto, las aplicaciones se ejecutarán en modo D3D12. Puede seleccionar D3D11 o D3D12 usando las siguientes opciones de línea de comando: - -Mode D3D11 , - -Mode D3D12 .
Nota: Es posible generar una solución que se dirige a Windows 8.1 definiendo cmake_system_version = 8.1 CMake Variable, pero no puede construir, ya que usará Visual Studio 2013 (V120) que carece de soporte C ++ 14 adecuado.
Su entorno Linux debe configurarse para el desarrollo de C ++. Si ya es así, asegúrese de que sus herramientas de C ++ estén actualizadas ya que el motor diligente usa características modernas de C ++ (se recomienda el clang 10 o posterior).
Es posible que deba instalar los siguientes paquetes:
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
Para configurar Vulkan también necesitará:
Para generar archivos Make para la configuración de depuración, ejecute el siguiente comando CMake desde la carpeta raíz del motor:
cmake -S . -B ./build -G "Unix Makefiles" -DCMAKE_BUILD_TYPE="Debug"
Para construir el motor, ejecute el siguiente comando:
cmake --build ./build
En Ubuntu 23 y más nuevo, puede bloquearse si no tiene Libtinfo5 instalado, deberá agregarlo.
La carpeta raíz del motor contiene archivos de configuración de código Visual Studio que configuran el IDE para construir el motor. Puede ejecutar aplicaciones directamente desde el IDE. Para ejecutar una aplicación desde la línea de comando, la carpeta de activos de la aplicación debe ser el directorio actual.
Asegúrese de que su máquina esté configurada para el desarrollo de Android. Descargue Android Studio, instale y configure el NDK y CMake y otras herramientas requeridas. Se requiere NDK R24 o posterior. Si no está utilizando la versión CMake incluida con Android Studio, asegúrese de que sus archivos de compilación estén configurados correctamente. Para verificar que su entorno esté configurado correctamente, intente construir la muestra de teteras y los tutoriales de Android Vulkan.
Abra la carpeta Diligentsamples/Android con Android Studio para construir y ejecutar tutoriales y muestras en Android.
Por defecto, las aplicaciones se ejecutarán en modo Vulkan. Para ejecutarlos en modo Vulkan, agregue los siguientes indicadores de lanzamiento: --es mode gles (en Android Studio, vaya a Run-> Editar configuraciones Menú)
Prerrequisitos:
Después de clonar el repositorio, ejecute el siguiente comando desde la carpeta raíz del motor para generar el proyecto Xcode:
cmake -S . -B ./build/MacOS -G "Xcode"
El proyecto se ubicará en la carpeta build/MacOS .
Tenga en cuenta que si CMake no puede encontrar el compilador, es posible que deba ejecutar el siguiente comando:
sudo xcode-select --reset
Por defecto, no hay implementación de Vulkan en MacOS. Motor diligente Carga a Vulkan dinámicamente y puede usar una implementación de portabilidad de Vulkan, como Moltenvk o GFX-Portability. Instale Vulkansdk y asegúrese de que su sistema esté configurado correctamente como se describe aquí. En particular, es posible que deba definir las siguientes variables de entorno (suponiendo que Vulkan SDK esté instalado en /Users/MyName/VulkanSDK/1.3.290.0 y desea usar 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
Tenga en cuenta que las variables de entorno establecidas en el shell no son vistas por las aplicaciones lanzadas desde LaunchPad u otra GUI de escritorio. Por lo tanto, para asegurarse de que una aplicación encuentre bibliotecas Vulkan, debe iniciarse desde la línea de comando. Debido a la misma razón, el archivo del proyecto XCode también debe abrirse desde el shell utilizando el comando open . Con las versiones de Xcode 7 y posterior, este comportamiento puede necesitar habilitarse primero utilizando el siguiente comando:
defaults write com.apple.dt.Xcode UseSanitizedBuildSystemEnvironment -bool NO
Consulte esta página para obtener más detalles.
DYLD_LIBRARY_PATH y LD_LIBRARY_PATH Las variables de entorno se ignoran en macOS a menos que la protección de integridad del sistema se deshabilite (que generalmente no se recomienda). Para que los ejecutables encuentren la biblioteca Vulkan, debe estar en rpath. Si se establece la variable de entorno VULKAN_SDK y puntos para corregir la ubicación, Diligent Engine configurará el RPATH para todas las aplicaciones automáticamente.
Última versión probada de Vulkan SDK: 1.3.290.0.
Prerrequisitos:
Ejecute el comando a continuación desde la carpeta raíz del motor para generar el proyecto Xcode configurado para la compilación de iOS:
cmake -S . -B ./build/iOS -DCMAKE_SYSTEM_NAME=iOS -G "Xcode"Si es necesario, puede proporcionar un objetivo de implementación de iOS (se requiere 13.0 o posterior), así como otros parámetros, por ejemplo:
cmake -S . -B ./build/iOS -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_DEPLOYMENT_TARGET=13.0 -G "Xcode"iphonesimulator . También puede usar la variable CMAKE_OSX_ARCHITECTURES para especificar la arquitectura de destino, por ejemplo:
cmake -S . -B ./build/iOSSim -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphonesimulator -DCMAKE_OSX_ARCHITECTURES=arm64 -G "Xcode" Abra el archivo del proyecto Xcode en la carpeta build/IOS y cree el motor. Para ejecutar las aplicaciones en un dispositivo iOS, deberá establecer el equipo de desarrollo apropiado en la configuración del proyecto.
Para habilitar Vulkan en iOS, descargue e instale Vulkansdk. No hay cargador Vulkan en iOS y enlaces diligentes del motor directamente con Moltenvk XCFramework (ver Guía de instalación de Moltenvk) que implementa a Vulkan en el metal. Para habilitar Vulkan en un motor diligente en iOS, especifique la ruta a Vulkan SDK al ejecutar CMake, por ejemplo (suponiendo que Vulkan SDK esté instalado en /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" Por defecto, el motor se vincula con Moltenvk XCFramework ubicado en Vulkan SDK. Si no se desea esto o una aplicación desea usar una biblioteca específica, puede proporcionar la ruta completa a la biblioteca a través de la variable CMAKE CMAKE MOLTENVK_LIBRARY .
Consulte la Guía del usuario de Moltenvk para obtener más información sobre la instalación y el uso de Moltenvk.
Última versión probada de Vulkan SDK: 1.3.290.0.
Construir requisitos previos:
Activar ruta y otras variables de entorno en el terminal actual
source ${PATH_TO_EMSDK} /emsdk/emsdk_env.sh${PATH_TO_EMSDK}/emsdk/emsdk_env.bat en lugar de source ${PATH_TO_EMSDK}/emsdk/emsdk_env.sh
Para generar el proyecto, ejecute el siguiente comando Cmake desde la carpeta raíz del motor:
emcmake cmake -S . -B ./build/Emscripten -G "Ninja"Para construir el motor, ejecute el siguiente comando:
cmake --build ./build/EmscriptenPara probar aplicaciones Emscripten, ejecute un servidor web básico
cd ./build/Emscripten
python https_server.py Abra un navegador y navegue a http://localhost
Por ejemplo, el tutorial Hello Triangle estará disponible en
http://localhost/DiligentSamples/Tutorials/Tutorial01_HelloTriangle/Tutorial01_HelloTriangle.html
Para acceder al servidor desde otra computadora en la red local, use el servidor HTTPS. Para habilitar esto, primero instale el módulo cryptography . Puede hacerlo ejecutando el siguiente comando:
pip install cryptographyPara iniciar el servidor HTTPS, use el siguiente comando:
python https_server.py --mode=httpsUse el protocolo HTTPS para abrir las páginas. Por ejemplo:
https://localhost/DiligentSamples/Tutorials/Tutorial01_HelloTriangle/Tutorial01_HelloTriangle.html
Al usar el servidor HTTPS, a diferencia del servidor HTTP, puede encontrar el siguiente error al cargar la página: net::ERR_CERT_AUTHORITY_INVALID .
Hay dos formas de resolver este problema:
Advanced y luego seleccione Proceed to localhost (unsafe) .python https_server.py --mode=https --register Utilizamos los puertos predeterminados para los protocolos HTTP/HTTPS, 80 y 443 respectivamente. Si ya tiene un servidor que se ejecuta en esos puertos, puede especificar un número de puerto diferente utilizando el argumento --port e incluir el número de puerto correspondiente en la URL después de la dirección IP. Por ejemplo:
http://localhost:${YOUR_PORT}/DiligentSamples/Tutorials/Tutorial01_HelloTriangle/Tutorial01_HelloTriangle.html
Diligent tiene una estructura modular, por lo que para su proyecto solo puede usar los submódulos que implementan la funcionalidad requerida. El siguiente diagrama muestra las dependencias entre módulos.
Core
|
+------>Tools----------.
| | |
| V |
+------->FX---------. |
| | |
| V V
'----------------->Samples
No olvide inicializar recursivamente submódulos si está agregando repositorios diligentes como submódulos a su proyecto.
Si su proyecto usa CMake, agregar motor diligente requiere solo unas pocas líneas de código. Supongamos que la estructura del directorio se ve así:
|
+-DiligentCore
+-HelloDiligent.cpp
Entonces se deben hacer los siguientes pasos:
add_subdirectory(DiligentCore)A continuación se muestra un ejemplo de un archivo 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() es una función de conveniencia que copia bibliotecas compartidas junto al ejecutable para que el sistema pueda encontrarlas y cargarlas. También eche un vistazo a los tutoriales iniciados para Windows y Linux.
En la mayoría de las plataformas, las bibliotecas de motores de núcleo están construidas en versiones estáticas y dinámicas (por ejemplo, Diligent-GraphicsEngineD3D12-static y Diligent-GraphicsEngineD3D12-shared ). Puede elegir con qué versión vincular cambiando el nombre de destino en el comando target_link_libraries() CMake. Al vincular con bibliotecas dinámicas, se definirá la macro ENGINE_DLL , y las bibliotecas deberán cargarse en tiempo de ejecución. Por ejemplo, para el backend directo3D12:
# if ENGINE_DLL
// Load the dll and import GetEngineFactoryD3D12() function
auto GetEngineFactoryD3D12 = LoadGraphicsEngineD3D12();
# endif
auto * pFactoryD3D12 = GetEngineFactoryD3D12(); Al usar la enlace Static, la macro ENGINE_DLL no se definirá, y la función GetEngineFactoryD3D12 estará vineada estáticamente con el ejecutable.
El archivo sampepp.cpp proporciona un ejemplo de cómo inicializar el motor en diferentes plataformas utilizando un enlace estático o dinámico.
Puede usar FetchContent para descargar módulos de motor Diligent. La única advertencia es que debe especificar el directorio de origen para que cada módulo sea el mismo que el nombre del módulo, de modo que se puedan encontrar archivos de encabezado. A continuación se muestra un ejemplo de un archivo Cmake que usa 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 su proyecto no usa CMake, se recomienda construir bibliotecas con Cmake y agregarlas a su sistema de compilación. Puede descargar los últimos artefactos de compilación de GitHub.
El directorio de instalación de CMake global está controlado por la variable CMAKE_INTALL_PREFIX. Tenga en cuenta que el valor predeterminado es /usr/local en UNIX y c:/Program Files/${PROJECT_NAME} en Windows, que puede no ser lo que desea. Use -D CMAKE_INSTALL_PREFIX=install para usar la carpeta install local en su lugar:
cmake -S . -B ./build/Win64 -D CMAKE_INSTALL_PREFIX=install -G "Visual Studio 17 2022" -A x64
Para instalar bibliotecas y archivos de encabezado, ejecute el siguiente comando cmake desde la carpeta de compilación:
cmake --build . --target installEl directorio de instalación de DiligentCore contendrá todo lo requerido para integrar el motor:
Una forma más fácil es vincularse con bibliotecas dinámicas. Al vincular estáticamente, deberá enumerar DiligentCore, así como todas las bibliotecas de terceros utilizadas por el motor. Además de eso, también deberá especificar bibliotecas de sistemas específicas de la plataforma. Por ejemplo, para la plataforma Windows, la lista de bibliotecas con las que su proyecto deberá vincular puede verse así:
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
Los encabezados de motores diligentes requieren que una de las siguientes macros de plataforma se define como 1 : PLATFORM_WIN32 , PLATFORM_UNIVERSAL_WINDOWS , PLATFORM_ANDROID , PLATFORM_LINUX , PLATFORM_MACOS , PLATFORM_IOS .
Puede controlar qué componentes del motor desea instalar utilizando las siguientes opciones de CMake: DILIGENT_INSTALL_CORE , DILIGENT_INSTALL_FX , DILIGENT_INSTALL_SAMPLES y DILIGENT_INSTALL_TOOLS .
Otra forma de integrar el motor es generar archivos de compilación (como los proyectos de Visual Studio) y agregarlos a su sistema de compilación. La personalización de compilación que se describe a continuación puede ayudar a ajustar la configuración de sus necesidades específicas.
Las opciones de CMake disponibles se resumen en la tabla a continuación:
| Opción | Valor predeterminado | Descripción |
|---|---|---|
DILIGENT_NO_DIRECT3D11 | No | No construya backend directo 3D11 |
DILIGENT_NO_DIRECT3D12 | No | No construya backend directo 3D12 |
DILIGENT_NO_OPENGL | No | No construyas backend de OpenGL |
DILIGENT_NO_VULKAN | No | No construya el backend vulkan |
DILIGENT_NO_METAL | No | No construya backend de metal |
DILIGENT_NO_WEBGPU | No | No cree un backend de WebGPU |
DILIGENT_NO_ARCHIVER | No | No construyas Archiver |
DILIGENT_NO_RENDER_STATE_PACKAGER | No | No construya la herramienta de paquete de estado de renderizado |
DILIGENT_ENABLE_DRACO | No | Habilitar soporte de compresión Draco en el cargador GLTF |
DILIGENT_USE_RAPIDJSON | No | Use el analizador Rapidjson en el cargador GLTF |
DILIGENT_BUILD_TOOLS | Sí | Módulo de compilación de herramientas |
DILIGENT_BUILD_FX | Sí | Construir el módulo FX |
DILIGENT_BUILD_SAMPLES | Sí | Construir módulo de muestras |
DILIGENT_BUILD_SAMPLE_BASE_ONLY | No | Construir solo el proyecto SampleBase y no hay otras muestras/tutoriales |
DILIGENT_BUILD_TESTS | No | Construir pruebas unitarias |
DILIGENT_NO_GLSLANG | No | No construya glslang y spriv-tools |
DILIGENT_NO_HLSL | No | Deshabilitar el soporte HLSL en backends no directos 3D |
DILIGENT_NO_FORMAT_VALIDATION | Sí | Deshabilitar la validación del formato del código fuente |
DILIGENT_LOAD_PIX_EVENT_RUNTIME | No | Habilitar soporte de eventos PIX |
DILIGENT_NVAPI_PATH | Camino a NVAPI SDK | |
DILIGENT_INSTALL_CORE | Sí | Instalar módulo de núcleo |
DILIGENT_INSTALL_TOOLS | Sí | Instalar el módulo de herramientas |
DILIGENT_INSTALL_FX | Sí | Instalar el módulo FX |
DILIGENT_INSTALL_SAMPLES | Sí | Instalar módulo de muestras |
DILIGENT_INSTALL_PDB | No | Instalar la base de datos de depuración del programa |
DILIGENT_DEAR_IMGUI_PATH | Ruta opcional a un proyecto IMGUI proporcionado por el usuario | |
DILIGENT_ARGS_DIR | Ruta opcional a un proyecto Args proporcionado por el usuario | |
DILIGENT_NUKLEAR_DIR | Ruta opcional a un proyecto nuklear proporcionado por el usuario | |
DILIGENT_MSVC_COMPILE_OPTIONS | Opciones adicionales de compilación de MSVC para todas las configuraciones | |
DILIGENT_MSVC_DEBUG_COMPILE_OPTIONS | Opciones adicionales de compilación de MSVC para la configuración de depuración | |
DILIGENT_MSVC_RELEASE_COMPILE_OPTIONS | /GL /Arch: AVX2 | Opciones adicionales de compilación de MSVC para configuraciones de lanzamiento |
DILIGENT_CLANG_COMPILE_OPTIONS | Opciones adicionales de compilación de clang para todas las configuraciones | |
DILIGENT_CLANG_DEBUG_COMPILE_OPTIONS | Opciones adicionales de compilación de clang para la configuración de depuración | |
DILIGENT_CLANG_RELEASE_COMPILE_OPTIONS | -mavx2 | Opciones adicionales de compilación de Clang para configuraciones de lanzamiento |
DILIGENT_USD_PATH | Ruta a la carpeta de instalación de USD |
Por defecto, todos los back-end disponibles en la plataforma actual están construidos. Para deshabilitar los back-end específicos, use las siguientes opciones: DILIGENT_NO_DIRECT3D11 , DILIGENT_NO_DIRECT3D12 , DILIGENT_NO_OPENGL , DILIGENT_NO_VULKAN , DILIGENT_NO_METAL , DILIGENT_NO_WEBGPU . WebGPU Backend está habilitado de forma predeterminada cuando se construye para la web. Para habilitarlo en otras plataformas, use DILIGENT_NO_WEBGPU=OFF . Las opciones se pueden configurar a través de CMake UI o desde la línea de comando como en el ejemplo a continuación:
cmake -D DILIGENT_NO_DIRECT3D11=TRUE -S . -B ./build/Win64 -G "Visual Studio 17 2022" -A x64
Además, los componentes individuales del motor se pueden habilitar o deshabilitar utilizando las siguientes opciones: DILIGENT_BUILD_TOOLS , DILIGENT_BUILD_FX , DILIGENT_BUILD_SAMPLES . Si solo desea construir el proyecto SampleBase , puede usar la opción DILIGENT_BUILD_SAMPLE_BASE_ONLY .
Por defecto, Vulkan Back-end está vinculado con Glslang que permite compilar sombreadores HLSL y GLSL para Spirv en el tiempo de ejecución. Si no se requiere una compilación de tiempo de ejecución, Glslang se puede deshabilitar con la opción DILIGENT_NO_GLSLANG CMake. Además, el soporte HLSL en backends no direct3D se puede deshabilitar con la opción DILIGENT_NO_HLSL . Habilitar las opciones reduce significativamente el tamaño de los binarios de back-end de Vulkan y OpenGL, lo que puede ser especialmente importante para las aplicaciones móviles.
Diligent Engine utiliza el formato de clang para garantizar un formato constante en toda la base del código. La validación se puede deshabilitar utilizando la opción DILIGENT_NO_FORMAT_VALIDATION CMake. Tenga en cuenta que cualquier solicitud de extracción fallará si se encuentran problemas de formato.
Diligent Engine utiliza una validación extensa que siempre está habilitada en la construcción de depuración. Algunas de las verificaciones pueden habilitarse en las configuraciones de lanzamiento configurando la opción DILIGENT_DEVELOPMENT CMake.
Para habilitar el soporte de eventos PIX, establezca DILIGENT_LOAD_PIX_EVENT_RUNTIME cmake bandera.
Para habilitar algunas características avanzadas en las GPU NVIDIA (como el soporte indirecto nativo de múltiples dibujos en Direct3D11), descargue NVAPI y establezca la variable DILIGENT_NVAPI_PATH CMake.
Diligent Engine utiliza múltiples bibliotecas de terceros. Si el archivo Cmake de una aplicación define cualquiera de esas bibliotecas, Diligent usará objetivos existentes. La aplicación deberá asegurarse de que la configuración de compilación sea compatible con Diligent.
Diligent Engine permite a los clientes personalizar la configuración de compilación al proporcionar un archivo de script de configuración que define las siguientes funciones opcionales de CMake:
custom_configure_build() - Define las propiedades globales de compilación como las configuraciones de compilación, los indicadores de compilación C/C ++, los indicadores de enlace, etc.custom_pre_configure_target() : define la configuración personalizada para cada objetivo en la compilación y se llama antes de que el sistema de compilación del motor comience a configurar el objetivo.custom_post_configure_target() : llamado después de que el sistema de compilación del motor haya configurado el objetivo para permitir que el cliente anule las propiedades establecidas por el motor. La ruta al script de configuración debe proporcionarse a través de la variable BUILD_CONFIGURATION_FILE al ejecutar cmake y debe ser relativo a la carpeta raíz cmake, por ejemplo:
cmake -D BUILD_CONFIGURATION_FILE=BuildConfig.cmake -S . -B ./build/Win64 -G "Visual Studio 17 2022" -A x64
Si se define, la función custom_configure_build() se llama antes de agregar cualquier objetivo de compilación. De forma predeterminada, CMake define las siguientes cuatro configuraciones: Debug, Release, RelWithDebinfo, Minsizerel. Si lo desea, puede definir sus propias configuraciones de compilación configurando CMAKE_CONFIGURATION_TYPES Variable. Por ejemplo, si desea tener solo dos configuraciones: debug y ReleaSEMT, agregue la siguiente línea a la función custom_configure_build() :
set (CMAKE_CONFIGURATION_TYPES Debug ReleaseMT CACHE STRING "Configuration types: Debug, ReleaseMT" FORCE ) El sistema de compilación debe conocer la lista de configuraciones de depuración y liberación (optimizada), por lo que las siguientes dos variables también deben establecerse cuando se define la variable CMAKE_CONFIGURATION_TYPES :
set (DEBUG_CONFIGURATIONS DEBUG CACHE INTERNAL "" FORCE )
set (RELEASE_CONFIGURATIONS RELEASEMT CACHE INTERNAL "" FORCE ) Tenga en cuenta que debido a los detalles de CMake, los nombres de configuración enumerados en DEBUG_CONFIGURATIONS y RELEASE_CONFIGURATIONS deben ser capitalizados .
Si define cualquier configuración que no sea cuatro CMake estándar, también debe establecer las siguientes variables, para cada nueva configuración:
CMAKE_C_FLAGS_<Config> - C Compilar BanderasCMAKE_CXX_FLAGS_<Config> - C ++ compilar banderasCMAKE_EXE_LINKER_FLAGS_<Config> - Banderas de enlace ejecutableCMAKE_SHARED_LINKER_FLAGS_<Config> - banderas de enlace de biblioteca compartidaPor ejemplo:
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 )A continuación se muestra un ejemplo de función 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 () Si se define, custom_pre_configure_target() se requiere para cada objetivo creado por el sistema de compilación y permite configurar propiedades específicas del objetivo.
Por defecto, el sistema de compilación establece algunas propiedades de destino. Si custom_pre_configure_target() establece todas las propiedades requeridas, puede decirle al sistema de compilación que no se requiere un procesamiento adicional al configurar TARGET_CONFIGURATION_COMPLETE Parent Spope Variable a TRUE :
set (TARGET_CONFIGURATION_COMPLETE TRUE PARENT_SCOPE ) El siguiente es un ejemplo de función 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 el cliente solo necesita anular algunas configuraciones, puede definir la función custom_post_configure_target() que se llama después de que el motor haya completado la configuración del destino, por ejemplo:
function (custom_post_configure_target TARGET )
set_target_properties ( ${TARGET} PROPERTIES
CXX_STANDARD 17
)
endfunction ()Consulte esta página. Además, los tutoriales y las muestras que se enumeran a continuación es un buen lugar para comenzar.
La notación del estado de renderización diligente es un lenguaje basado en JSON que describe sombreadores, estados de tubería, firmas de recursos y otros objetos en una forma conveniente, por ejemplo, por ejemplo:
{
"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 "
}
]
}Los archivos JSON se pueden analizar dinámicamente en el momento de ejecución. Alternativamente, una aplicación puede usar la herramienta Packager para preprocesar descripciones de tuberías (compilar sombreadores para plataformas de destino, definir diseños de recursos internos, etc.) en un archivo binario optimizado para el rendimiento de carga en tiempo de ejecución.
| Tutorial | Captura de pantalla | Descripción |
|---|---|---|
| 01 - Hola Triángulo |  | Este tutorial muestra cómo renderizar un triángulo simple usando API de motor diligente. |
| 02 - Cubo |  | Este tutorial demuestra cómo representar un objeto 3D real, un cubo. Muestra cómo cargar sombreadores de archivos, crear y usar vértices, índice y buffers uniformes. |
| 03 - Textura |  | Este tutorial demuestra cómo aplicar una textura a un objeto 3D. Muestra cómo cargar una textura del archivo, crear objeto de enlace de recursos de sombreador y cómo probar una textura en el sombreador. |
| 03 - Texturing -C | | Este tutorial es idéntico al tutorial03, pero se implementa utilizando C API. |
| 03 - Texturing -dotnet | | Este tutorial demuestra cómo usar la API de motor diligente en aplicaciones .NET. |
| 04 - Instancing |  | Este tutorial demuestra cómo usar Instancing para representar múltiples copias de un objeto utilizando una matriz de transformación única para cada copia. |
| 05 - Matriz de textura |  | Este tutorial demuestra cómo combinar la instancia con matrices de textura para usar una textura única para cada instancia. |
| 06 - múltiples lectura |  | Este tutorial muestra cómo generar listas de comandos en paralelo desde múltiples hilos. |
| 07 - sombreador de geometría |  | Este tutorial muestra cómo usar Geometry Shader para representar una estructura alámbrica suave. |
| 08 - Teselación |  | Este tutorial muestra cómo usar la teselación de hardware para implementar un algoritmo de renderizado de terreno adaptativo simple. |
| 09 - Quads |  | Este tutorial muestra cómo representar múltiples quads 2D, con frecuencia cambiando texturas y modos de mezcla. |
| 10 - transmisión de datos |  | Este tutorial muestra la estrategia de mapeo de búfer dinámico utilizando MAP_FLAG_DISCARD y MAP_FLAG_DO_NOT_SYNCHRONIZE Flags para transmitir eficientemente cantidades variables de datos a GPU. |
| 11 - Actualizaciones de recursos |  | Este tutorial demuestra diferentes formas de actualizar buffers y texturas en un motor diligente y explica importantes detalles internos e implicaciones de rendimiento relacionadas con cada método. |
| 12 - Renderizar objetivo |  | Este tutorial demuestra cómo convertir un cubo 3D en un objetivo de renderizado fuera de pantalla y hacer un efecto simple de postprocesamiento. |
| 13 - Mapa de sombras |  | Este tutorial demuestra cómo representar sombras básicas usando un mapa de sombra. |
| 14 - COMPUTE SHADER |  | Este tutorial muestra cómo implementar un sistema de simulación de partículas simple utilizando sombreadores de cómputo. |
| 15 - Múltiples ventanas |  | Este tutorial demuestra cómo usar un motor diligente para renderizar a múltiples ventanas. |
| 16 - Recursos sin atiero |  | Este tutorial muestra cómo implementar recursos sin Bindless, una técnica que aprovecha la función de indexación de recursos de sombreadores dinámicos habilitados por las API de próxima generación para mejorar significativamente el rendimiento de la representación. |
| 17 - MSAA |  | Este tutorial demuestra cómo usar anti-aliasing múltiple (MSAA) para que los bordes geométricos se vean más suaves y más temporalmente estables. |
| 18 - Consultas |  | Este tutorial demuestra cómo usar consultas para recuperar varias información sobre la operación de la GPU, como el número de primitivas presentadas, la duración del procesamiento de comandos, etc. |
| 19 - Renderiza pases |  | Este tutorial demuestra cómo usar la API de Renders Pass para implementar sombreado diferido simple. |
| 20 - Sombreador de malla |  | Este tutorial demuestra cómo utilizar la amplificación y los sombreadores de malla, las nuevas etapas programables, para implementar View Frustum Culling y Object LOD Cálculo en la GPU. |
| 21 - trazado de rayos |  | Este tutorial demuestra los conceptos básicos del uso de la API de trazado de rayos en motor diligente. |
| 22 - Representación híbrida |  | Este tutorial demuestra cómo implementar un renderizador híbrido simple que combine la rasterización con el trazado de rayos. |
| 23 - colas de comando |  | Este tutorial demuestra cómo usar múltiples colas de comandos para realizar la representación en paralelo con operaciones de copia y cómputo. |
| 24 - sombreado de tasa variable |  | Este tutorial demuestra cómo usar sombreado de velocidad variable para reducir la carga de sombreado de píxeles. |
| 25 - Renderizador de estatal |  | Este tutorial muestra cómo crear y archivar los estados de tubería con la herramienta Render State Packager Offline en el ejemplo de un trazador de ruta simple. |
| 26 - Renderice caché de estado |  | Este tutorial expande la técnica de rastreo de ruta implementada en un tutorial anterior y demuestra cómo usar el caché de estado de renderizado para guardar los estados de tuberías creados en el tiempo de ejecución y cargarlos cuando se inicia la aplicación. |
| 27 - postprocesamiento |  | Este tutorial demuestra cómo usar los efectos posteriores al procesamiento del módulo DiligentFX. |
| Muestra | Captura de pantalla | Descripción |
|---|---|---|
| Muestra de atmósfera |  | Esta muestra demuestra cómo integrar el efecto de postprocesamiento de dispersión de luz epipolar en una aplicación para representar la atmósfera física. |
| Demostración de GLFW |  | Este mini-juego de laberinto demuestra cómo usar GLFW para crear ventana y manejo de la entrada del teclado y el mouse. |
| Visor GLTF |  | Esta muestra demuestra cómo usar el cargador de activos y el renderizador PBR para cargar y renderizar modelos GLTF. |
| Visor de USD |  | Esta muestra demuestra cómo representar archivos USD usando Hydrogent, una implementación de la API de representación HYDRA en motor diligente. |
| Oscuridad |  | Esta muestra demuestra cómo usar el componente de sombreado para representar sombras de alta calidad. |
| Querida demostración |  | Esta muestra demuestra la integración del motor con la biblioteca de Dear Imgui UI. |
| Demostración nuklear |  | Esta muestra demuestra la integración del motor con la biblioteca de UI Nuklear. |
| Hola ar |  | Esta muestra demuestra cómo usar el motor diligente en una aplicación básica de Android AR. |
| Asteroides |  | Esta muestra es un punto de referencia de rendimiento que representa 50,000 asteroides texturizados únicos y permite comparar el rendimiento de diferentes modos de representación. |
| Demostración de integración de la unidad |  | Este proyecto demuestra la integración del motor diligente con Unity. |
La funcionalidad de representación de alto nivel se implementa mediante el módulo DiligentFX. Los siguientes componentes ya están disponibles:
 | |
 |  |
Anti-aliasing temporal
Mapeo de tono Utilidades de sombreador
Agradeceríamos si pudiera enviarnos un enlace en caso de que su producto use motor diligente.
Sistema de visualización de terrenos a gran escala para simuladores de capacitación piloto por Elbit Systems
Lumenrt: un software de visualización y modelado de realidad por Bentley Systems
Godus: un juego de sandbox galardonado de 22cans
Gráficos VRMAC: una biblioteca de gráficos multiplataforma para .NET 
Diligent Engine es un proyecto abierto que todos pueden ser utilizados libremente por todos. 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
