DiligentEngine | modern cross-platform low | Game Engine library

 by   DiligentGraphics C++ Version: v2.4.g License: Apache-2.0

kandi X-RAY | DiligentEngine Summary

kandi X-RAY | DiligentEngine Summary

DiligentEngine is a C++ library typically used in Gaming, Game Engine applications. DiligentEngine has no bugs, it has no vulnerabilities, it has a Permissive License and it has medium support. You can download it from GitHub.

A modern cross-platform low-level graphics library and rendering framework

            kandi-support Support

              DiligentEngine has a medium active ecosystem.
              It has 1791 star(s) with 183 fork(s). There are 101 watchers for this library.
              It had no major release in the last 12 months.
              There are 21 open issues and 104 have been closed. On average issues are closed in 39 days. There are no pull requests.
              It has a neutral sentiment in the developer community.
              The latest version of DiligentEngine is v2.4.g

            kandi-Quality Quality

              DiligentEngine has 0 bugs and 0 code smells.

            kandi-Security Security

              DiligentEngine has no vulnerabilities reported, and its dependent libraries have no vulnerabilities reported.
              DiligentEngine code analysis shows 0 unresolved vulnerabilities.
              There are 0 security hotspots that need review.

            kandi-License License

              DiligentEngine is licensed under the Apache-2.0 License. This license is Permissive.
              Permissive licenses have the least restrictions, and you can use them in most projects.

            kandi-Reuse Reuse

              DiligentEngine releases are available to install and integrate.
              Installation instructions, examples and code snippets are available.
              It has 51 lines of code, 1 functions and 7 files.
              It has low code complexity. Code complexity directly impacts maintainability of the code.

            Top functions reviewed by kandi - BETA

            kandi's functional review helps you automatically verify the functionalities of the libraries and avoid rework.
            Currently covering the most popular Java, JavaScript and Python libraries. See a Sample of DiligentEngine
            Get all kandi verified functions for this library.

            DiligentEngine Key Features

            No Key Features are available at this moment for DiligentEngine.

            DiligentEngine Examples and Code Snippets

            No Code Snippets are available at this moment for DiligentEngine.

            Community Discussions


            Unity 3'nd Person Controller Camera Acting Weird
            Asked 2022-Apr-08 at 23:22

            I'm very new in Unity and Stackowerflow. If i did something wrong, please don't judge me ^^ I used Unity's TPS Controller asset for my game. In first, it worked very well. But then It broke. But i didn't do anything :( (i don't even touch scripts or prefabs). After that, i deleted asset and re-download it but it didnt work again. Here is one example from my broken scene and these are the codes from my controller. Thanks For Any Kind of Help.

            Starter Assets Input ...


            Answered 2022-Apr-08 at 23:22

            I had the same problem too. I researched a lot of documents about that and finally, I solved this problem. The problem is not about your codes or events or smth else. The problem is related to Unity. I don't know the exact reason for the problem but you can solve it this way: First, go Edit > Project Settings and select Input System Package from the Left tab. And then, change the Update Method with Process Events In Dynamic Update. And that's all! Dynamic update means the usual Update method that you see in the scripts void Update().


            Source https://stackoverflow.com/questions/71804001


            OpenTK doesn't render the color of my triangle
            Asked 2022-Apr-03 at 07:08

            I am learning to program a game engine which is why I followed a tutorial, with that tutorial I have gotten this far and even though my code is identical to theirs (theirs did work in the videos) its not working the way it is meant to. The triangle stays black no matter what. There is not any errors.

            Main Program Script:



            Answered 2022-Apr-03 at 07:08

            You actually assign the shader program to a local variable in the event callback function's scope. You need to assign it to the variable in scope of Main:

            Source https://stackoverflow.com/questions/71723584


            How to create a first-person "space flight" camera
            Asked 2022-Mar-15 at 13:43

            I'm currently attempting to create a first-person space flight camera.

            First, allow me to define what I mean by that.

            Notice that I am currently using Row-Major matrices in my math library (meaning, the basis vectors in my 4x4 matrices are laid out in rows, and the affine translation part is in the fourth row). Hopefully this helps clarify the order in which I multiply my matrices.

            What I have so Far

            So far, I have successfully implemented a simple first-person camera view. The code for this is as follows:



            Answered 2022-Mar-02 at 23:15

            The problem is that two numbers, pitch and yaw, provide insufficient degrees of freedom to represent consistent free rotation behavior in space without any “horizon”. Two numbers can represent a look-direction vector but they cannot represent the third component of camera orientation, called roll (rotation about the “depth” axis of the screen). As a consequence, no matter how you implement the controls, you will find that in some orientations the camera rolls strangely, because the effect of trying to do the math with this information is that every frame the roll is picked/reconstructed based on the pitch and yaw.

            The minimal solution to this is to add a roll component to your camera state. However, this approach (“Euler angles”) is both tricky to compute with and has numerical stability issues (“gimbal lock”).

            Instead, you should represent your camera/player orientation as a quaternion, a mathematical structure that is good for representing arbitrary rotations. Quaternions are used somewhat like rotation matrices, but have fewer components; you'll multiply quaternions by quaternions to apply player input, and convert quaternions to matrices to render with.

            It is very common for general purpose game engines to use quaternions for describing objects' rotations. I haven't personally written quaternion camera code (yet!) but I'm sure the internet contains many examples and longer explanations you can work from.

            Source https://stackoverflow.com/questions/71328720


            How do I make copies of a Node in Godot
            Asked 2022-Feb-19 at 01:11

            I'm new to Godot coming fresh from unity and I cant figure out how to duplicate an object/node. I've tried the duplicate function to no effect. My most recent attempts try to create child nodes with the same property as the parent. I cant seem to get anywhere, help would be appreciated. Here is my code that tries to create a child node:



            Answered 2022-Feb-19 at 01:11

            • The base node class is invisible (gray) so you cannot see if they were added or not. You can switch from the local to the remote tab in the scene tree while running to see only one invisible node added.
            • If you change the code to AddChild(copynode).Duplicate(); you can see it adds all 5 invisible nodes.

            Source https://stackoverflow.com/questions/71180866


            Coming from OO languages to C, how can I avoid circular dependencies?
            Asked 2022-Feb-13 at 13:14

            When I say "Entity" below, I'm not specifically referring to anything relating to the ECS pattern, I just mean a general game entity.

            I'm trying my hand at game development in C, after having done previous game dev in TypeScript. I'm looking for a C idiomatic way to reuse a pattern with which I'm familiar: each tick, the game iterates through a list of entities, telling each one to update itself, then draw itself. Each entity knows how to update itself, but requires information about the game as a whole to make this update.



            Answered 2022-Feb-13 at 13:14

            Don't #include "entity.h" from game.h and vice versa. Just forward declare what you need a pointer to. Also add header guards if you haven't already.


            Source https://stackoverflow.com/questions/71100649


            SpawnObject for ak(Clone) (UnityEngine.GameObject), NetworkServer is not active. Cannot spawn objects without an active server
            Asked 2022-Feb-10 at 07:54

            helloI'm making an object in Unity that gives players random weapons when they hover over it, but it always gives me this warning and doesn't create it.



            Answered 2022-Feb-10 at 07:54

            This is because of you are calling the spawn function from client. You should call it in server.

            Source https://stackoverflow.com/questions/71010816


            Detecting if an enemy was shot by bullet
            Asked 2022-Feb-06 at 03:20

            I am trying to learn Godot by making a simple 2D shooter, but am running into a problem. I do not know how to detect if an enemy has been shot by a bullet. My bullets are Area2D nodes with a Sprite, and CollisionShape2D node attached. My enemies are KinematicBody2D nodes with a Sprite, and CollisionShape2D node attached. The enemy also has a timer attached, but that is not important.

            Here is the enemy code:



            Answered 2022-Feb-06 at 03:20

            On your _on_PlayerBullet_body_entered you a body that has a reference to whatever the Area2D collided with, you can use it to communicate with it.

            For example, you can call a method on it. Which could, of course could be queue_free:

            Source https://stackoverflow.com/questions/71003599


            Phaser.js: How to get or remove all sprites in one scene
            Asked 2022-Jan-29 at 09:00

            I used to handle a group of sprites by push them into an array or sprite group which is build-in class in the Phaser. But I am seeking another simple way could get or remove all sprites in an scene. Does anyone have any idea to resolve this? Thanks a lot!



            Answered 2022-Jan-29 at 09:00

            The Scene has a property children (link to documentation)

            You can get all Sprites, with the command:

            Source https://stackoverflow.com/questions/70903111


            Phaser3, Creating Rounded Rectangle, Not Staying Put Relative To Window
            Asked 2022-Jan-21 at 00:26

            I'm trying to create a scoreboard using phaser3. It creates the board when I do the following in create function:



            Answered 2022-Jan-21 at 00:26


            Source https://stackoverflow.com/questions/70794747


            Ursina Python Engine: Lighting, Shadows And Bloom Effects
            Asked 2022-Jan-17 at 07:34

            I Am New To Ursana Engine And I Don't Know It Properly. But I Can Make Games In It. But The Problem Is That My Game Doesn't Have Any . So My Game Looks Dead.

            Is There Any Way To Make My Game Look Good Using In Ursana Engine?



            Answered 2021-Dec-11 at 20:32

            You have to add lights and also apply lit_with_shadows_shader to entities that will receive shadow.

            See more here: https://www.ursinaengine.org/cheat_sheet.html#DirectionalLight

            Source https://stackoverflow.com/questions/70139918

            Community Discussions, Code Snippets contain sources that include Stack Exchange Network


            No vulnerabilities reported

            Install DiligentEngine

            Diligent Engine uses CMake as a cross-platform build tool. To start using cmake, download the latest release (3.16 or later is required). Another build prerequisite is Python interpreter (3.0 or later is required). If after following the instuctions below you have build/run issues, please take a look at troubleshooting.
            By default there is no Vulkan implementation on MacOS. Diligent Engine loads Vulkan dynamically and can use a Vulkan Portability implementation such as MoltenVK or gfx-portability. Install VulkanSDK and make sure that your system is properly configured as described here. In particular, you may need to define the following environment variables (assuming that Vulkan SDK is installed at ~/LunarG/vulkansdk-macos and you want to use MoltenVK):.
            To enable Vulkan on iOS, download and install VulkanSDK. There is no Vulkan loader on iOS, and Diligent Engine links directly with MoltenVK XCFramework (see MoltenVk install guide) that implements Vulkan on Metal. To enable Vulkan in Diligent Engine on iOS, specify the path to Vulkan SDK when running CMake, for example (assuming that Vulkan SDK is installed at /LunarG/vulkansdk-macos):. By default, the engine links with MoltenVK XCFramework located in LunarG SDK. If this is not desired or an application wants to use a framework from a specific location, it can provide the full path to the framework via MoltenVK_FRAMEWORK CMake variable. Refer to MoltenVK user guide for more information about MoltenVK installation and usage. Last tested LunarG SDK version:
            By default, all back-ends available on current platform are built. To disable specific back-ends, use the following options: DILIGENT_NO_DIRECT3D11, DILIGENT_NO_DIRECT3D12, DILIGENT_NO_OPENGL, DILIGENT_NO_VULKAN, DILIGENT_NO_METAL. The options can be set through cmake UI or from the command line as in the example below:. Additionally, individual engine components can be enabled or disabled using the following options: DILIGENT_BUILD_TOOLS, DILIGENT_BUILD_FX, DILIGENT_BUILD_SAMPLES, DILIGENT_BUILD_DEMOS, DILIGENT_BUILD_UNITY_PLUGIN. If you only want to build SampleBase project, you can use DILIGENT_BUILD_SAMPLE_BASE_ONLY option. By default Vulkan back-end is linked with glslang that enables compiling HLSL and GLSL shaders to SPIRV at run time. If run-time compilation is not required, glslang can be disabled with DILIGENT_NO_GLSLANG cmake option. Additionally, HLSL support in non-Direct3D backends can be disabled with DILIGENT_NO_HLSL option. Enabling the options significantly reduces the size of Vulkan and OpenGL back-end binaries, which may be especially important for mobile applications. Diligent Engine uses clang-format to ensure consistent formatting throughout the code base. The validation can be disabled using DILIGENT_NO_FORMAT_VALIDATION CMake option. Note that any pull request will fail if formatting issues are found. Diligent Engine uses extensive validation that is always enabled in Debug build. Some of the checks may be enabled in release configurations by setting DILIGENT_DEVELOPMENT CMake option. To enable PIX events support, download WinPixEventRuntime and set DILIGENT_PIX_EVENT_RUNTIME_PATH CMake variable to the root folder of the package.
            Diligent Engine allows clients to customize build settings by providing configuration script file that defines the following optional cmake functions:.
            custom_configure_build() - defines global build properties such as build configurations, c/c++ compile flags, link flags etc.
            custom_pre_configure_target() - defines custom settings for every target in the build and is called before the engine's build system starts configuring the target.
            custom_post_configure_target() - called after the engine's build system has configured the target to let the client override properties set by the engine.
            If defined, custom_configure_build() function is called before any build target is added. By default, cmake defines the following four configurations: Debug, Release, RelWithDebInfo, MinSizeRel. If you want, you can define your own build configurations by setting CMAKE_CONFIGURATION_TYPES variable. For instance, if you want to have only two configuration: Debug and ReleaseMT, add the following line to the custom_configure_build() function:.
            CMAKE_C_FLAGS_<Config> - c compile flags
            CMAKE_CXX_FLAGS_<Config> - c++ compile flags
            CMAKE_EXE_LINKER_FLAGS_<Config> - executable link flags
            CMAKE_SHARED_LINKER_FLAGS_<Config> - shared library link flags
            Please refer to this page. Also, tutorials and samples listed below is a good place to start. This tutorial shows how to render simple triangle using Diligent Engine API. This tutorial demonstrates how to render an actual 3D object, a cube. It shows how to load shaders from files, create and use vertex, index and uniform buffers. This tutorial demonstrates how to apply a texture to a 3D object. It shows how to load a texture from file, create shader resource binding object and how to sample a texture in the shader. This tutorial is identical to Tutorial03, but is implemented using C API. This tutorial demonstrates how to use instancing to render multiple copies of one object using unique transformation matrix for every copy. This tutorial demonstrates how to combine instancing with texture arrays to use unique texture for every instance. This tutorial shows how to generate command lists in parallel from multiple threads. This tutorial shows how to use geometry shader to render smooth wireframe. This tutorial shows how to use hardware tessellation to implement simple adaptive terrain rendering algorithm. This tutorial shows how to render multiple 2D quads, frequently switching textures and blend modes. This tutorial shows dynamic buffer mapping strategy using MAP_FLAG_DISCARD and MAP_FLAG_DO_NOT_SYNCHRONIZE flags to efficiently stream varying amounts of data to GPU. This tutorial demonstrates different ways to update buffers and textures in Diligent Engine and explains important internal details and performance implications related to each method. This tutorial demonstrates how to render a 3d cube into an offscreen render target and do a simple post-processing effect. This tutorial demonstrates how to render basic shadows using a shadow map. This tutorial shows how to implement a simple particle simulation system using compute shaders. This tutorial demonstrates how to use Diligent Engine to render to multiple windows. This tutorial shows how to implement bindless resources, a technique that leverages dynamic shader resource indexing feature enabled by the next-gen APIs to significantly improve rendering performance. This tutorial demonstrates how to use multisample anti-aliasing (MSAA) to make geometrical edges look smoother and more temporarily stable. This tutorial demonstrates how to use queries to retrieve various information about the GPU operation, such as the number of primitives rendered, command processing duration, etc. This tutorial demonstrates how to use the render passes API to implement simple deferred shading. This tutorial demonstrates how to use amplification and mesh shaders, the new programmable stages, to implement view frustum culling and object LOD calculation on the GPU. This tutorial demonstrates the basics of using ray tracing API in Diligent Engine.


            1 Vulkan API is not natively supported on MacOS and iOS platforms and requires a Vulkan portability implementation such as MoltenVK or gfx-portability. 2 Available under commercial license - please contact us for details.
            Find more information at:

            Find, review, and download reusable Libraries, Code Snippets, Cloud APIs from over 650 million Knowledge Items

            Find more libraries

            Stay Updated

            Subscribe to our newsletter for trending solutions and developer bootcamps

            Agree to Sign up and Terms & Conditions

            Share this Page

            share link

            Explore Related Topics

            Reuse Pre-built Kits with DiligentEngine

            Consider Popular Game Engine Libraries


            by godotengine


            by photonstorm


            by libgdx


            by aseprite


            by BabylonJS

            Try Top Libraries by DiligentGraphics


            by DiligentGraphicsC++


            by DiligentGraphicsC++


            by DiligentGraphicsC


            by DiligentGraphicsC++


            by DiligentGraphicsShell