Hello everybody! I decided to write a graphics engine, the killer of Unity and Unreal. If anyone interested and have free time, join. High-level render is based on low-level OpenGL 4.5 and DirectX 11. Ideally, there will be PBR, TAA, SSR, SSAO, some variation of indirect light algorithm, support for multiple viewports and multiple cameras. The key feature is COM based (binary compatibility is needed). Physics, ray tracing, AI, VR will not. I grabbed the basic architecture from the DGLE engine. The editor will be on Qt (https://github.com/fra-zz-mer/RenderMasterEditor). Now there is a buildable editor. The main point of the engine is the maximum transparency of the architecture and high-quality rendering. For shaders, there will be no new language, everything will turn into defines.

1 hour ago, lukash said:

Hello everybody! I decided to write a graphics engine, the killer of Unity and Unreal.

Ha ha,...... Well ...... nobody will accuse you of not having ambition

What platforms are supported? (I looked at the link, but didn't see it mentioned there.)

Edit: Maybe your mention of COM answers that question, but it might still be of interest to know specifically what platforms you plan to support.

3 hours ago, Zakwayda said:

What platforms are supported? (I looked at the link, but didn't see it mentioned there.)

Edit: Maybe your mention of COM answers that question, but it might still be of interest to know specifically what platforms you plan to support.

Now I concentrate on the version for Windows. After writing a basic render and a minimally usable editor, I plan to port to Linux.I will not use COM for Linux, as far as I know there is a stable ABI (I would do it already if I had Linux as the second system on my desktop  ). I do not consider Mac because it has a restrictive implementation of OpenGL.

You may find the project I've been working on useful here: https://github.com/DiligentGraphics/DiligentEngine

It is a low-level cross-platform graphics library that supports 6 platforms (Universal Windows, Windows Desktop, Linux, Android, Mac and iOS) and has Direct3D11, Direct3D12, Vulkan, and OpenGL/GLES backends. Shaders for all backends and platforms can be written in HLSL. You may use it as a low-level graphics abstraction layer. Note that by targeting old-school DirectX11 and OpenGL 4.5 these days you will unlikely be able to beat either Unity or Unreal.

13 hours ago, DiligentDev said:

You may find the project I've been working on useful here: https://github.com/DiligentGraphics/DiligentEngine

It is a low-level cross-platform graphics library that supports 6 platforms (Universal Windows, Windows Desktop, Linux, Android, Mac and iOS) and has Direct3D11, Direct3D12, Vulkan, and OpenGL/GLES backends. Shaders for all backends and platforms can be written in HLSL. You may use it as a low-level graphics abstraction layer. Note that by targeting old-school DirectX11 and OpenGL 4.5 these days you will unlikely be able to beat either Unity or Unreal.

Hi DiligentDev! Very interesting project, but let we ask some questions. How does it relates to LLGL (https://github.com/LukasBanana/LLGL)? What is difference, pros, cons? Also what is the endpoint goal of this project? Is there some engines that use these API? I see that you use a shader converter for targeting to different API, but I do not like this approach and prefer c preprocessor for more transparent compilation. I agree that dx 11, opengl 4.5 rather old-school, but for my purposes I don't see any restrictions in these API for implementing all graphics techniques. 

I can't really tell you much about LLGL, but my impression is that it is mostly an experimental project. You can take a look at the code samples, compare it to Diligent samples and figure out what works best for you.

Speaking about Diligent, all its 5 rendering backends are feature complete at this point on all 6 supported platforms. The engine is thoroughly tested and optimized. What to shader converter, it is only really used on OpenGL backend. On Vulkan, HLSL is compiled directly to SPIRV using glslang (or you can use any other compiler such as DXC). You can really supply compiled HLSL or SPIRV bytecode directly. Or you can use GLSL with OpenGL/Vulkan backends.

I am not sure what you mean by using "c preprocessor for more transparent compilation". If you are talking about using macros to produce HLSL and GLSL  from the same file, then believe me this is not going to be transparent.

I am not really sure what your goal is. If you want to learn the APIs and figure out why the industry moved away from DX11 and OpenGL to DX12 and Vulkan, you can find your own way. If you want to build a renderer and concentrate on rendering part, then using existing low-level library, being it Diligent, LLGL, bgfx or any other framework will save you a lot of time.

Update: For half a year, I completely rewrote the engine.

Implemented: 

• Deferred render

• Physically based materials

• Image based lighting

• Game objects system with parent-child relationship

• Translate manupulator

• Picking

• Experimental Import FBX

I spend this weekend to my engine (and suddenly broke up with the girl ). I completely reinvent material system. I introduce generic materials. It can be described in the text file: passes, parameters, textures, defines. All this stuff will automatically be sent to the shader and editor UI generated. Material is just intance of generic material, parameters and textures can be overwritten.

 On the basis of this implemented normal mapping.