dragonjoker/ashes

Drop-in replacement for Vulkan shared library, for older hardware compatibility

ashes's Issues

Error model

In base, no exceptions must be raised, at all.
This implies returning an error code, wherever it is needed.

Update my fork of SaschaWillems/Vulkan to use RendererLib.

Image and buffer memory

Create MemoryRequirements and DeviceMemory in RendererLib.
This will require the effective creation of an OpenGL image/buffer storage when the call is made to bindMemory.

Allow swapchain to have a depth / stencil buffer.

Support shader specialisation constants

OpenGL automatic context switch

Instead of enabling a context through Device::enable, implement automatic context enabling for the current thread.

Create DescriptorPool class.

And DescriptorSetPool should only be used to wrap this class.

Fail to build

on Arch linux

CMake Error at CMakeLists.txt:189 (add_subdirectory):
  add_subdirectory given source "Templates" which is not an existing
  directory.


CMake Error at CMakeLists.txt:193 (add_subdirectory):
  add_subdirectory given source "Test" which is not an existing directory.


CMake Error at CMakeLists.txt:197 (add_subdirectory):
  add_subdirectory given source "Samples" which is not an existing directory.


-- Configuring incomplete, errors occurred!
See also "/home/arthapz/Dev/repos/Ashes/build/CMakeFiles/CMakeOutput.log".

OpenGL 3.X renderer

Create C++ library for the C API

This is the replacement for previous Ashes.
It will only call vanilla Vulkan functions.
See #113

DirectX 11 renderer.

Create base C API

See #113

Rework RenderPass attachments

To make them more compilant with vulkan.h

roadmap?

I have been keeping an eye on your project, do you have a roadmap to where you are heading?

Make Gl3Renderer compatible with C API

See #113

Vulkan Events

Add VkImageSubresource and VkSubresourceLayout interfaces

A merge of these two ones into one single struct may be necessary.

Cleanup Vulkan renderer

See #113

Allow line width as a dynamic pipeline state

OpenGL ES 3.1 renderer.

Make D3D11Renderer compatible with C API

See #113

Support inline uniform blocks.

Implement PhysicalDevice in RendererLib with properties and features.

Android support

The lib isn't tested at all on Android.

Dynamic uniform buffers

Add support for compressed texture formats

BC3, ASTC (check which ones) and ETC2.

Support derivative pipelines.

Push constant arrays

When a push constant is an array, GlRenderer bugs.

Add depth bounds to viewport

Use Named buffers and textures, to allow persistent mapping.

Make TestRenderer compatible with C API

OpenGL SwapChain

The OpenGL swapchain is limited, and this limit impacts the API structure (see SwapChain::createDepthStencil).
I must make it work like a Vulkan swapchain, hence I need to implement it as a FBO.
It will also allow to work with the swapchain images as with any other one.

It will help for #34

OpenGL functions into context

Instead of having them in a global namespace, OpenGL functions should be members of the Device (or its context)

Make Gl4Renderer compatible with C API

See #113

Push descriptor sets

Replace VertexLayout with VertexInputState.

Support for SPIR-V across all renderers.

Common text shader language across renderers.

Rationale

The various renderers use slightly different shader languages: SPIR-V, GLSL#150, GLSL#420, and HLSL (sm5).
Convertion to SPIR-V can be (and actually is) handled using glslang and libSPIRV.
For text shaders, I'd like to have a common language, that would be parsed inside each specific renderer.

Details

I think a good starting point could be GLSL with Vulkan extensions (for push constants, which are handled as simple uniforms in OpenGL renderers, and as constant buffers in Direct3D11 renderer).
I would add some kind of annotation using #pragma preprocessor directive, to help the renderers' parsers to make the appropriate replacements.

Example

Let's start with the following annotated GLSL#420 vertex shader:

// Here, layout can remain as is, since it can be removed completely for GLSL#150,
// and replaced by a matching cbuffer in HLSL (except for 'set', which is another problem).
layout( set=0, binding=1 ) uniform Matrix
{
	mat4 mtxProjection;
};

// The vertex shader inputs need a change, since D3D11 needs semantics
// (even if their names aren't important).
in VertexInput
{
	#pragma semantic_name POSITION
	#pragma semantic_index 0
	layout( location = 0 ) vec4 position;
	#pragma semantic_name TEXCOORD
	#pragma semantic_index 0
	layout( location = 1 ) vec2 texcoord;
};

// This one can be removed from D3D11 renderer's parser, and remain as is for others.
// It will also be used in D3D11 renderer's parser to define the SV_POSITION holder.
out gl_PerVertex
{
	vec4 gl_Position;
};

// The vertex shader inputs need a change, since D3D11 needs semantics
// (even if their names aren't important).
out VertexOutput
{
	#pragma semantic_name POSITION
	#pragma semantic_index 0
	layout( location = 0 ) vec3 vtx_position;
	#pragma semantic_name TEXCOORD
	#pragma semantic_index 0
	layout( location = 1 ) vec2 vtx_texcoord;
}

// The main function will certainly need some rework inside the D3D parser,
// to be able to return what is needed, and to have what is need in entry.
void main()
{
	// This specific line may be a problem (I'll explain later).
	// Note that `ashesScalePosition` is the only Ashes intrinsic,
	// which allows the renderer to transform the position
	// to make it correct for it's own clip space.
	gl_Position = mtxProjection * ashesScalePosition( position );
	vtx_position = vec3( gl_Position );
	vtx_texcoord = texcoord;
	// In HLSL, we'll need a return statement.
}

The generated GLSL#150 would look like this (not a lot of changes, except for the layout specifier which is removed from the uniform buffer declaration):

uniform Matrix
{
	mat4 mtxProjection;
};

in VertexInput
{
	layout( location = 0 ) vec4 position;
	layout( location = 1 ) vec2 texcoord;
};

out gl_PerVertex
{
	vec4 gl_Position;
};

out VertexOutput
{
	layout( location = 0 ) vec3 vtx_position;
	layout( location = 1 ) vec2 vtx_texcoord;
};

void main()
{
	gl_Position = mtxProjection * ashesScalePosition( position );
	vtx_position = vec3( gl_Position );
	vtx_texcoord = texcoord;
}

The generated HLSL would (obviously) be very different:

cbuffer Matrix: register(b1)
{
	float4x4 mtxProjection;
};

struct VertexInput
{
	float4 position: POSITION;
	float2 texcoord: TEXCOORD;
};

struct VertexOutput
{
	float4 gl_Position: SV_POSITION;
	float3 vtx_position: POSITION;
	float2 vtx_texcoord: TEXCOORD;
};


VertexOutput main( in VertexInput input )
{
	VertexOutput output;
	output.gl_Position = mul( mtxProjection, ashesScalePosition( input.position ) );
	output.vtx_position = vec3( output.gl_Position );
	output.vtx_texcoord = input.texcoord;
	return output;
}

Problems

As far as I can see, this can be done without too much hard work.
Some points need attention though.

Matrix multiplication
In GLSL it is handled using multiplication operator *, while in HLSL it is handled using the intrinsic function mul.
I suggest using mul in the common language, and the parsers would either provide the function, or replace it with multiplication operator (can be complex, since there can be anything, in the function call arguments).

Types
They'll need to be #defined or completely replaced by the parser.

Intrinsics
Similar issue as types, they'll either need to be #defined or completely replaced by the parser.

set layout
This one is IMO a big issue, and it is unsolvable: in Vulkan we can specify the same binding, as long as the sets are different:

layout( set = 0, binding = 0 ) uniform Glop
{
  //whatever
};
layout( set = 1, binding = 0 ) uniform Meow
{
  //whatever else
};

This is perfectly valid with Vulkan, but impossible in other renderers.
It will probably be a limitation for users, when using Ashes.

Conclusion

I'm open to any suggestion that would help :).

Remove Surface from Device creation

Problem here lies in OpenGL contexts....

Create custom allocator interface.

DirectX 12 Renderer.

Implement command Copy Buffer To Image in D3D11Renderer

This concept is completely alien to Direct3D 11.
Either you give your image its data at creation, or through texture copy/blit.
So, since in Vulkan you can't give an image its data at creation, I must copy from another texture.
Two cases:

• The texture memory was created as device local => I can't map the texture to RAM.
  I need to have/create a staging texture, for this case (a cache of staging textures ?).
• The texture memory was created as host visible => I can map it to RAM.

What I'll do first, is the naive approach:

• Map buffer to RAM
• Map texture to RAM (staging or host visible destination)
• Copy buffer mapped data to texture mapped data
• Unmap all
  If the texture is device local, an additional step is needed:
• Copy staging texture to destination texture

The only remaining question now is about the staging texture...

One more bit to #34

Metal renderer.

I don't have any Apple device, hence I can't do it by myself, feel free to start working on it :P

Add invalidation to buffers

Update tests and samples...

See #113

Remove GeometryBuffers

It will need specific processing in OpenGL, to be able to generate the VAO when the draw commands are issued, and initialisation of this VAO must happen when the command buffer is submitted to a queue.

C API for Ashes

With all these moves to improve compliance with vulkan.h, I will make Ashes a drop in replacement to Vulkan.

The first approach is an automatic one: you load Ashes shared library instead of Vulkan's, and you're done. The API selection will be done on first call of vkGetInstanceProcAddr.

The second approach is a manual one: additionally, you can ask for the list of loaded plugins, through a call to the function int ashEnumeratePlugins( uint32_t * count , AshPluginDescription * plugins );
It works as Vulkan ones : if plugins is set to NULL, count will then contain the number of loaded plugins.
AshPluginDescription is defined as follows:

typedef struct AshPluginDescription
{
  const char * name;
  const char * description;
  PFN_vkGetInstanceProcAddr getInstanceProcAddr;
} AshPluginDescription;

Some changes to this definition may be done, but the idea remains the same.
The struct and the function will be declared in ashes.h

Make Ashes more compliant with vulkan.h

Rework RenderPass to make it compliant with vulkan.h

Support bind sparse