Welcome, Guest. Please login or register.
Did you miss your activation email?

Login with username, password and session length

 
Advanced search

1387087 Posts in 66512 Topics- by 59064 Members - Latest Member: Vhalenn

January 19, 2021, 04:40:17 PM

Need hosting? Check out Digital Ocean
(more details in this thread)
TIGSource ForumsDeveloperTechnical (Moderator: ThemsAllTook)Diligent Engine - a Modern Cross-Platform Low-level Graphics Library
Pages: 1 [2]
Print
Author Topic: Diligent Engine - a Modern Cross-Platform Low-level Graphics Library  (Read 4485 times)
fluffrabbit
Guest
« Reply #20 on: August 06, 2019, 06:09:07 AM »

That makes sense, though my own GL framework is only up to 2000 lines total, so it's (currently) maintainable as 1 file. When it breaks 3000 lines I'll consider splitting it into multiple files, but I find it annoying when I can't find where I put a piece of code and it's in the last place I look because of the arbitrary boundaries I put between functionality. The things you've specifically mentioned (PBR, shadows, post-processing) are all part of 3D graphics, so they would go in the main file. Things that take up more space, like loading needlessly complex 3D model formats such as glTF, would go in their own file dependent upon the main file. That way you/I can still have 50,000 lines eventually but spread out over 10 files rather than 100.
Logged
assiduous
Level 0
**


View Profile
« Reply #21 on: August 06, 2019, 07:52:34 AM »

Diligent Engine's core module now contains more than 100,000 lines excluding any third-party projects. Splitting this into 2,000-line files will still make 50+ files. Like I mentioned, the boundaries between projects are not arbitrary, but very carefully thought of. They help navigate the code rather than making it harder to find what you are looking for. Because of this structure I can easily find anything by just browsing the source on GitHub.
Logged
fluffrabbit
Guest
« Reply #22 on: August 06, 2019, 08:44:07 AM »

Well, large codebases call for desperate measures. You're approaching the size of an operating system there. It's great that you're providing a reference for how every graphical technique on the planet works. I cherry-pick and avoid the size. To each their own.
Logged
assiduous
Level 0
**


View Profile
« Reply #23 on: August 06, 2019, 09:12:48 AM »

100,000 lines is not really a very big project. If you look at Ogre3D, it is likely 1,000,000+ lines.

BTW, I just added shadow map Tutorial that shows the basics of shadow map rendering
https://github.com/DiligentGraphics/DiligentSamples/tree/master/Tutorials/Tutorial13_ShadowMap
Logged
assiduous
Level 0
**


View Profile
« Reply #24 on: August 11, 2019, 10:58:06 PM »

Hello!
I recently added a new Diligent Engine tutorial that demonstrates the usage of compute shaders and may be interesting on its own. The example app implements a simple GPU particle system that consists of a number of spherical particles moving in random directions and encountering elastic collisions. The simulation and collision detection is performed on the GPU by compute shaders. To accelerate collision detection, the shader subdivides the screen into bins and for every bin creates a list of particles residing in the bin. The number of bins is the same as the number of particles and the bins are distributed evenly on the screen, thus every bin on average contains one particle. The size of the particle does not exceed the bin size, so a particle should only be tested for collision against particles residing in its own or eight neighboring bins, resulting in O(1) algorithmic complexity.

The full description of the implementation of the method is here:
https://github.com/DiligentGraphics/DiligentEngine
https://github.com/DiligentGraphics/DiligentSamples/tree/master/Tutorials/Tutorial14_ComputeShader
Logged
assiduous
Level 0
**


View Profile
« Reply #25 on: October 13, 2019, 08:25:08 PM »

Diligent Engine release v.2.4.c is out and enables Vulkan on iOS, significantly improved OpenGL/GLES performance, introduces many API improvements and implements a set of higher-level features, samples and tutorials:
* GLTF2.0 support (loader, PBR renderer and sample viewer)
* Shadowing Component and Shadows Sample
* Integration with Dear Imgui library and Dear Imgui demo
* Tutorial13 - Shadow Map
* Tutorial14 - Compute Shader
* Tutorial15 - Multiple Windows







Logged
Schrompf
Level 8
***

C++ professional, game dev sparetime


View Profile WWW
« Reply #26 on: October 13, 2019, 10:28:59 PM »

Looks nice. Your PBR stuff is on point.
Logged

Snake World, multiplayer worm eats stuff and grows DevLog
assiduous
Level 0
**


View Profile
« Reply #27 on: January 14, 2020, 12:32:53 PM »

This release of Diligent Engine implements a number of new features: MSAA, Queries, Bindless Resources. It also makes a major improvement to code quality assurance by enabling automated unit testing, format validation and static code analysis.
Check it out on GitHub: https://github.com/DiligentGraphics/DiligentEngine
Logged
assiduous
Level 0
**


View Profile
« Reply #28 on: February 04, 2020, 01:01:02 PM »

Diligent Engine is now also available in C!
Check out Tutorial 03 implemented using the new API: https://github.com/DiligentGraphics/DiligentSamples/tree/master/Tutorials/Tutorial03_Texturing-C.

This is what C API looks like:

Code:
// Bind vertex and index buffers
Uint32   offset = 0;
IBuffer* pBuffs[1];
pBuffs[0] = g_pCubeVertexBuffer;
IDeviceContext_SetVertexBuffers(pContext, 0, 1, pBuffs, &offset,
                                RESOURCE_STATE_TRANSITION_MODE_TRANSITION,
                                SET_VERTEX_BUFFERS_FLAG_RESET);
IDeviceContext_SetIndexBuffer(pContext, g_pCubeIndexBuffer, 0,
                              RESOURCE_STATE_TRANSITION_MODE_TRANSITION);

// Set the pipeline state
IDeviceContext_SetPipelineState(pContext, g_pPSO);
// Commit shader resources. RESOURCE_STATE_TRANSITION_MODE_TRANSITION mode
// makes sure that resources are transitioned to required states.
IDeviceContext_CommitShaderResources(pContext, g_pSRB,
                                     RESOURCE_STATE_TRANSITION_MODE_TRANSITION);

DrawIndexedAttribs DrawAttrs;
memset(&DrawAttrs, 0, sizeof(DrawAttrs));
DrawAttrs.IndexType    = VT_UINT32; // Index type
DrawAttrs.NumIndices   = 36;
DrawAttrs.NumInstances = 1;
// Verify the state of vertex and index buffers
DrawAttrs.Flags = DRAW_FLAG_VERIFY_ALL;
IDeviceContext_DrawIndexed(pContext, &DrawAttrs);
Logged
assiduous
Level 0
**


View Profile
« Reply #29 on: April 28, 2020, 09:37:59 PM »

New release of Diligent Engine is out on GitHub!
The major feature of this release is Vulkan support on Android. The release also covers C API announced earlier as well as introduces a number of API improvements and bug fixes.
https://github.com/DiligentGraphics/DiligentEngine


Logged
assiduous
Level 0
**


View Profile
« Reply #30 on: May 13, 2020, 09:20:38 PM »

Also, check out a new Hello AR sample that demonstrates how to use Diligent Engine in a basic AR application.
https://github.com/DiligentGraphics/DiligentEngine#samples


Logged
assiduous
Level 0
**


View Profile
« Reply #31 on: September 21, 2020, 01:07:09 PM »

The most recent release of Diligent Engine has introduced two major features: Mesh Shaders and Render Passes.

Mesh Shaders is a new feature of modern GPUs that is exposed through two new programmable stages: amplification and mesh shaders. The new stages give applications great control over geometry generation and processing entirely on the GPU. Diligent Engine exposes mesh shaders through common API and currently supports them on Windows, Linux and Universal Windows platforms.

A new tutorial demonstrates how mesh shaders can be used to perform view frustum culling and simple LOD selection entirely on the GPU.




Another new feature is render passes that allow applications to get more control over tiled-deferred rendering architectures and are instrumental in achieving high performance on mobile devices. A new tutorial shows how to use render passes API to implement simple deferred renderer.



Check out the new release on GitHub.
https://github.com/DiligentGraphics/DiligentEngine
Logged
assiduous
Level 0
**


View Profile
« Reply #32 on: January 03, 2021, 10:21:12 PM »

The latest release of Diligent Engine enables support for arguably the most innovative GPU capability of recent years: hardware-accelerated ray tracing. Ray tracing is supported in D3D12 and Vulkan backends and is exposed through common easy-to use yet fully exhaustive API: exactly the same host code works in both backends. Similar to other shader types, ray-tracing shaders authored in HLSL will work in both backends verbatim. Vulkan backend also supports GLSL as well as SPIRV bytecode.

A new tutorial demonstrates how ray tracing API in Diligent Engine can be used to simulate physics-based light transport in a scene to render soft shadows, multiple-bounce reflections and refractions, and dispersion.



https://github.com/DiligentGraphics/DiligentEngine
Logged
Pages: 1 [2]
Print
Jump to:  

Theme orange-lt created by panic