next »

[assiduous]

Hello!

I would like to introduce the project I've been working on for a while and that you may find useful. It is a modern low-level graphics library called Diligent Engine designed to take advantage of next-gen graphics APIs (Diect3D12, Vulkan, Metal).
The engine supports Windows, Linux, Android, Mac and iOS platforms. It has Direct3D11, Direct3D12, Vulkan, and OpenGL/GLES backends. For all supported platforms and backends, shaders can be written in HLSL.

Full source code is available on GitHub:
https://github.com/DiligentGraphics/DiligentEngine

At the moment it is a purely low-level graphics API, but higher-level features such as PBR renderer are in plans.

[goob256]

Fellow low level gfx lib creator here. This looks pretty decent. Nice to see support for modern apis (d3d12, vulkan, metal.) Just chiming in to say "nice job".

[ThemsAllTook]

Same here, looks pretty nice!

[assiduous]

@goobliata, @ThemsAllTook Thanks!

[assiduous]

Diligent Engine now supports Vulkan on MacOS (enabled with MoltenVK)

Here is the full list of supported platforms and APIs:

Platform	Supported APIs
Windows Desktop	Direct3D11, Direct3D12, OpenGL4.2+, Vulkan
Universal Windows	Direct3D11, Direct3D12
Linux	OpenGL4.2+, Vulkan
Android	OpenGLES3.0+
MacOS	OpenGL4.1, Vulkan
iOS	OpenGLES3.0

Check out the latest release on GitHub:
https://github.com/DiligentGraphics/DiligentEngine

[kason.xiv]

Is this done mostly by your hand? Do you have a slack or discord where development plans are discussed?

[assiduous]

Is this done mostly by your hand?

It is.

Do you have a slack or discord where development plans are discussed?

There is gitter chat (https://gitter.im/diligent-engine), though it is not super crowded for the time being. People mostly ask questions via GitHub issues.

[assiduous]

Check out epipolar light scattering effect (https://github.com/DiligentGraphics/DiligentFX/tree/master/Postprocess/EpipolarLightScattering) - the first ready-to-use component of an under-construction high-level renderer DiligentFX.
The effect works by smartly placing expensive ray-marching samples along the epipolar lines that originate at the light source and interpolating the radiance between these samples.

[assiduous]

New release v2.4.b is out that features improved shader resource reflection, improved pipeline resource layout definition, better OpenGLES3.0 support, DiligentFX module, new Render Target tutorial and more.

[assiduous]

Diligent Engine now also supports Vulkan on iOS (enabled by MoltenVK). Check out the latest version:
https://github.com/DiligentGraphics/DiligentEngine#build_and_run_ios

[assiduous]

Diligent Engine now supports GLTF2.0 format and implements physically-based renderer with image-based lighting.
https://github.com/DiligentGraphics/DiligentEngine/blob/master/README.md#gltf_loader_and_renderer

Check-out the cross-platform GLTF viewer:
https://github.com/DiligentGraphics/DiligentSamples/tree/master/Samples/GLTFViewer

The viewer now runs on Windows, Universal Windows, Linux and Mac. Android and iOS are coming.

[InfiniteStateMachine]

How did you like working with the format. Can FBX die soon?

[assiduous]

GLTF is designed to be a run-time format, unlike FBX, so I don't think the comparison is really fair.
The format has a number of good features: state of the art PBR material description, animation, etc.
It has limitations too, so it may not work for all use cases. However I think it is a very reasonable open standard format that should be useful for a wide range of applications.

[fluffrabbit]

PBR is pretty well documented and straightforward if your renderer supports multiple texture slots, cubemaps, and a way to pre-process textures with framebuffers. glTF is simple to load, though it has a lot of nuanced features that have tripped me up such as animation.

On the other hand, that epipolar light scattering makes me question everything I know about computers. Wow. I don't even know what I'm looking at but it looks amazing. Atmospheric haze scattering the sunlight miles into the distance. This is really far ahead.

[assiduous]

The viewer now also supports Android!
It technically runs on iOS too, but due to some issues (could be MoltenVK), the image looks corrupted.

[InfiniteStateMachine]

GLTF is designed to be a run-time format, unlike FBX, so I don't think the comparison is really fair.
The format has a number of good features: state of the art PBR material description, animation, etc.
It has limitations too, so it may not work for all use cases. However I think it is a very reasonable open standard format that should be useful for a wide range of applications.

What are the limitations compared to FBX? Can it not be compared somewhat? I ask because unreal engine is in the process of supporting gltf and it seems to fit the standard pipeline flown as FBX.

The fact it's runtime ready seems even better since every studio I've ever worked at was hit with pipeline/loading issues due to how FBX is structured.

[fluffrabbit]

glTF gives you an option of either arrays of structs or structs of arrays, plus several exporters don't include tangents, so in practice you can't just drop the glTF blob into graphics memory, there is still a loading step. (Unless your workflow is extremely synchronized with exporters and importers using the exact same glTF configuration.)

[assiduous]

Diligent Engine now implements some shadow rendering BKMs:

- Cascaded shadow maps with cascade stabilization
- PCF
- Variance shadow maps
- Two and four-component exponential variance shadow maps
- Optimized fixed-size or world-sized filter kernels
- Best cascade search based on projection into light space
- Filtering across cascades
- Various artifact removal techniques

The techniques are implemented as a standalone shadow map manager and few shader functions that can be easily integrated into an application.
Check it out on GitHub:
https://github.com/DiligentGraphics/DiligentEngine#high-level-rendering-components-1
https://github.com/DiligentGraphics/DiligentSamples/tree/master/Samples/Shadows

I am planning to add exponential shadow maps and moment shadow maps later. Are there any state-of-the-art shadowing techniques that I am missing?

[fluffrabbit]

That's amazing, and I don't have a clue about buffered shadow techniques as I have yet to implement them in my own code. No seams? That's great!

However, I'm not fond of the project organization. You use a lot of little files as well as submodules, which is hardly keeping with the philosophy of compactness and simplicity. Aside from graphical quality, how does Dilligent compare against Ogre3D and Panda3D?

[assiduous]

Speaking about code organization, there are adherents of two principal schools: the first one puts everything into a giant file so that everything is in one place. I've seen files with 50,000+ lines of code. This is definitely convenient from integration point of view, however supporting or working with such files is a nightmare. This file is essentially a black box of code.

The second school breaks everything into small components. As you can tell, I am from the second school. I do believe that modular organization tells a lot about the project structure, while copying a folder is just little bit more extra work than copying a single file.
In Diligent Engine, different modules can be enabled/disabled as necessary: all backends, samples, tutorials, demo project can be turned on/off as needed. Projects are organized into hierarchy where more complex are built on top of more basic ones. The folder structure is easy and natural to navigate even though it contains many files.

Speaking about Ogre3D, Diligent Engine is more low-level library. It does not have an editor, but provides low-level functionality and a set of basic building blocks (PBR shaders, shadows, post-processing, etc.)