diligentgraphics/diligentcore

A modern cross-platform low-level graphics API

diligentcore's Issues

Make '_sampler' suffix configurable through shader creation attributes

Right now the suffix is hard-coded. To add flexibility, the suffix should be configurable through shader creation attributes.

Add support for Update Texture on DX12

Implement texture mapping

Use glslang to compile HLSL directly to SPIRV in Vulkan backend

This will avoid extra conversion from HLSL to GLSL

Add immediate context to BufferData / TextureData parameters

This will explicitly specify which command queue will be used to initialize the resource

Unhandled Exception every time ShaderResourceBinfing->GetVariable(#, #)->Set(TexSRV) is called.

Hello, every time I call mSRB->GetVariable(#, "#)->Set(Tex_SRV) an exception is thrown on every renderer.
I traced all of them to a "RefCntAutoPtr" constructer.

RefCntAutoPtr(IObject* pObj, const INTERFACE_ID& IID) noexcept
 :  m_pObject(nullptr)
 {
      if(pObj)
         pObj->QueryInterface( IID, reinterpret_cast<IObject**>(&m_pObject) );  //<<This Line
 }

The constructor is called from these location:

On D3D12.
On D3D11.
On Vulkan.

It is worth noting that I noticed every ITextureView I create has the same address in memory...

<thread> error when compiling from managed on VS2017

c:\program files (x86)\microsoft visual studio\2017\professional\vc\tools\msvc\14.13.26128\include\thread(8): fatal error C1189: #error: is not supported when compiling with /clr or /clr:pure.

Implement Metal back-end

The Metal back-end stub is located here

Support multiple windows

Allow creating multiple swap chains attached to different windows.

Incorrect include paths in GraphicsAccessories.h.

Hello, I noticed GraphicsAccessories.h includes depend on "Additional Include Directories", Which cause errors with engines who don't include those directories.

/// Defines graphics engine utilities
#include "GraphicsTypes.h"
#include "Shader.h"
#include "Texture.h"
#include "Buffer.h"
#include "RenderDevice.h"
#include "DebugUtilities.h"

Should be:

/// Defines graphics engine utilities
#include "../../GraphicsEngine/interface/GraphicsTypes.h"
#include "../../GraphicsEngine/interface/Shader.h"
#include "../../GraphicsEngine/interface/Texture.h"
#include "../../GraphicsEngine/interface/Buffer.h"
#include "../../GraphicsEngine/interface/RenderDevice.h"
#include "../../../Platforms/Basic/interface/DebugUtilities.h"

Imlement stream output

Add render pass object to the API

This will make Vulkan implementation more efficient

Add split barriers to the API

Add begin transition/end transition flags to StateTransitionDesc structure. In Vulkan backend, submit barrier at either begin or end stage.

Make allocators more efficient by taking Alignment as parameter

Return null instead of pointer to a dummy variable from SRB/Shader if the variable is not found

Make messages about unmapped dynamic buffers more verbose

Add option to bind samplers by index

Compiler Error C2440

Hi! I was trying to build DiligentCore and got "Compiler Error C2440" in few places in code.
'''
c:\diligentcore-master\primitives\interface\FormatString.h(68): error C2440: 'initializing': cannot convert from 'initializer list' to 'Diligent::MemorySizeFormatter'

C:\DiligentCore-master\Graphics\GraphicsEngineVulkan\src\VulkanUploadHeap.cpp(81): error C2440: 'initializing': cannot convert from 'initializer list' to 'Diligent::VulkanUploadHeap::UploadPageInfo'

'''

Only GL bakend was sucessfuly compiled all other are failed (

I'm use: VS2015, Win10, i7

Implement multiple command queues through multiple immediate contexts

Batch barriers in Vulkan backend

Shader creation isn't quite flexable.

Hello, I found great difficulty in implementing Diligent into my Engine due to its heavy abstraction of shader creation. Let me explain to you.
To create a shader we need only one thing (ShaderCreationAttribs) which hides all real data from the user/client.

A typical game engine does the following:
1- Compile shader from source, then translate it into other language if necessary (ex: HLSL to GLSL)
2- Reflect all data necessary.
3- Combine the compiled shader and its reflected data to a structure (aka ShaderBlob)
4- Create GPU shader in the graphical backend.

So the engine have full access to (Compiled shader, shader reflected data and the GPU shader program).
Diligent hides compiled shader and requires the user to query reflection data by IShader->GetVariable() which isn't really practical, a better implementation would be grouping all reflection data into a class.

Plus, Diligent require engines declare the type of a variable at the shader creation that makes things worse.

In my opinion shader creation should be separated to multiple stages/functions that will ease integration into engines.

I want to hear your suggestion, I am ready to modify diligent and do my best.

Add java bindings

Add names to resources for debugging with NSight/RenderDoc

Add fence object to the API

Replace all third-party libraries with submodules

Rework D3D12 shader resource layout to use shader variable manager

Similar to Vk implementation

Implement persistently mapped buffers

Remove debug strings from STDAllocator in release build

Implement queries

Port Vulkan backend to Android

Remove map type, map flag parameters from IBuffer::Unmap function

Add explicit state transitions to the API

Move HLSL->SPIRV compiler to dynamic library

This component is large and should be optional. If an application does not need to compile HLSL shaders at run time, it should not pay the price of increase executable size.

Add support for Byte Address buffers

dx11: D3D11_RESOURCE_MISC_BUFFER_ALLOW_RAW_VIEWS

Root signature cache in D3D12 backend

Implement root signature cache to avoid creating duplicate root signatures for PSOs sharing the same shader resource layout.

Port Vulkan backend to Linux

Add Vulkan default entrypoint name to be from bytecode

If the bytecode used the default entrypoint name need to be from bytecode

Treat MipLevelCount == -1 as whole mipmap chain

To be consistent with D3D

DX12 texture update error

D3D12 ERROR: ID3D12CommandList::CopyTextureRegion: D3D12_SUBRESOURCE_FOOTPRINT::RowPitch must be a multiple of 256 (aka. D3D12_TEXTURE_DATA_PITCH_ALIGNMENT) and greater or equal to the pitch implied by the width. RowPitch is 16, and must be greater or equal to 16 when D3D12_SUBRESOURCE_FOOTPRINT::Width is 4 and D3D12_SUBRESOURCE_FOOTPRINT::Format is R8G8B8A8_TYPELESS. [ RESOURCE_MANIPULATION ERROR #868: COPYTEXTUREREGION_INVALIDSRCROWPITCH]

Diligent Engine: ERROR: Debug assertion failed in Diligent::CommandContext::Close(), file commandcontext.cpp, line 94:

Failed to close the command list

Add resource layout object to the API

This will be an abstraction for root signature/pipeline layout.

Besides that:

• Move shader variable type selection from shader initialization to PSO initialization
• Initialize static shader resources through PSO rather than through shaders
• Return variable list from shader objects

Add support for NULL buffers in SetVertexBuffers

Enable Vulkan on iOS via MoltenVK

Vulkan backend is already ported to MacOS. It also builds fine on iOS, but it does not link properly with MoltenVK libraries: none of Vulkan functions are resolved.

Add FinishFrame() function to device context

This will trigger the context to release all resources, make it explicit and will allow do all the related work in a free-threaded manner
Also. move command queue and all related logic to device context

Memory leaks in Vulkan backend when compiling HLSL shaders

The leaks are caused by a bug in glslang:
KhronosGroup/glslang#1554

Port Vulkan backend to iOS/MacOS (via MoltenVK)

Rework dynamic memory allocation in D3D12 backend to not rely on ring buffer

This will drop the requirement that all dynamic resources must be unmapped at the end of the frame. Each context will manage its own dynamic resource lifetimes

Add C# bindings

Vulkan DXC compiler adding type prefix for constant buffer variables

Vulkan backend perf markers are not working (renderdoc)

Support ConstantBuffer layout info?