Today, I'm going to write a class that represents a texture resource in the low-level render engine. We can use this class to read form texture data while rendering objects. In addition, we can also use it to create textures that can be written to by the graphics pipeline. For example, we can use i…

Previously, I wrote a free-list container which had a vector as its buffer and I ran into the problem of conflicting destruction of items which made it necessary to write our own vector container that has an extra template parameter to control whether the items should be destructed upon deletion or…

Today's video is less related to game engine programming and more about creating utility functions that we need in order to organize the data within the engine. Of course, it's hard to go about without good containers and as we have seen in the previous episodes we're desperately in need of having …

In the last video, I made a render surface class that uses a DXGI swap chain and today I'm going to integrate that class into our low-level renderer, so that we can create render surfaces and use them for displaying each frame. 

?(Red Episode) 

✅ Support Game Engine Series https://patreon.c…

Right now we're in the middle of implementing a DirectX 12 renderer and so far we've created a d3d12 device, a command structure to submit work to GPU, and we spent the last episode writing a descriptor heap allocator which helps us to easily place descriptors in descriptor heaps. Now we've got eno…

In the last video we started implementing an allocator class for managing descriptor heaps. After writing the initialize and allocate functions, we ran into a problem caused by the fact that resources and descriptors can't be removed in an immediate fashion, because we're using a multi-frame render…

In this new episode, I'm going to write an allocator class that keeps track of resource descriptors for our graphics resources. I'll start with a high-level explanation of resources, descriptors and descriptor heaps and will continue implementing the allocator class. (Red Episode)

Support Game Engin…

In the last video, we set up a command queue, command list and a set of command allocators to be used for multiple frame buffers in such a way that enables the CPU and GPU to work in parallel. However, because we have a limited number of frame buffers, we need to synchronize CPU and GPU. In this vi…

Last time, we set up the graphics engine architecture, consisting of a high-level renderer and one or more low-level renderers. We also started implementing a DirectX 12 renderer and, so far, we successfully initialized a Direct3D device that represents the graphics card. In this episode, we'll be …

Previously, I set up the high-level renderer and defined how it would interact with a low-level renderer through an interface. I also added the required headers for DirectX 12 so that we can access its API. Today, I'm going to start with writing the initialization and shutdown code for the D3D12 lo…

Today, after almost a year of game engine programming videos, I'm really excited to finally start working on the graphics renderer! So far we've been defining a lot of general architecture for the game engine and I think that will help us a lot with not getting too distracted during implementation …

Today, we'll finish writing the code that saves the geometry to asset files. The main thing that's left to do is to generate an icon for the 3D object and write everything to a file. 

(Green Episode)

Support Game Engine Series: https://patreon.com/gameengineseries​

Discord: https://discord.gg/75Z…

We spent the last couple of episodes setting up the asset pipeline and started with the geometry asset. We created the content tools to generate and process meshes and also made a control in the editor to visualize the generated geometry. The last remaining part of the pipeline is the ability to sa…

Last time, we wrote a function that successfully generates a mesh for a UV sphere. We also made a user control which we can use to set the properties of the sphere, such as segmentation and size. Today, I'll continue and add a control for the smoothing angle, so that we can have smooth UV spheres. …

Today I'd like to add a new type of primitive mesh to the geometry pipeline, which is a UV sphere. I think this is an interesting exercise to also more thoroughly test the geometry routines. In the first part of this new episode, I'll write the code that will generate the mesh for the UV sphere and…

Previously, we started visualizing the 3D geometry that we got from content tools, the last step of which was being able to move the camera around the object. So, today I'm going to add this functionality to the geometry viewer. But first I'm going to briefly explain a bit about spherical coordinat…

In the last two videos, we set up the geometry pipeline to accept a geometry asset class from the content tools and started working on a WPF renderer so that we'll be able to inspect the generated or imported geometry content. Today, we'll add the viewer control and hopefully see the fruits of our …

Today, we're going to start working on an asset editor class for geometry assets. We'll also prepare for viewing a geometry asset by writing a mesh renderer class. This class will serve as a viewmodel for the WPF 3D viewer that we'll write in the next video. (Green Episode) 

Support Game Engine…

In the previous episode we wrote some of the functionality that we need in the geometry asset class in order to further process the generated or imported 3D meshes. Starting with this video, we'll create a new dialog window that will allow us to tell the content tools what kind of primitive mesh we…

Now that we have the data structures in place for geometry asset, we can go ahead and unpack the imported geometry so that we can process it further in the level editor and finally save it to an asset file. (Green Episode) 

Support Game Engine Series: https://patreon.com/gameengineseries​

Discor…

In this video, we're going to define the geometry asset class which we can use to unpack imported mesh data. (Green Episode) 

Support Game Engine Series: https://patreon.com/gameengineseries​

Discord: https://discord.gg/75ZmXwz​

keywords: mesh, geometry, vertices, asset pipeline, level of detail

b…

Now that we're able to generate geometry using the content tools, we need to send the data back to the level editor so that it can be processed further and saved to an asset file. In this video, I'll finish the last part in the C++ side that's needed to pack and send the data to the C# side. (Red E…

Today I'd like to continue and finish the vertex processing routine. First, I'll write a function to process the UV coordinates similar to what we did for vertex normals. Then I'll pack the resulting vertices in a final format which will be loaded to the GPU and used in the vertex shader. (Red Epis…

Now that we have some initial data for a mesh, we can go ahead and write the processing part of the geometry pipeline. In this video, I'm going to write a function that determines what the normal vector should be at each vertex. Using this function and a smoothing angle we can define soft edges and…

Previously, we defined most of the data structures that we need when we want to import or generate 3D geometry and we also set up the primitive mesh generation and defined some functions that we can use to generate meshes. Today, I'd like to write the simplest one of those functions which will gene…

In this video, I'll set up the foundation for Primal Engine's asset pipeline and we'll start with defining data structures needed for importing and generating 3D mesh geometry. (Red Episode)

Support Game Engine Series: https://patreon.com/gameengineseries​

Discord: https://discord.gg/75ZmXwz​

keywords…

Today we'll finish pretty much everything that we need to do to host and interact win32 windows in the level editor. 

(Green Episode) 

Support Game Engine Series: https://patreon.com/gameengineseries​

Discord: https://discord.gg/75ZmXwz​

by Arash Khatami

---------------------------------------…

In the last video, we managed to host a native Win32 window in the level editor which is a .Net Core application. Because we're doing this to render graphics, we need to update the dimensions of the hosted window whenever it's resized. Today, we're going to look at how we can receive windows messag…

In this video, we're going to use HwndHost class to host a Win32 window in the level editor which is a WPF .Net Core application. We're also going to fix a couple of small issues in the windows platform implementation.

(Red Episode)

Support Game Engine Series: https://patreon.com/gameengineseries​

Dis…

Previously, we kind of finished writing the window framework and also made a program to test it. Today, I'd like to spend a little time cleaning up that code and, in addition, enable the game application to open a main window for displaying graphics. 

(Red Episode) 

Support Game Engine Seri…