Diligent Engine - v2.5.6

This release significantly enhances Diligent Engine by introducing the WebGPU backend, making the web a first-class citizen in the Diligent Engine ecosystem. WebGPU is a modern graphics API specifically designed for the web, offering several key advantages over WebGL. These enhancements are now fully leveraged by Diligent Engine, providing:

• Lower Overhead and Higher Rendering Performance: WebGPU reduces CPU overhead, allowing more efficient use of hardware resources, leading to smoother and faster rendering.
• Support for Compute Shaders: Unlike WebGL, WebGPU natively supports compute shaders, enabling more complex and parallel computations directly on the GPU.
• Improved API Design: WebGPU offers a more streamlined and explicit API, reducing ambiguity and making it easier for developers to harness the full power of modern GPUs.
• Enhanced Resource Management: WebGPU provides better control over memory and resource management, leading to more predictable performance and reduced latency.

In addition to the WebGPU backend, this release also introduces asynchronous shader compilation. This feature allows shaders to be compiled in parallel, preventing the rendering thread from being blocked during compilation. Asynchronous shader compilation is fully supported in the WebGPU backend, ensuring a smooth and responsive experience even during complex rendering tasks.

We are also excited to announce that samples are now available to run directly on the web. You can explore these samples at the Diligent Engine Samples Website (https://diligentgraphics.github.io/). This makes it easier than ever to see the power of Diligent Engine in action, directly in your browser.

API Changes

• Implemented WebGPU backend
  • Added EngineWebGPUCreateInfo
  • Added IEngineFactoryWebGPU interface
  • Added RENDER_DEVICE_TYPE_WEBGPU, SHADER_SOURCE_LANGUAGE_WGSL, SHADER_VARIABLE_FLAG_UNFILTERABLE_FLOAT_TEXTURE_WEBGPU,
    SHADER_VARIABLE_FLAG_NON_FILTERING_SAMPLER_WEBGPU enum values
  • Added WEB_GPU_BINDING_TYPE enum, WebGPUResourceAttribs struct, and
    WebGPUResourceAttribs WebGPUAttribs member to PipelineResourceDesc struct
  • Added WebGPU-specific interfaces (IRenderDeviceWebGPU, IDeviceContextWebGPU, etc.)
• Enabled asynchronous shdare and pipeline state compilation (API255001)
  • Added AsyncShaderCompilation render device feature
  • Added pAsyncShaderCompilationThreadPool and NumAsyncShaderCompilerThreads members to EngineCreateInfo struct
  • Added SHADER_COMPILE_FLAG_ASYNCHRONOUS and PSO_CREATE_FLAG_ASYNCHRONOUS flags
  • Added SHADER_STATUS and PIPELINE_STATE_STATUS enums
  • Added IShader::GetStatus and IPipelineState::GetStatus methods

Diligent Engine - v2.5.5

This release packs a lot of new features and improvements.

New High-Level Rendering components

• Post Processing effects:
  • Screen-Space Reflections
    
  • Screen-Space Ambient Occlusion
    
  • Depth of Field
    
  • Bloom
    
  • Temporal Anti-Aliasing
• Hydrogent, an implementation of the Hydra rendering API in Diligent Engine.
  
• PBR Material Improvements:
  • Clear-Coat
    
  • Sheen (aka fuzz)
    
  • Iridescence (aka thin layer)
    
  • Anisotropy
    

New Samples and Tutorials

• Tutorial27 - Post Processing
  

• USD Viewer
  

API Changes

• Added MultiDraw and MultiDrawIndexed commands (API254006)
• Added SerializationDeviceGLInfo struct (API254005)
  • The ValidateShaders member allows disabling time-consuming shader compilation
• Replaced AnisotropicFilteringSupported member of SamplerProperties struct with MaxAnisotropy (API254004)
• Added TextureSubresourceViews device feature (API254003)
• Added device context rendering statistics (API254002)
  • Added DeviceContextStats struct
  • Added IDeviceContext::ClearStats and IDeviceContext::GetStats methods
• IDeviceContext::TransitionShaderResources: removed unused pPipelineState parameter (API254001)

Diligent Engine - v2.5.4

Besides a number of API improvements (such as read-only depth buffers, texture component swizzle, shader constant buffer reflection) and bug fixes, this release enables the Dot Net support. Applications targeting Dot Net can use the NuGet package that implements the Core Diligent API.

A new tutorial demonstrates how to use the Diligent Engine in a Dot Net application.

API Changes

• Use thread group count X/Y/Z for mesh draw commands (API253012)
• Added ShaderMacroArray struct (API253011)
  • The Macros member of ShaderCreateInfo struct is now of type ShaderMacroArray
• Replaced ResourceMappingDesc with ResourceMappingCreateInfo (API253010)
  • Use ResourceMappingCreateInfo::NumEntries to define the number of entries instead of the trailing null entry
• Removed ShaderCreateInfo::ppConversionStream (API253009)
• Removed ppCompilerOutput member of the ShaderCreateInfo struct and added it as parameter to the IRenderDevice::CreateShader method (API253008)
• Added IPipelineStateGL::GetGLProgramHandle and IShaderGL::GetGLShaderHandle methods (API253007)
• Enabled read-only depth-stencil buffers (API253006)
  • Added TEXTURE_VIEW_READ_ONLY_DEPTH_STENCIL view type
  • Added UseReadOnlyDSV member to GraphicsPipelineDesc struct
• Added PSO_CACHE_FLAGS enum and PipelineStateCacheDesc::Flags member (API253005)
• Archiver and render state cache: added content version (API253004)
• Added RenderDeviceShaderVersionInfo struct and RenderDeviceInfo::MaxShaderVersion member (API253003)
• Added texture component swizzle (API253002)
  • Added TEXTURE_COMPONENT_SWIZZLE enum and TextureComponentMapping struct
  • Added Swizzle member to TextureViewDesc struct
  • Added TextureComponentSwizzle member to DeviceFeatures struct
• Added shader constant buffer reflection API (API253001)
  • Added SHADER_CODE_BASIC_TYPE and SHADER_CODE_VARIABLE_CLASS enums
  • Added ShaderCodeVariableDesc and ShaderCodeBufferDesc structs
  • Added IShader::GetConstantBufferDesc method

Diligent Engine - v2.5.3

This release introduces a new major feature - render state cache.

The cache object (IRenderStateCache) provides methods to create shaders and pipeline states that are identical to the methods of the render device. However, for each call the cache attempts to find the object data (e.g. compiled shader bytecode, pipeline state data etc.) to avoid expensive operations (such as shader compilation). If the data is not found, the object is created and its data is added to the cache. The cache data can be requested from the cache, stored in a file and loaded next time.

Another major capability of the render state cache is hot shader reloading. The cache stores all data required to create shader objects, and when Reload method is called, the cache automatically detects which shaders need to be recompiled and which pipeline states need to be updated. The pipelines are updated transparently for the application.

Tutorials

Two new tutorials have been added.

Tutorial 25 - Render State Packager shows how to create and archive pipeline states with the render state packager off-line tool on the example of a simple path tracer.

Tutorial 26 - Render State Cache expands the path tracing technique implemented in previous tutorial and demonstrates how to use the render state cache to save pipeline states created at run time and load them when the application starts.

API Changes

• Added RENDER_STATE_CACHE_LOG_LEVEL enum, replaced EnableLogging member of RenderStateCacheCreateInfo struct with LoggingLevel (API252009)
• Added IPipelineResourceSignature::CopyStaticResources and IPipelineState::CopyStaticResources methods (API252008)
• Added render state cache (IRenderStateCache interface and related data types) (API252007)
• Moved UseCombinedTextureSamplers and CombinedSamplerSuffix members from ShaderCreateInfo to ShaderDesc (API252006)
• Added IntanceLayerCount and ppInstanceLayerNames members to EngineVkCreateInfo struct (API252005)
• Added IgnoreDebugMessageCount and ppIgnoreDebugMessageNames to EngineVkCreateInfo struct (API252004)
• Refactored archiver API (removed IDeviceObjectArchive and IArchive; enabled dearchiver
  to load multiple archives to allow storing signatures and pipelines separately) (API252003)
• Added SET_SHADER_RESOURCES_FLAGS enum and Flags parameter to IShaderResourceVariable::Set
  and IShaderResourceVariable::SetArray methods (API252002)
• Added primitive topologies with adjacency (API252001)

Diligent Engine - v2.5.2

This release introduces an API for packaging render state objects (shaders, pipeline states, resource singatures, render passes) into archives. An object archive contains data optimized for run-time loading performance (shaders are compiled into optimized byte code and patched to match resource signatures, if necessary; internal pipeline resource layouts are initialized; all objects are verified for compatibility and correctness etc.). One archive may contain data for multiple backends (e.g. Direct3D12, Vulkan, OpenGL).

The two key new interfaces are IArchiver that packs resource states into an archive, and IDearchiver that unpacks the states from the archive at run time.

This release also introduces Diligent Render State Notation, a JSON-based language that describes shaders, pipeline states, resource signatures and other objects in a convenient form, e.g.:

{
    "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"
                },
            },
            "PSODesc": {
                "Name": "My Pipeline State",
                "PipelineType": "GRAPHICS"
            },
            "pVS": "My Vertex shader",
            "pPS": "My Pixel shader"
        }
    ]
}

Render state notation files can be parsed and loaded dynamically at run time. Alternatively, an application can use a packaging tool to preprocess pipeline descriptions (compile shaders for target platforms, define internal resource layouts, etc.) into archives off-line.

Among other improvements are bug fixes, pipeline state cache support and samplers with unnormalized coordinates.

Diligent Engine - v2.5.1

This release introduces the following major features:

• Variable rate shading gives applications control over the frequency at which pixel shading is performed, allowing applications to trade quality for performance and power savings.
• Sparse (aka partially resident or tiled) resources are large virtual resources only partially baked by the physical memory. Spare resources are very useful for handling large scenes such as open environments, terrain, in mega texturing techniques, etc.
• Emscripten platform support allows applications built with Diligent Engine to run in web browsers.

API Changes

• Added subsampled render targets for VRS (API Version 250011)
• Added sparse resources (API Version 250010)
• Updated API to use 64bit offsets for GPU memory (API Version 250009)
• Reworked draw indirect command attributes (moved buffers into the attribs structs), removed DrawMeshIndirectCount (API Version 250008)
• Enabled indirect multidraw commands (API Version 250007)
• Enabled variable rate shading (API Version 250006)
• Added TransferQueueTimestampQueries feature (API Version 250005)
• Added RESOURCE_STATE_COMMON state; added STATE_TRANSITION_FLAGS enum and replaced
  StateTransitionDesc::UpdateResourceState with STATE_TRANSITION_FLAGS Flags (API Version 250004)
• Added ComputeShaderProperties struct (API Version 250003)
• Added IShaderResourceBinding::CheckResources method and SHADER_RESOURCE_VARIABLE_TYPE_FLAGS enum (API Version 250002)
• Removed IShaderResourceVariable::IsBound with IShaderResourceVariable::Get (API Version 250001)

Samples and tutorials

New Tutorial23 - Command Queues demonstrates how to use multiple command queues to perform rendering in parallel with copy and compute operations.

Another new Tutorial24 - Variable rate shading demonstrates how to use variable rate shading to reduce the pixel shading load.

Diligent Engine - v2.5

A major release that introduces a number of significant improvements:

• Pipeline resource signatures enable applications to define explicit shader resource layouts that allow sharing shader resource binding objects between different pipeline states.
• Multiple immediate contexts is an abstraction over multiple command queues that enables e.g. async compute and parallel rendering.
• Inline ray-tracing is a powerful extension to ray tracing that allows casting rays from regular shaders (pixel, compute, etc.).
• Ray tracing on Metal is now also supported by Diligent Engine.
• Debug groups improve debugging and profiling experience.
• Wave operations enable sharing data between threads in one shader thread group.
• Tile shaders is a special type of shader currently only available on Metal that is similar to compute shader, but processes on-chip tile memory.
• Memoryless framebuffer attachments enable memory savings on mobile platforms.

API Changes

• Added MISC_TEXTURE_FLAG_MEMORYLESS flag (API Version 250000)
• Removed RayTracing2 device feature and added RAY_TRACING_CAP_FLAGS enum (API Version 240099)
• Added tile shaders (API Version 240098)
  • Added PIPELINE_TYPE_TILE and SHADER_TYPE_TILE enum values
  • Added TileShaders device feature
  • Added TilePipelineDesc, TilePipelineStateCreateInfo and DispatchTileAttribs structs
  • Added IRenderDevice::CreateTilePipelineState, IPipelineState::GetTilePipelineDesc,
    IDeviceContext::DispatchTile and IDeviceContext::GetTileSize methods
• Removed GetNextFenceValue, GetCompletedFenceValue, and IsFenceSignaled methods from IRenderDeviceD3D12 and IRenderDeviceVk interfaces
  as they are now in ICommandQueue interface (API Version 240097)
• Added ICommandQueue interface, IDeviceContext::LockCommandQueue and IDeviceContext::UnlockCommandQueue methods,
  removed fence query methods from IRenderDeviceVk, IRenderDeviceD3D12, and IRenderDeviceMtl (API Version 240096)
• Added multiple immediate device contexts and refactored adapter queries (API Version 240095)
  • CommandQueueMask member of TextureDesc, BufferDesc, PipelineStateDesc, TopLevelASDesc,
    and BottomLevelASDesc, was renamed to ImmediateContextMask
  • Added pContext member to TextureData and BufferData structs to indicate which context to
    use for initialization.
  • Removed GetDeviceCaps and GetDeviceProperties IDeviceContext methods and added
    GetDeviceInfo and GetAdapterInfo methods; added RenderDeviceInfo struct.
  • Renamed SamplerCaps to SamplerProperties, TextureCapstoTextureProperties; added BufferProperties, RayTracingProperties, and MeshShaderProperties` structs
  • Removed DeviceLimits struct
  • Removed DeviceCaps struct and moved its members to GraphicsAdapterInfo and RenderDeviceInfo structs
  • Added NativeFence to DeviceFeatures
  • Added CommandQueueInfo struct
  • Added COMMAND_QUEUE_TYPE and QUEUE_PRIORITY enums
  • Renamed ShaderVersion struct to Version
  • Reworked GraphicsAdapterInfo struct
  • Added ImmediateContextCreateInfo struct and pImmediateContextInfo, NumImmediateContexts members to EngineCreateInfo struct
  • Added AdapterId and GraphicsAPIVersion members to EngineCreateInfo struct
  • Removed DIRECT3D_FEATURE_LEVEL enum
  • Added FENCE_TYPE enum
  • Renamed IFence::Reset to IFence::Signal; added IFence::Wait method
  • Added IEngineFactory::EnumerateAdapters method
  • Added DeviceContextDesc struct and IDeviceContext::GetDesc method
  • Added IDeviceContext::Begin method, renamed IDeviceContext::SignalFence to IDeviceContext::EnqueueSignal
• Added debug annotations IDeviceContext::BeginDebugGroup, IDeviceContext::EndDebugGroup,
  IDeviceContext::InsertDebugLabel (API Version 240095)
• Added DefaultVariableMergeStages member to PipelineResourceLayoutDesc struct (API240094)
• Added IShaderResourceVariable::SetBufferRange and IShaderResourceVariable::SetBufferOffset methods,
  added DeviceLimits struct (API240093)
• Updated API to allow explicitly flushing/invlidating mapped buffer memory range :
  added MEMORY_PROPERTIES enum, IBuffer::GetMemoryProperties(), IBuffer::FlushMappedRange(),
  and IBuffer::InvalidateMappedRange() methods (API240092)
• Added IDeviceContext::SetUserData() and IDeviceContext::GetUserData() methods (API240091)
• Added SHADER_VARIABLE_FLAGS enum and SHADER_VARIABLE_FLAGS Flags member to ShaderResourceVariableDesc struct (API240090)
• Reworked validation options (API240089)
  • Added VALIDATION_FLAGS and D3D12_VALIDATION_FLAGS enums; renamed D3D11_DEBUG_FLAGS to D3D11_VALIDATION_FLAGS
  • Added VALIDATION_FLAGS ValidationFlags and bool EnableValidation to EngineCreateInfo
  • Added D3D12_VALIDATION_FLAGS D3D12ValidationFlags to EngineD3D12CreateInfo; removed EnableDebugLayer, EnableGPUBasedValidation,
    BreakOnError, BreakOnCorruption
  • Added VALIDATION_LEVEL enum and SetValidationLevel() create info structs' helper functions
  • Removed EngineGLCreateInfo::CreateDebugContext member (it is replaced with EnableValidation)
• Added MtlThreadGroupSizeX, MtlThreadGroupSizeY, and MtlThreadGroupSizeZ members to
  DispatchComputeAttribs and DispatchComputeIndirectAttribs structs (API Version 240088)
• Added InstanceDataStepRate device feature (API Version 240087)
• Added WaveOp device feature (API Version 240086)
• Added UpdateSBT command (API Version 240085)
• Removed EngineD3D12CreateInfo::NumCommandsToFlushCmdList and EngineVkCreateInfo::NumCommandsToFlushCmdBuffer as flushing
  the context based on the number of commands is unreasonable (API Version 240084)
• Added pipeline resource signatures, enabled inline ray tracing, added indirect draw mesh command (API Version 240083)
• Replaced IDeviceContext::ExecuteCommandList() with IDeviceContext::ExecuteCommandLists() method that takes
  an array of command lists instead of one (API Version 240082)
• Added IDeviceObject::SetUserData() and IDeviceObject::GetUserData() methods (API Version 240081)

Samples and tutorials

New Tutorial 22 - Hybrid Rendering demonstrates how to implement a simple hybrid renderer that combines rasterization with ray tracing. The tutorial runs on DirectX12, Vulkan and Metal.

Diligent Engine - v2.4.g

API Changes

• Enabled ray tracing (API Version 240080)

• Added IDeviceContext::GetFrameNumber method (API Version 240079)

• Added ShaderResourceQueries device feature and EngineGLCreateInfo::ForceNonSeparablePrograms parameter (API Version 240078)

• Renamed USAGE_STATIC to USAGE_IMMUTABLE (API Version 240077)

• Renamed static samplers into immutable samplers (API Version 240076)

  • Renamed StaticSamplerDesc -> ImmutableSamplerDesc
  • Renamed PipelineResourceLayoutDesc::NumStaticSamplers -> PipelineResourceLayoutDesc::NumImmutableSamplers
  • Renamed PipelineResourceLayoutDesc::StaticSamplers -> PipelineResourceLayoutDesc::ImmutableSamplers

• Refactored pipeline state creation (API Version 240075)

  • Replaced PipelineStateCreateInfo with GraphicsPipelineStateCreateInfo and ComputePipelineStateCreateInfo
  • Replaced IRenderDevice::CreatePipelineState with IRenderDevice::CreateGraphicsPipelineState and IRenderDevice::CreateComputePipelineState
  • pVS, pGS, pHS, pDS, pPS, pAS, pMS were moved from GraphicsPipelineDesc to GraphicsPipelineStateCreateInfo
  • GraphicsPipelineDesc GraphicsPipeline was moved from PipelineStateDesc to GraphicsPipelineStateCreateInfo
  • pCS is now a member of ComputePipelineStateCreateInfo, ComputePipelineDesc was removed
  • Added IPipelineState::GetGraphicsPipelineDesc method

  Old API for graphics pipeline initialization:

  PipelineStateCreateInfo PSOCreateInfo;
  PipelineStateDesc&      PSODesc = PSOCreateInfo.PSODesc;
  
  PSODesc.GraphicsPipeline.pVS = pVS;
  PSODesc.GraphicsPipeline.pPS = pVS;
  // ...
  Device->CreatePipelineState(PSOCreateInfo, &pPSO);

  New API for graphics pipeline initialization:

  GraphicsPipelineStateCreateInfo PSOCreateInfo;
  // ...
  PSOCreateInfo.pVS = pVS;
  PSOCreateInfo.pPS = pVS;
  Device->CreateGraphicsPipelineState(PSOCreateInfo, &pPSO);

  Old API for compute pipeline initialization:

  PipelineStateCreateInfo PSOCreateInfo;
  PipelineStateDesc&      PSODesc = PSOCreateInfo.PSODesc;
  
  PSODesc.ComputePipeline.pCS = pCS;
  // ...
  Device->CreatePipelineState(PSOCreateInfo, &pPSO);

  New API for compute pipeline initialization:

  ComputePipelineStateCreateInfo PSOCreateInfo;
  
  PSOCreateInfo.pCS = pCS;
  Device->CreateComputePipelineState(PSOCreateInfo, &pPSO);

• Added ShaderInt8, ResourceBuffer8BitAccess, and UniformBuffer8BitAccess device features. (API Version 240074)

• Added ShaderFloat16, ResourceBuffer16BitAccess, UniformBuffer16BitAccess, and ShaderInputOutput16 device features. (API Version 240073)

Samples and Tutorials

• Added Tutorial21 - Ray Tracing

Diligent Engine - v2.4.f

API Changes

• Added UnifiedMemoryCPUAccess member to GraphicsAdapterInfo struct (API Version 240072)
  • An application should check allowed unified memory access types before creating unified buffers
• Added GPU vendor and memory size detection (API Version 240071)
  • Added ADAPTER_VENDOR enum
  • Added GraphicsAdapterInfo struct
  • Added GraphicsAdapterInfo AdapterInfo member to DeviceCaps struct
  • Removed ADAPTER_TYPE AdaterType from DeviceCaps struct
• Reworked texture format properties (API Version 240070)
  • Added RESOURCE_DIMENSION_SUPPORT enum
  • Reworked TextureFormatInfoExt struct
• Added option to disable/enable device features during initialization (API Version 240069)
  • Added DEVICE_FEATURE_STATE enum
  • Changed the types of members of DeviceFeatures struct from bool to DEVICE_FEATURE_STATE
  • Added DeviceFeatures Features member to EngineCreateInfo struct
• Enabled mesh shaders (API Version 240068)
  • Added PIPELINE_TYPE enum
  • Replaced IsComputePipline member of PipelineStateDesc struct with PIPELINE_TYPE PipelineType
  • Added new mesh shader types
  • Added mesh shader draw commands
• Added QUERY_TYPE_DURATION query type (API Version 240067)
• Added USAGE_UNIFIED usage type (API Version 240066)
• Added render passes (API Version 240065)
• Added CREATE_SHADER_SOURCE_INPUT_STREAM_FLAGS enum and IShaderSourceInputStreamFactory::CreateInputStream2 method (API Version 240064)
• Added ISwapChain::SetMaximumFrameLatency function (API Version 240061)
• Added EngineGLCreateInfo::CreateDebugContext member (API Version 240060)
• Added SHADER_SOURCE_LANGUAGE_GLSL_VERBATIM value (API Version 240059).
• Added GLBindTarget parameter to IRenderDeviceGL::CreateTextureFromGLHandle method (API Version 240058).

Samples and Tutorials

• Added HelloAR Android sample
• Added Tutorial19 - Render Passes
• Added Tutorial20 - Mesh Shader

Diligent Engine - v2.4.e

• Enabled Vulkan on Android
• Added C Interface

API Changes

• Added PreTransform parameter to swap chain description
• Added PipelineStateCreateInfo struct that is now taken by IRenderDevice::CreatePipelineState instead of PipelineStateDesc struct. Added PSO_CREATE_FLAGS enum
• Updated swap chain creation functions to use NativeWindow
• Added NativeWindow wrapper and replaced pNativeWndHandle and pDisplay members with it in EngineGLCreateInfo