next »

[fluffrabbit]

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.

[assiduous]

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.

[fluffrabbit]

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.

[assiduous]

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

[assiduous]

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

[assiduous]

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

[Schrompf]

Looks nice. Your PBR stuff is on point.

[assiduous]

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

[assiduous]

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);

[assiduous]

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

[assiduous]

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

[assiduous]

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

[assiduous]

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

[assiduous]

Diligent Engine v2.5 is out! This major release introduces a number of significant improvements:

• Pipeline resource signatures enable applications to define explicit shader resource layouts that allow sharing shader resource binding objects between different pipeline states.
• Multiple immediate contexts is an abstraction over multiple command queues that enables e.g. async compute and parallel rendering.
• Inline ray-tracing is a powerful extension to ray tracing that allows casting rays from regular shaders (pixel, compute, etc.).
• Ray tracing on Metal is now also supported by Diligent Engine.
• Debug groups improve debugging and profiling experience.
• Wave operations enable sharing data between threads in one shader thread group.
• Memoryless framebuffer attachments enable memory savings on mobile platforms.

A new Tutorial 22 - Hybrid Rendering demonstrates how to implement a simple hybrid renderer that combines rasterization with ray tracing. The tutorial runs on DirectX12, Vulkan and Metal.



https://github.com/DiligentGraphics/DiligentEngine

[assiduous]

Release 2.5.2 has just been released and introduces an API for packaging render state objects (shaders, pipeline states, resource singatures, render passes) into archives. An object archive contains data optimized for run-time loading performance (shaders are compiled into optimized byte code and patched to match resource signatures, if necessary; internal pipeline resource layouts are initialized; all objects are verified for compatibility and correctness etc.). One archive may contain data for multiple backends (e.g. Direct3D12, Vulkan, OpenGL).

The release also introduces Diligent Render State Notation, a JSON-based language that describes shaders, pipeline states, resource signatures and other objects in a convenient form, e.g.:

Code:

{
    "Shaders": [
        {
            "Desc": {
                "Name": "My Vertex shader",
                "ShaderType": "VERTEX"
            },
            "SourceLanguage": "HLSL",
            "FilePath": "cube.vsh"
        },
        {
            "Desc": {
                "Name": "My Pixel shader",
                "ShaderType": "PIXEL"
            },
            "SourceLanguage": "HLSL",
            "FilePath": "cube.psh",
        }
    ],
    "Pipeleines": [
        {
            "GraphicsPipeline": {
                "DepthStencilDesc": {
                    "DepthEnable": true
                },
                "RTVFormats": {
                    "0": "RGBA8_UNORM_SRGB"
                },
                "RasterizerDesc": {
                    "CullMode": "FRONT"
                },
            },
            "PSODesc": {
                "Name": "My Pipeline State",
                "PipelineType": "GRAPHICS"
            },
            "pVS": "My Vertex shader",
            "pPS": "My Pixel shader"
        }
    ]
}

Render state notation files can be parsed and loaded dynamically at run time. Alternatively, an application can use a packaging tool to preprocess pipeline descriptions (compile shaders for target platforms, define internal resource layouts, etc.) into archives off-line.

https://github.com/DiligentGraphics/DiligentEngine