DiligentEngine
v2.5.6
Uma moderna biblioteca gráfica 3D de plataforma cruzada e estrutura de renderização
O Diligent Engine é uma biblioteca de abstração gráfica de plataforma cruzada leve e uma estrutura de renderização. Ele foi projetado para aproveitar ao máximo o Direct3D12, Vulkan, Metal e WebGPU, enquanto suporta plataformas mais antigas via Direct3D11, OpenGL, OpenGles e WebGL. O Diligent Engine expõe a API de front-end comum e usa o HLSL como linguagem de sombreamento universal em todas as plataformas e renderizando back-ends. As representações de shader específicas da plataforma (GLSL, MSL, DX BYTECODE ou SPIRV) podem ser usadas com os back-end correspondentes. O mecanismo deve ser usado como subsistema gráfico em um mecanismo de jogo ou em qualquer outro aplicativo 3D. Ele é distribuído pela licença Apache 2.0 e é gratuito para usar.
| Plataforma | D3D11 | D3D12 | OpenGl/Gles | Vulkan | Metal | WebGPU | Construir status |
|---|---|---|---|---|---|---|---|
 Windows | ✔️ | ✔️ | ✔️ | ✔️ | - | ✔️ 3 |  |
 Janelas universais | ✔️ | ✔️ | - | - | - | - | |
 Linux | - | - | ✔️ | ✔️ | - | ✔️ 3 |  |
 Android | - | - | ✔️ | ✔️ | - | - |  |
 Macos | - | - | ✔️ | ✔️ 1 | ✔️ 2 | ✔️ 3 |  |
 iOS | - | - | ✔️ | ✔️ 1 | ✔️ 2 | - | |
 TvOS | - | - | - | ✔️ 1 | ✔️ 2 | - | |
 Emscriptten | - | - | ✔️ | - | - | ✔️ |  |
1 API Vulkan não é suportada nativamente nas plataformas MacOS, iOS e TvOS e requer uma implementação de portabilidade da Vulkan, como MoltenVK ou GFX-Portability.
2 Disponível sob licença comercial - entre em contato conosco para obter detalhes.
3 Requer uma implementação nativa do WebGPU, o Dawn é recomendado.
#if defined(_WIN32) ... #elif defined(LINUX) ... #elif defined(ANDROID) ...#if defined(D3D11) ... #elif defined(D3D12) ... #elif defined(OPENGL) ...Versões de API de nível baixo mínimo suportado:
Este é o repositório principal que contém quatro submódulos. Para obter o repositório e todos os submódulos, use o seguinte comando:
git clone --recursive https://github.com/DiligentGraphics/DiligentEngine.git
Ao atualizar o repositório existente, não se esqueça de atualizar todos os submódulos:
git pull
git submodule update --recursive
Também é uma boa ideia re-fazer o CMAKE e executar uma reconstrução limpa depois de obter a versão mais recente.
O repositório principal inclui os seguintes submódulos:
O motor diligente usa o CMake como uma ferramenta de construção de plataforma cruzada. Para começar a usar o CMake, faça o download do lançamento mais recente (3,20 ou posterior é necessário). Outro pré -requisito de construção é o intérprete Python (3,0 ou posterior é necessário). Se, depois de seguir as instruções abaixo, você tiver problemas de construção/execução, consulte a solução de problemas.
Construa pré -requisitos:
O suporte .NET requer .NET SDK 6.0 ou posterior.
Use a ferramenta CMake GUI ou da linha de comando para gerar arquivos de construção. Por exemplo, para gerar o Visual Studio 2022 Solução de 64 bits e arquivos de projeto na pasta Build/Win64 , navegue até a pasta raiz do mecanismo e execute o seguinte comando:
cmake -S . -B ./build/Win64 -G "Visual Studio 17 2022" -A x64
Você pode gerar solução Win32 que visa o Win8.1 SDK usando o seguinte comando:
cmake -D CMAKE_SYSTEM_VERSION=8.1 -S . -B ./build/Win64_8.1 -G "Visual Studio 17 2022" -A x64
Se você usar o Mingw, poderá gerar os arquivos Make usando o comando abaixo (observe que a funcionalidade será limitada e que o Mingw não é uma maneira recomendada de construir o mecanismo):
cmake -S . -B ./build/MinGW -D CMAKE_BUILD_TYPE=Release -G "MinGW Makefiles"
Para ativar as camadas de validação Vulkan, você precisará fazer o download do Vulkan SDK e adicionar variável de ambiente VK_LAYER_PATH que contém o caminho para o diretório de bin na pasta de instalação Vulkansdk.
Abra o arquivo DiligEntEngine.sln na pasta Build/Win64 , selecione Configuração e construa o mecanismo. Defina o projeto desejado como projeto de inicialização (por padrão, o GLTF Viewer será selecionado) e executá -lo.
Por padrão, aplicativos de amostra e tutorial mostrarão a caixa de diálogo Renderização de seleção de back -end. Use as seguintes opções de linha de comando para forçar o modo D3D11, D3D12, OpenGL ou Vulkan: - -mode D3D11 , - -mode D3D12 , -Mode GL ou -Mode VK . Se você deseja executar um aplicativo fora do ambiente do Visual Studio, a pasta de ativos do aplicativo deve ser definida como diretório de trabalho. (Para o Visual Studio, isso é configurado automaticamente pelo CMake). Como alternativa, você pode navegar até a pasta Build Target ou instalar e executar o executável a partir daí.
Para gerar arquivos de construção para a plataforma universal do Windows, você precisa definir as duas variáveis de cmake a seguir:
CMAKE_SYSTEM_NAME=WindowsStoreCMAKE_SYSTEM_VERSION=< Windows Version >Por exemplo, para gerar o Visual Studio 2022 Solução de 64 bits e arquivos de projeto na pasta Build/UWP64 , execute o seguinte comando da pasta raiz do mecanismo:
cmake -D CMAKE_SYSTEM_NAME=WindowsStore -D CMAKE_SYSTEM_VERSION=10.0 -S . -B ./build/UWP64 -G "Visual Studio 17 2022" -A x64
Defina o projeto desejado como projeto de inicialização (por padrão, o GLTF Viewer será selecionado) e executá -lo.
Por padrão, os aplicativos serão executados no modo D3D12. Você pode selecionar D3D11 ou D3D12 usando as seguintes opções da linha de comando: -Modo D3D11 , -Modo D3D12 .
NOTA: É possível gerar solução que segmente o Windows 8.1, definindo CMAKE_SYSTEM_VERSION = 8.1 Variável de cmake, mas não conseguirá construir, pois usará o conjunto de ferramentas do Visual Studio 2013 (V120) que não possui suporte adequado para C ++ 14.
Seu ambiente Linux precisa ser configurado para o desenvolvimento de C ++. Se já estiver, verifique se suas ferramentas C ++ estão atualizadas, pois o mecanismo diligente usa os modernos recursos de C ++ (Clang 10 ou posterior é recomendado).
Pode ser necessário instalar os seguintes pacotes:
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 o vulkan, você também precisará:
Para gerar arquivos para fazer a configuração de depuração, execute o seguinte comando cmake na pasta raiz do mecanismo:
cmake -S . -B ./build -G "Unix Makefiles" -DCMAKE_BUILD_TYPE="Debug"
Para construir o motor, execute o seguinte comando:
cmake --build ./build
No Ubuntu 23 e mais recente, ele pode travar se você não tiver o LBTInfo5 instalado, precisará adicioná -lo.
A pasta raiz do motor contém arquivos de configurações de código do Visual Studio que configuram o IDE para criar o mecanismo. Você pode executar aplicativos diretamente a partir do IDE. Para executar um aplicativo na linha de comando, a pasta de ativos do aplicativo deve ser o diretório atual.
Certifique -se de que sua máquina esteja configurada para o desenvolvimento do Android. Faça o download do Android Studio, instale e configure o NDK e o CMake e outras ferramentas necessárias. NDK R24 ou posterior é necessário. Se você não estiver usando a versão CMake, com o Android Studio, verifique se seus arquivos de construção estão configurados corretamente. Para verificar se seu ambiente está configurado corretamente, tente criar a amostra de bules e os tutoriais do Android Vulkan.
Diligentes abertos/pasta Android com o Android Studio para construir e executar tutoriais e amostras no Android.
Por padrão, os aplicativos serão executados no modo Vulkan. Para executá-los no modo Vulkan, adicione os seguintes sinalizadores de lançamento: --es mode gles (no Android Studio, vá para Run-> Editar Menu de Configurações)
Pré -requisitos:
Depois de clonar o repositório, execute o seguinte comando da pasta raiz do mecanismo para gerar o projeto Xcode:
cmake -S . -B ./build/MacOS -G "Xcode"
O projeto estará localizado na pasta build/MacOS .
Observe que se o CMake não encontrar o compilador, pode ser necessário executar o seguinte comando:
sudo xcode-select --reset
Por padrão, não há implementação vulkan no macOS. O motor diligente carrega vulkan dinamicamente e pode usar uma implementação de portabilidade da Vulkan, como Moltenvk ou GFX. Instale o vulkansdk e verifique se o seu sistema está configurado corretamente, conforme descrito aqui. Em particular, pode ser necessário definir as seguintes variáveis de ambiente (assumindo que o Vulkan SDK está instalado em /Users/MyName/VulkanSDK/1.3.290.0 e você deseja 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
Observe que as variáveis de ambiente definidas no shell não são vistas pelos aplicativos lançados no Launchpad ou em outra GUI da área de trabalho. Assim, para garantir que um aplicativo encontre bibliotecas Vulkan, ele precisa ser iniciado na linha de comando. Devido ao mesmo motivo, o arquivo do projeto Xcode também deve ser aberto no shell usando o comando open . Com as versões Xcode 7 e posterior, esse comportamento pode precisar ser ativado primeiro usando o seguinte comando:
defaults write com.apple.dt.Xcode UseSanitizedBuildSystemEnvironment -bool NO
Consulte esta página para obter mais detalhes.
DYLD_LIBRARY_PATH e LD_LIBRARY_PATH são ignoradas no macOS, a menos que a proteção da integridade do sistema seja desativada (que geralmente não é recomendada). Para que os executáveis encontrem a Biblioteca Vulkan, ela deve estar no RPath. Se a variável de ambiente VULKAN_SDK estiver definida e pontos para a localização correta, o Diligent Engine configurará o RPath para todos os aplicativos automaticamente.
Última Vulkan SDK Versão: 1.3.290.0.
Pré -requisitos:
Execute o comando abaixo da pasta raiz do mecanismo para gerar o projeto Xcode configurado para a compilação iOS:
cmake -S . -B ./build/iOS -DCMAKE_SYSTEM_NAME=iOS -G "Xcode"Se necessário, você pode fornecer o alvo de implantação do iOS (13.0 ou posterior é necessário), bem como outros parâmetros, por exemplo:
cmake -S . -B ./build/iOS -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_DEPLOYMENT_TARGET=13.0 -G "Xcode"iphonesimulator . Você também pode usar a variável CMAKE_OSX_ARCHITECTURES para especificar a arquitetura de destino, por exemplo:
cmake -S . -B ./build/iOSSim -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphonesimulator -DCMAKE_OSX_ARCHITECTURES=arm64 -G "Xcode" Abra o arquivo do projeto Xcode na pasta build/IOS e construa o mecanismo. Para executar os aplicativos em um dispositivo iOS, você precisará definir a equipe de desenvolvimento apropriada nas configurações do projeto.
Para ativar o Vulkan no iOS, baixe e instale o vulkansdk. Não existe um carregador vulkan no iOS e o motor diligente se vincula diretamente ao Moltenvk XCFramework (consulte o Guia de instalação Moltenvk) que implementa Vulkan no metal. Para ativar o Vulkan no motor diligente no iOS, especifique o caminho para o Vulkan SDK ao executar o CMake, por exemplo (assumindo que o Vulkan SDK está instalado em /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 padrão, o motor se vincula ao Moltenvk XCFramework localizado no Vulkan SDK. Se isso não for desejado ou um aplicativo desejar usar uma biblioteca específica, ele pode fornecer o caminho completo para a biblioteca via variável CMake MOLTENVK_LIBRARY .
Consulte o Guia do Usuário Moltenvk para obter mais informações sobre a instalação e o uso da Moltenvk.
Última Vulkan SDK Versão: 1.3.290.0.
Construa pré -requisitos:
Para ativar o caminho e outras variáveis de ambiente no terminal atual
source ${PATH_TO_EMSDK} /emsdk/emsdk_env.sh${PATH_TO_EMSDK}/emsdk/emsdk_env.bat em vez de source ${PATH_TO_EMSDK}/emsdk/emsdk_env.sh
Para gerar projeto, execute o seguinte comando cmake na pasta raiz do mecanismo:
emcmake cmake -S . -B ./build/Emscripten -G "Ninja"Para construir o motor, execute o seguinte comando:
cmake --build ./build/EmscriptenPara testar os aplicativos EMSCRIPTEN, execute um servidor web básico
cd ./build/Emscripten
python https_server.py Abra um navegador e navegue para http://localhost
Por exemplo, o tutorial do Hello Triangle estará disponível em
http://localhost/DiligentSamples/Tutorials/Tutorial01_HelloTriangle/Tutorial01_HelloTriangle.html
Para acessar o servidor de outro computador na rede local, use o servidor HTTPS. Para ativar isso, primeiro instale o módulo cryptography . Você pode fazer isso executando o seguinte comando:
pip install cryptographyPara iniciar o servidor HTTPS, use o seguinte comando:
python https_server.py --mode=httpsUse o protocolo HTTPS para abrir as páginas. Por exemplo:
https://localhost/DiligentSamples/Tutorials/Tutorial01_HelloTriangle/Tutorial01_HelloTriangle.html
Ao usar o servidor HTTPS, diferentemente do servidor HTTP, você pode encontrar o seguinte erro ao carregar a página: net::ERR_CERT_AUTHORITY_INVALID .
Existem duas maneiras de resolver esse problema:
Advanced e selecione Proceed to localhost (unsafe) .python https_server.py --mode=https --register Utilizamos as portas padrão para protocolos HTTP/HTTPS, 80 e 443 respectivamente. Se você já possui um servidor em execução nessas portas, poderá especificar um número de porta diferente usando o argumento --port e incluir o número da porta correspondente na URL após o endereço IP. Por exemplo:
http://localhost:${YOUR_PORT}/DiligentSamples/Tutorials/Tutorial01_HelloTriangle/Tutorial01_HelloTriangle.html
Diligent possui estrutura modular; portanto, para o seu projeto, você só pode usar os submódulos que implementam a funcionalidade necessária. O diagrama abaixo mostra as dependências entre os módulos.
Core
|
+------>Tools----------.
| | |
| V |
+------->FX---------. |
| | |
| V V
'----------------->Samples
Não se esqueça de inicializar recursivamente se você estiver adicionando repositórios diligentes como submódulos ao seu projeto.
Se o seu projeto usar o CMake, a adição de mecanismo diligente exige apenas algumas linhas de código. Suponha que a estrutura do diretório se pareça com a seguinte:
|
+-DiligentCore
+-HelloDiligent.cpp
Então as etapas a seguir precisam ser feitas:
add_subdirectory(DiligentCore)Abaixo está um exemplo de um arquivo 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() é uma função de conveniência que copia bibliotecas compartilhadas ao lado do executável para que o sistema possa encontrá -las e carregá -las. Por favor, dê uma olhada no início dos tutoriais para Windows e Linux.
Na maioria das plataformas, as bibliotecas de motores principais são construídas em versões estáticas e dinâmicas (por exemplo, Diligent-GraphicsEngineD3D12-static e Diligent-GraphicsEngineD3D12-shared ). Você pode escolher qual versão para vincular alterando o nome de destino no comando target_link_libraries() cmake. Ao vincular -se a bibliotecas dinâmicas, a macro ENGINE_DLL será definida e as bibliotecas precisarão ser carregadas em tempo de execução. Por exemplo, para o back -end Direct3D12:
# if ENGINE_DLL
// Load the dll and import GetEngineFactoryD3D12() function
auto GetEngineFactoryD3D12 = LoadGraphicsEngineD3D12();
# endif
auto * pFactoryD3D12 = GetEngineFactoryD3D12(); Ao usar a ligação estática, a macro ENGINE_DLL não será definida e a função GetEngineFactoryD3D12 estará estaticamente vinculada ao executável.
O arquivo sampleApp.cpp fornece um exemplo de como inicializar o mecanismo em diferentes plataformas usando vinculação estática ou dinâmica.
Você pode usar o FetchContent para baixar os módulos de motor diligente. A única ressalva é que você precisa especificar o diretório de origem para que cada módulo seja o mesmo que o nome do módulo, para que os arquivos de cabeçalho possam ser encontrados. Abaixo está um exemplo de um arquivo cmake que usa o 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)Se o seu projeto não usar cmake, é recomendável criar bibliotecas com cmake e adicione -as ao seu sistema de construção. Você pode baixar os artefatos de construção mais recentes do Github.
O diretório global de instalação do CMake é controlado pela variável cmake_intall_prefix. Observe que ele é o padrão para /usr/local no Unix e c:/Program Files/${PROJECT_NAME} no Windows, o que pode não ser o que você deseja. Use -D CMAKE_INSTALL_PREFIX=install para usar a pasta install local:
cmake -S . -B ./build/Win64 -D CMAKE_INSTALL_PREFIX=install -G "Visual Studio 17 2022" -A x64
Para instalar bibliotecas e arquivos de cabeçalho, execute o seguinte comando cmake na pasta Build:
cmake --build . --target installO Diretório de Instalação DiligentCore conterá tudo o necessário para integrar o mecanismo:
Uma maneira mais fácil é vincular -se a bibliotecas dinâmicas. Ao vincular estaticamente, você precisará listar o DiligentCore, bem como todas as bibliotecas de terceiros usadas pelo mecanismo. Além disso, você também precisará especificar bibliotecas de sistemas específicas da plataforma. Por exemplo, para a plataforma Windows, a lista de bibliotecas que seu projeto precisará se vincular pode ser assim:
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
Os cabeçalhos diligentes do motor exigem que uma das seguintes macros da plataforma seja definida como 1 : PLATFORM_WIN32 , PLATFORM_UNIVERSAL_WINDOWS , PLATFORM_ANDROID , PLATFORM_LINUX , PLATFORM_MACOS , PLATFORM_IOS .
Você pode controlar quais componentes do mecanismo você deseja instalar usando as seguintes opções cmake: DILIGENT_INSTALL_CORE , DILIGENT_INSTALL_FX , DILIGENT_INSTALL_SAMPLES e DILIGENT_INSTALL_TOOLS .
Outra maneira de integrar o mecanismo é gerar arquivos de construção (como projetos do Visual Studio) e adicioná -los ao seu sistema de construção. Construir A personalização descrita abaixo pode ajudar a ajustar as configurações para suas necessidades específicas.
As opções de cmake disponíveis estão resumidas na tabela abaixo:
| Opção | Valor padrão | Descrição |
|---|---|---|
DILIGENT_NO_DIRECT3D11 | Não | Não construa back -end direta3d11 |
DILIGENT_NO_DIRECT3D12 | Não | Não construa back -end direto3D12 |
DILIGENT_NO_OPENGL | Não | Não construa back -end do OpenGL |
DILIGENT_NO_VULKAN | Não | Não construa back -end vulkan |
DILIGENT_NO_METAL | Não | Não construa back -end de metal |
DILIGENT_NO_WEBGPU | Não | Não construa back -end da WebGPU |
DILIGENT_NO_ARCHIVER | Não | Não construa arquiver |
DILIGENT_NO_RENDER_STATE_PACKAGER | Não | Não crie a ferramenta Render Render State Packager |
DILIGENT_ENABLE_DRACO | Não | Ativar suporte de compressão DRACO no carregador GLTF |
DILIGENT_USE_RAPIDJSON | Não | Use o analisador Rapidjson no carregador GLTF |
DILIGENT_BUILD_TOOLS | Sim | Build Tools Module |
DILIGENT_BUILD_FX | Sim | Construir módulo FX |
DILIGENT_BUILD_SAMPLES | Sim | Construir módulo de amostras |
DILIGENT_BUILD_SAMPLE_BASE_ONLY | Não | Construa apenas o projeto de amostra e nenhuma outra amostra/tutoriais |
DILIGENT_BUILD_TESTS | Não | Construir testes de unidade |
DILIGENT_NO_GLSLANG | Não | Não construa Glslang e Spriv-Tools |
DILIGENT_NO_HLSL | Não | Desative o suporte HLSL em back-ends não-diretos |
DILIGENT_NO_FORMAT_VALIDATION | Sim | Desativar a validação de formatação do código -fonte |
DILIGENT_LOAD_PIX_EVENT_RUNTIME | Não | Ativar suporte a eventos PIX |
DILIGENT_NVAPI_PATH | Caminho para o nvapi sdk | |
DILIGENT_INSTALL_CORE | Sim | Instale o módulo principal |
DILIGENT_INSTALL_TOOLS | Sim | Instale o módulo de ferramentas |
DILIGENT_INSTALL_FX | Sim | Instale o módulo FX |
DILIGENT_INSTALL_SAMPLES | Sim | Instale o módulo de amostras |
DILIGENT_INSTALL_PDB | Não | Instale o banco de dados de depuração do programa |
DILIGENT_DEAR_IMGUI_PATH | Caminho opcional para um projeto de Dear Imgui fornecido pelo usuário | |
DILIGENT_ARGS_DIR | Caminho opcional para um projeto args fornecido pelo usuário | |
DILIGENT_NUKLEAR_DIR | Caminho opcional para um projeto nuclear fornecido pelo usuário | |
DILIGENT_MSVC_COMPILE_OPTIONS | Opções adicionais de compilação do MSVC para todas as configurações | |
DILIGENT_MSVC_DEBUG_COMPILE_OPTIONS | Opções adicionais de compilação do MSVC para configuração de depuração | |
DILIGENT_MSVC_RELEASE_COMPILE_OPTIONS | /GL /Arch: Avx2 | Opções adicionais de compilação do MSVC para configurações de liberação |
DILIGENT_CLANG_COMPILE_OPTIONS | Opções adicionais de compilação de clang para todas as configurações | |
DILIGENT_CLANG_DEBUG_COMPILE_OPTIONS | Opções adicionais de compilação de clang para configuração de depuração | |
DILIGENT_CLANG_RELEASE_COMPILE_OPTIONS | -mavx2 | Opções adicionais de compilação de clang para configurações de liberação |
DILIGENT_USD_PATH | Caminho para a pasta de instalação do USD |
Por padrão, todos os back-ends disponíveis na plataforma atual são construídos. Para desativar os back-end específicos, use as seguintes opções: DILIGENT_NO_DIRECT3D11 , DILIGENT_NO_DIRECT3D12 , DILIGENT_NO_OPENGL , DILIGENT_NO_VULKAN , DILIGENT_NO_METAL , DILIGENT_NO_WEBGPU . O back -end do WebGPU é ativado por padrão ao criar a Web. Para ativá -lo em outras plataformas, use DILIGENT_NO_WEBGPU=OFF . As opções podem ser definidas através da interface do usuário cmake ou da linha de comando, como no exemplo abaixo:
cmake -D DILIGENT_NO_DIRECT3D11=TRUE -S . -B ./build/Win64 -G "Visual Studio 17 2022" -A x64
Além disso, os componentes individuais do motor podem ser ativados ou desativados usando as seguintes opções: DILIGENT_BUILD_TOOLS , DILIGENT_BUILD_FX , DILIGENT_BUILD_SAMPLES . Se você deseja criar apenas um projeto SampleBase , poderá usar a opção DILIGENT_BUILD_SAMPLE_BASE_ONLY .
Por padrão, o back-end Vulkan está vinculado ao GlsLang que permite a compilação de shaders HLSL e GLSL no SPIRV no tempo de execução. Se a compilação em tempo de execução não for necessária, o GLSLANG poderá ser desativado com a opção DILIGENT_NO_GLSLANG CMAKE. Além disso, o suporte a HLSL nos backnds não-Direct3D pode ser desativado com a opção DILIGENT_NO_HLSL . A possibilidade das opções reduz significativamente o tamanho dos binários de back-end Vulkan e OpenGL, o que pode ser especialmente importante para aplicativos móveis.
O mecanismo diligente usa o formato Clang para garantir uma formatação consistente em toda a base de código. A validação pode ser desativada usando a opção DILIGENT_NO_FORMAT_VALIDATION CMAKE. Observe que qualquer solicitação de tração falhará se os problemas de formatação forem encontrados.
O Diligent Engine usa validação extensa que sempre está ativada na construção de depuração. Algumas das verificações podem ser ativadas nas configurações de liberação definindo a opção DILIGENT_DEVELOPMENT CMake.
Para ativar o suporte a eventos PIX, defina DILIGENT_LOAD_PIX_EVENT_RUNTIME CMAKE Sinalizador.
Para ativar alguns recursos avançados no NVIDIA GPUS (como o suporte indireto de vários desenhos nativos no Direct3D11), faça o download do NVAPI e defina a variável DILIGENT_NVAPI_PATH cmake.
O motor diligente usa várias bibliotecas de terceiros. Se o arquivo cMake de um aplicativo definir qualquer uma dessas bibliotecas, o Diligent usará as metas existentes. O aplicativo precisará garantir que as configurações de compilação sejam compatíveis com diligente.
O Diligent Engine permite que os clientes personalizem as configurações de construção, fornecendo arquivo de script de configuração que define as seguintes funções opcionais cmake:
custom_configure_build() - define propriedades globais de construção, como configurações de compilação, sinalizadores de compilação C/C ++, sinalizadores de link etc.custom_pre_configure_target() - Define Configurações personalizadas para todos os alvos da compilação e é chamado antes que o sistema de construção do mecanismo comece a configurar o destino.custom_post_configure_target() - chamado depois que o sistema de construção do mecanismo configurou o destino para permitir que o cliente substitua as propriedades definidas pelo mecanismo. O caminho para o script de configuração deve ser fornecido através da variável BUILD_CONFIGURATION_FILE ao executar o cmake e deve ser relativa à pasta raiz cmake, por exemplo:
cmake -D BUILD_CONFIGURATION_FILE=BuildConfig.cmake -S . -B ./build/Win64 -G "Visual Studio 17 2022" -A x64
Se definido, a função custom_configure_build() é chamada antes que qualquer destino de construção seja adicionado. Por padrão, o CMake define as quatro configurações a seguir: Debug, Release, Relwithdebinfo, MinsizeL. Se desejar, você pode definir suas próprias configurações de compilação definindo a variável CMAKE_CONFIGURATION_TYPES . Por exemplo, se você deseja ter apenas duas configurações: Debug e Releasemt, adicione a seguinte linha à função custom_configure_build() :
set (CMAKE_CONFIGURATION_TYPES Debug ReleaseMT CACHE STRING "Configuration types: Debug, ReleaseMT" FORCE ) O sistema de compilação precisa conhecer a lista de configurações de depuração e liberação (otimizada), para que as duas variáveis a seguir também devem ser definidas quando CMAKE_CONFIGURATION_TYPES é definido:
set (DEBUG_CONFIGURATIONS DEBUG CACHE INTERNAL "" FORCE )
set (RELEASE_CONFIGURATIONS RELEASEMT CACHE INTERNAL "" FORCE ) Observe que, devido às especificidades do CMake, os nomes de configuração listados em DEBUG_CONFIGURATIONS e RELEASE_CONFIGURATIONS devem ser capitalizados .
Se você definir qualquer configuração diferente de quatro cmake padrão, também precisará definir as seguintes variáveis, para cada nova configuração:
CMAKE_C_FLAGS_<Config> - c sinalizadores de compilaçãoCMAKE_CXX_FLAGS_<Config> - sinalizadores de compilamento C ++CMAKE_EXE_LINKER_FLAGS_<Config> - sinalizadores de link executáveisCMAKE_SHARED_LINKER_FLAGS_<Config> - sinalizadores de link da biblioteca compartilhadaPor exemplo:
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 )Abaixo está um exemplo da função 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 () Se definido, custom_pre_configure_target() é chamado para todos os alvos criados pelo sistema Build e permite configurar propriedades específicas do alvo.
Por padrão, o sistema de construção define algumas propriedades de destino. Se custom_pre_configure_target() definir todas as propriedades necessárias, ele pode dizer ao sistema de construção que nenhum processamento adicional é necessário definindo TARGET_CONFIGURATION_COMPLETE scope variável para TRUE :
set (TARGET_CONFIGURATION_COMPLETE TRUE PARENT_SCOPE ) A seguir, é apresentado um exemplo da função 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 () Se o cliente precisar substituir apenas algumas configurações, poderá definir a função custom_post_configure_target() , que é chamada depois que o mecanismo concluir a configuração do destino, por exemplo:
function (custom_post_configure_target TARGET )
set_target_properties ( ${TARGET} PROPERTIES
CXX_STANDARD 17
)
endfunction ()Consulte esta página. Além disso, tutoriais e amostras listados abaixo é um bom lugar para começar.
A notação do estado de renderização diligente é uma linguagem baseada em JSON que descreve shaders, estados de pipeline, assinaturas de recursos e outros objetos de uma forma conveniente, por exemplo:
{
"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 "
}
]
}Os arquivos JSON podem ser analisados dinamicamente no tempo de execução. Como alternativa, um aplicativo pode usar a ferramenta Packager para pré-processar descrições de pipeline (compilar shaders para plataformas de destino, definir layouts de recursos internos etc.) em um arquivo binário otimizado para o desempenho de carregamento em tempo de execução.
| Tutorial | Captura de tela | Descrição |
|---|---|---|
| 01 - Hello Triangle |  | Este tutorial mostra como renderizar o triângulo simples usando a API de mecanismo diligente. |
| 02 - Cubo |  | Este tutorial demonstra como renderizar um objeto 3D real, um cubo. Ele mostra como carregar shaders de arquivos, criar e usar buffers de vértice, índice e uniformes. |
| 03 - Textura |  | Este tutorial demonstra como aplicar uma textura a um objeto 3D. Ele mostra como carregar uma textura do arquivo, criar um objeto de ligação de recursos do shader e como amostrar uma textura no shader. |
| 03 - texture -c | | Este tutorial é idêntico ao Tutorial03, mas é implementado usando a API C. |
| 03 - DOTNET de textura | | Este tutorial demonstra como usar a API de mecanismo diligente em aplicativos .NET. |
| 04 - Instância |  | Este tutorial demonstra como usar a Instancing para renderizar várias cópias de um objeto usando matriz de transformação exclusiva para cada cópia. |
| 05 - Array de textura |  | Este tutorial demonstra como combinar instanciamento com matrizes de textura para usar textura exclusiva para todas as instâncias. |
| 06 - Multithreading |  | Este tutorial mostra como gerar listas de comando em paralelo a partir de vários threads. |
| 07 - Shader de geometria |  | Este tutorial mostra como usar o shader de geometria para renderizar o quadro de arame liso. |
| 08 - Tessellation |  | Este tutorial mostra como usar a teselação de hardware para implementar o algoritmo simples de renderização de terrenos adaptativos. |
| 09 - Quads |  | Este tutorial mostra como renderizar vários quads 2D, alternando frequentemente texturas e modos de mistura. |
| 10 - Transmissão de dados |  | Este tutorial mostra a estratégia de mapeamento de buffer dinâmico usando MAP_FLAG_DISCARD e MAP_FLAG_DO_NOT_SYNCHRONIZE Sinalizadores para transmitir com eficiência quantidades variadas de dados para a GPU. |
| 11 - Atualizações de recursos |  | Este tutorial demonstra maneiras diferentes de atualizar buffers e texturas no mecanismo diligente e explica detalhes internos importantes e implicações de desempenho relacionadas a cada método. |
| 12 - renderizar alvo |  | Este tutorial demonstra como renderizar um cubo 3D em um alvo de renderização fora da tela e fazer um efeito simples de pós-processamento. |
| 13 - Mapa das Sombras |  | Este tutorial demonstra como renderizar sombras básicas usando um mapa de sombras. |
| 14 - Calcule o shader |  | Este tutorial mostra como implementar um sistema de simulação de partículas simples usando shaders de computação. |
| 15 - Várias janelas |  | Este tutorial demonstra como usar o mecanismo diligente para renderizar para várias janelas. |
| 16 - Recursos sem ligação |  | Este tutorial mostra como implementar Recursos Bindless, uma técnica que aproveita o recurso de indexação de recursos dinâmicos de shader ativado pelas APIs de próxima geração para melhorar significativamente o desempenho da renderização. |
| 17 - MSAA |  | Este tutorial demonstra como usar anti-aliasing múltiplo (MSAA) para fazer com que as bordas geométricas pareçam mais suaves e mais temporariamente estáveis. |
| 18 - Consultas |  | Este tutorial demonstra como usar consultas para recuperar várias informações sobre a operação da GPU, como o número de primitivas renderizadas, duração do processamento de comando, etc. |
| 19 - Render Pass |  | Este tutorial demonstra como usar a API de renderização passa para implementar sombreamento diferido simples. |
| 20 - Shader de malha |  | Este tutorial demonstra como usar os shaders de amplificação e malha, os novos estágios programáveis, para implementar o cálculo da LOD de LOD de visualização Frustum e objeto na GPU. |
| 21 - rastreamento de raios |  | Este tutorial demonstra o básico do uso da API de rastreamento de raios no motor diligente. |
| 22 - renderização híbrida |  | Este tutorial demonstra como implementar um renderizador híbrido simples que combina rasterização com rastreamento de raios. |
| 23 - Filas de comando |  | Este tutorial demonstra como usar várias filas de comando para executar a renderização em paralelo com operações de cópia e computação. |
| 24 - sombreamento da taxa variável |  | Este tutorial demonstra como usar o sombreamento da taxa variável para reduzir a carga de sombreamento de pixels. |
| 25 - Render Packager State |  | Este tutorial mostra como criar e arquivar estados de oleoduto com a ferramenta off-line do Render State Packager no exemplo de um rastreador de caminho simples. |
| 26 - Renderizar o cache do estado |  | Este tutorial expande a técnica de rastreamento do caminho implementada no tutorial anterior e demonstra como usar o cache do estado de renderização para salvar os estados do pipeline criados no tempo de execução e carregá -los quando o aplicativo iniciar. |
| 27 - pós -processamento |  | Este tutorial demonstra como usar os efeitos de pós-processamento do módulo DiligentFX. |
| Amostra | Captura de tela | Descrição |
|---|---|---|
| Amostra de atmosfera |  | Esta amostra demonstra como integrar o efeito pós-processamento de espalhamento de luz epipolar em uma aplicação para tornar a atmosfera baseada fisicamente. |
| Demoção GLFW |  | Este mini-jogo do Maze demonstra como usar o GLFW para criar janela e manusear a entrada do teclado e do mouse. |
| Visualizador GLTF |  | Esta amostra demonstra como usar o carregador de ativos e o renderizador de PBR para carregar e renderizar modelos GLTF. |
| Visualizador do USD |  | Esta amostra demonstra como renderizar arquivos em USD usando hidrogente, uma implementação da API de renderização Hydra no motor diligente. |
| Sombras |  | Esta amostra demonstra como usar o componente de sombreamento para renderizar sombras de alta qualidade. |
| Caro demonstração de Imgui |  | Esta amostra demonstra a integração do mecanismo com a Dear Imgui UI Library. |
| Demonstração nuclear |  | Esta amostra demonstra a integração do mecanismo com a biblioteca de interface do usuário nuclear. |
| Olá ar |  | Esta amostra demonstra como usar o mecanismo diligente em um aplicativo básico do Android AR. |
| Asteróides |  | Este sample é um benchmark de desempenho que renderiza 50.000 asteróides texturizados exclusivos e permite comparar o desempenho de diferentes modos de renderização. |
| Demonstração de integração da unidade |  | Este projeto demonstra a integração do motor diligente com a unidade. |
A funcionalidade de renderização de alto nível é implementada pelo módulo Diligentfx. Os seguintes componentes estão agora disponíveis:
 | |
 |  |
Anti-aliasing temporal
Utilitários de shader de mapeamento de tom
Agradecemos se você pudesse nos enviar um link caso seu produto use mecanismo diligente.
Sistema de visualização de terrenos em larga escala para simuladores de treinamento piloto por sistemas Elbit
Lumenrt: um software de visualização e modelagem de realidade da Bentley Systems
Godus: um jogo de sandbox premiado por 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
