—————– Devlog XXIII —————–

– I NEED TO HURRY UP AAAA - EnTT - Table –

To recap, my project is a custom made rendering engine that focuses on diverse rendering options along with high stylistic control (very high-level explanation).

✨ What did I do? ☀️

In my previous devlog, I stated how I was working on the new RenderGraph. I’ve now realized, that I have like until the end of the week for when I need to ship. So instead, my goal is to get this looking impressive.

To start, here is what I’ve done so far:

• Cleaned up system inits
• Changed how the UUID service works (now you just access it and call generate)
• Implemented a new library, EnTT
• Did some cleanning up
• Added a PointLightComponent for future use (no dev. yet)
• Added and implemented the CameraComponent

Here are the big things:

EnTT

EnTT is an open-source library that handles objects within games, editors, etc. It’s creator is: Michele Caini (skypjack on github).

EnTT is a library that exposes something called an Entity Component System (ECS). Basically, instead of saving a bunch of data directly inside of one struct or class, you define an entity (a unique id) and assign that entity components. The components are what actually gives the entity meaning.

New Camera

If you have ever ued Blender for a bit, you would know that your camera is on the same list as your meshes. This is since, to Blender, they are inherantly the same thing (don’t quote me on that).

Previously, my camera was seperate to all of the rest of the objects. This caused the data to be split, and handling the differences made my architecture a bit weird.

Now that I’ve implemented EnTT, I’ve added a CameraComponent that defines things like rotation, FoV, etc - completely erasing the need for a separate camera, and opening the doors to more flexibility.

Thank You for Reading

New book is great! I won’t get to use too much of it for stardance, but I’m checking out this snowglobe thing that seems like it would be the next area!!

Wish me luck on the ship. I want to get it out by the end of the week so I can hopefully still cache in some stardust. Probally won’t get the computer though (high hopes for a living or smthin idk)

Github repo: https://github.com/pkncoder/Engine

Project landing page: https://pkncoder.github.io/Engine

❓ What’s next? 🛑

• Change my Rasterizer to be a Defered Renderer & implement multiple point lights
• UI??

—————– Devlog XXII —————–

– BrEaKiNg ChaNGeS - 📖 NEW BOOOKKKK –

To recap, my project is a custom made rendering engine that focuses on diverse rendering options along with high stylistic control (very high-level explanation).

✨ What did I do? ☀️

Sadly, I’ve done much coding

Base list

This is what I have done since the last devlog:

• Planned out a bit more on the inner workings from no Renderer->Rendered Image
• Created the new Shader & Program classes
• Updated the workings on RendererManager
• Started work on the new Renderer / IRenderer class
• Current commit is now broken (compiles, doesn’t run

Overview

In my new obsidian vault , I’ve been working on creating the new database on how it all works. Through this, I’ve been using excalidraw (Obsidian) to plan out pipelines & create visuals.

Currently, I have 2 main drawings:

• Shader & Program pipeline
• Renderer Pipeline

The Shader & Program pipeline explains the lifetime and usage of both the Shader and Program (OpenGL program) classes. A program gets created, has shaders attached to it (deleting the shader in the process), and then the program gets linked & binded.

The Renderer Pipeline explains the lifetime and usage of a renderer. Starting from the RendererManager, go through normal rendering stuff, and will end at shutting down the RendererManager.

For the inner workings of the new renderer setup, I’ll leave that for (hopefully next devlog) when I get everything working start to finish of the RendererPipeline.

Thank You for Reading

As for the “New Book I got, I have just purchased “Game Engine Architecture Vol. I” (Jason Gregory) to specialize the program more (most likely after Stardance ends).

Github repo: https://github.com/pkncoder/Engine
Project landing page: https://pkncoder.github.io/Engine

❓ What’s next? 🛑

• Plan out the RenderGraph
• Create the base RenderGraph class
• Create the BlitList
• Create the INodeInput & INodeOutput

—————– Devlog XXI —————–

– My brain hurts 🧠 - Sharp like glass –

To recap, my project is a custom made rendering engine that focuses on diverse rendering options along with high stylistic control (very high-level explanation).

✨ What did I do? ☀️

Sadly, I haven’t done much coding

Instead, I’ve been trying to figure out how I want my Render Graph to work.

To start, what is a render graph? What I am interpreting the render graph as, issss: An API meant to simplify and provide structure to a final renderer.

In the final application, the render graph will be an option for a more advanced final render editor. What I am working on now, is how it will be put together so I don’t have a mess in the future.

Recently, I’ve been using Obsidian to mark everything down. This also starts a little docs. Using a mix of Obsidian and the excalidraw plugin, I’m able to write everything down and create visuals.

Currently, I have a mix of nodes that are the main important ones. These nodes are just the interfaces, so they aren’t specified. They act as a blueprint for any of the full nodes.

• IRenderOutput - Add textures to a list of blitables
• IShaderInput - Base input interface
• IShaderOutput - Base output interface
• IShaderNode - Node representation of shaders
• IShaderPassNode - Base shader interface

Thank You for Reading

I haven’t been home enough to create the “big brain wall” which is sad, but at least my stuff is digital.

Github repo: https://github.com/pkncoder/Engine
Project landing page: https://pkncoder.github.io/Engine

❓ What’s next? 🛑

• Setup current program for Render Graph implementation
• Implement IShader, IGPUTexture, etc.
• Create IRenderGraph for the renderers

—————– Devlog XX —————–

– 🌟I have the best one liners 🗿– 🥀 Now I have to be smart??? 🧠 –

To recap, my project is a custom made rendering engine that focuses on diverse rendering options along with high stylistic control (very high-level explanation).

✨ What did I do? ☀️

For the quick overview:

• Fixed the shadow map issue (so angry about this, see below)
• Fixed an issue with textures not caching
• Got the very base implementation of Uniform Buffers

To start off, in the previous devlog I mentioned I was re-writing the shadow mapping.

Shadow Mapping - Rendering a 3d model with the light being the eye. Everything that it can see is not in shadow, everything else is. quick explanation

I was having issues with getting the shadows to work correctly. I had ideas for issues, including: (the model matrix, the renderPackets being in a bad order, the far plane). IT TURNS OUT It was none of these.

Whenever I made the code to compile a geometry shader along the vertex & fragment shader, I just copied my old one and spliced in the code.

Turns out I forgot to swap some variables, and I was putting code in places it should NOT be at. No idea why it didn’t crash, but it fixed my shadow issues very quick .

As for UBOs, I’ll talk about them in a future devlog, when I have everything planned out.

Thank You for Reading

As I said with “Planning out” everything, I’m going to set up a whiteboard - I’ll have to move my 🏳️‍🌈 pride flags 🏳️‍⚧️ :( -

Github repo: https://github.com/pkncoder/Engine
Project landing page: https://pkncoder.github.io/Engine

❓ What’s next? 🛑

1. Refactor
2. Build the big brain wall
3. Do some thinking

🥀 Git Commits🗿

Weird position issue

Saving now, I am so angry about this. I was compiling and overwrigting the wrong code :(

Made the testing for shadows a bit better, and changed the rendering a bit

Fixed issue with textures and full models not actually caching

Removed anoying debug line for shadow transform matricies

Working on getting the ubos working’

Got it to push

First test ubos

—————– Devlog XIX —————–

- 🌲 Textuers 🧚‍♀️ - 👩‍💻 Shadoowwsss 💀-

To recap, my project is a custom made rendering engine that focuses on diverse rendering options along with high stylistic control (very high-level explanation).

✨ What did I do? ☀️

To recap on what I did:

• Got the program to launch to black screen
  • I needed to inject the Asset Manager to a class
• Got objects loading correctly without shadows
• Got textures to load
• Started work on fixing the shadow map

Nothing too crazy has been changed, the texture issues were about some compatibility problems and not uploading to the same index.

The shadow values are uploaded to a 3d texture, where to calculate if an object is in sight or not, we commit triangles based on their position. The problem now is about the far plane, and hitting triangles that weren’t in shadow.

I’m not sure what the problem is, but I’m going to do a bit more looking into it.

Thank You for Reading :3-blahaj-spinning

I still have to fix the shadows issue (obviuosly) but then I can move onto formatting the data (putting it into buffers, creating wrappers, etc).!!

Github repo: https://github.com/pkncoder/Engine
Project landing page: https://pkncoder.github.io/Engine

❓ What’s next? 🛑

1. Write the shadow cubemap geometry shader & ad it to the OpaquePass (temp main pass)
2. Make and debug UBOs replacing base uniforms
3. Refactor / clean
4. Create the real Render Graph?

🥀 Git Commits (shortened)🗿

Commits: https://github.com/pkncoder/Engine/commits/Phase-IV/

Most Recent:

Temporary Save

—————– Devlog XVIII —————–

- 🌲 Trees 🧚‍♀️ - 👩‍💻 SO MUCH REWRITING 💀-

To recap, my project is a custom made rendering engine that focuses on diverse rendering options along with high stylistic control (very high-level explanation).

✨ What did I do? ☀️

These last few days, I’ve been working on getting my Rasterizer (drawing triangles of a model on screen and coloring them) working.

The big changes that I did include:

• Fixing an issue with textures not loading
• Updated the Interface for every Renderer.
• Implemented the extract / prepare / dispatch pipeline into the Rasterizer for real now.
• Started working on the base ideas of a “Shader Graph”

The issue with textures was just moving a line like 3 lines lower. I was freeing the image data before saving it (oops).

The updated interface is the IRenderer class. Each Renderer bases off of the class, supplying it with a framework so each Renderer can be talked to the same way. Here are some of those functions:

1. beginFrame - Clear previous frame data and prepare for a new frame
2. extract - Take raw scene data (camera, renderables) and convert it into packets for the next step.
3. prepare - Take each packet from extract and turn them into draw commands for dispatch.
4. dispatch - Take each draw command and send a draw call, along the way binding any textures & uniforms.
5. postProcess - Take the frame and post-process it. This may be removed.
6. present - Take the rendered frame and show it to the screen (blit it).

To do a quick review on what the Shader Graph is - it is a collection of “nodes,” each with their own inputs and outputs that connect together to render out a frame.

I’m still a bit confused, but I’ve been watching presentations on the topic from companies like Unity & Activision.

Thank You for Reading

Yea, I know it’s been a while since my last devlog. I’ve been making some posts in slack about my Path Tracer, since I spent a little time on that.

I’m looking at the timing for everything, the hope is to ship this at the end of Phase-IV and hope that I can get a UI working before too late. I’m hoping I can get enough stardust to pay for a new laptop, but idk that’s a long shot. I still have about 25 more hours if I get a 16x mult (which I can only hope for) before I would hit the mark for the FW 12, which isn’t crazy (the mult is tho).

Github repo: https://github.com/pkncoder/Engine
Project landing page: https://pkncoder.github.io/Engine

❓ What’s next? 🛑

1. Stop the program from crashing to reach a black screen
2. Rewrite shaders to allow for correct models wo/ shadows
3. Write the shadow cubemap geometry shader & ad it to the OpaquePass (temp main pass)
4. Make and debug UBOs replacing base uniforms

🥀 Git Commits (shortened)🗿

https://github.com/pkncoder/Engine/commits/Phase-IV/

—————– Devlog XVII —————–

- Strange Hours -

To recap, my project is a custom made rendering engine that focuses on diverse rendering options along with high stylistic control (very high-level explanation).

✨ What did I do? ☀️

To start off, I did not work directly on my application, but the online demo. It’s like working on the website, but through another editor sometimes.

The goal of the Path Tracer is to eventaully get it clean & quick enough to be real-time. This is the first of the 5 renderers that I will be making.

I was working on my online shadertoy DEMO for the Path Tracer, specifically the denoiser. The name of the denoiser I am using is the “Edge-Avoiding Á Trous Wavelet Transform”.

As a quick overview:

• It applies a blur “with holes” to allow for less to no image distortion
• Fast enough for realtime
• Includes “weights” based on (in my code): Normal, Depth, and Color. The larger the difference between the center pixel and the scanned pixel* (kernel), the more weight is applied, lessening the amount of blur.

This is amazing, however when the camera moves, the denoiser assumes that the current and previous pixel are in the same world postion (when it isn’t). This causes errors when trying to overlay the image and gather data. This is why we track the motion of the camera, creating a vector to get the same world position pixel.

I got this wrong on one of the first attempts, the last attachment (videos are compressed) shows that fun video (warning for those who get motion sick).

With this, I am able to blur the image, and with some more techniques, I can get rid of “ghosting.”

Thank You for Reading

In the videos, I rendered them in fullscreen 4k on my better laptop+GPU, don’t worry about your system being too slow, just don’t fullscreen it <3 (the development was done on my lower end mac).

The hours logged are from refactoring the project after the last devlog, and editing the code when I didn’t do it in shadertoy’s editor.

Github repo: https://github.com/pkncoder/Engine
Project landing page: https://pkncoder.github.io/Engine

🥀 Git Commits 🗿

BREAKING CHANGE - Refactored Buffer & GPUResource managers + IRenderer - Code has been broken for a bit but womp womp

Shadertoy shaders path tracer https://www.shadertoy.com/view/7fBSzR

—————– Devlog XVI —————–

• So long, gay Bowser ⭐️ – IRenderer, hardly know her? -

To recap, my project is a custom made rendering engine that focuses on
diverse rendering options along with high stylistic control (very
high-level explanation).

✨ What did I do? ⭐️

BEFORE ANYTHING - Thanks so much to @AVD for the super star, wasn’t expecting it and I really appreciate it 👏 👏.

Now, for what I did:

• Dealt with an issue in Obsidian, as apparently there was “minor rendering performance improvements.” This is FALSE :( - I just downgraded the version
• Created the new BufferManager to handle UBOs, SSBOs, VBOs, EBOs, etc. + Dynamic, Static, and Stream buffers.
• Integrated the RenderTarget & ShaderPass system from PathTracer straight into IRenderer + added base utilities to it.
• Did some formatting

Overall the two big things that I did was the new Buffer system & the updated IRenderer interface.

For the new Buffers, previously I had UBOs (dynamic values) & SSBOs (big mostly static information blocks) set up in seperate files, that BufferManager returned. Now, every buffer is a single struct called GPUBuffer, and GPUBuffer has a type, and a usage (see attached photo). Now everything is centralized on that.

For the new IRenderer interface, now there are RenderTargets - textures that shaders write to as output - and ShaderPasses - A pass of a shader. These can be added to a registry, keyed by a UUID (big number, in this case).

Thanks for reading

Again, thanks so much to AVD for the super star!

I’m excited for when I can finally start writing my shaders, it’s getting closer & closer!! The fancy Path Tracer will be cool and all, but I have big plans for the Ray Marcher!!

Github repo: https://github.com/pkncoder/Engine
Project landing page: https://pkncoder.github.io/Engine

🥀 Git Commits 🗿

Fixed an obsidian issue I ran into, “Minor rendering performance improvements.” was NOT true, broke almost the entire canvas. Fixed it though + new png

Created the new buffer managegr system, I need to go through and make changes. Also, on launch there was more blacked out sections, different every launch :(

New IRenderer setup for the render targets & render handles

Refactor 1-6

Refactor 7-9 for BufferManager

—————– Devlog XV —————–

– Temp code go brrrrr 🔋 - New term: “Far Landing” –

To recap, my project is a custom made rendering engine that focuses on
diverse rendering options along with high stylistic control (very
high-level explanation).

✨ What did I do? ☀️

I tried getting this out before 4 hours, but it just –wouldn’t__ happen. Weird errors kept popping up (mostly being my fault).

Here’s a list of what I did:

• Figured out generally how I was going to deal with uploading and caching meshes + textures
• Put the new GPUResourceManager class into place to do the previously mentioned job
• Started reworking the renderer pipeline (NOT THE RENDER PIPELINE) on CPU side, and set up the interface class with that
• Patched together the old Rasterizer renderer to work with the new IRenderer pipeline
• Fixed errors throughout
• Split up normal & bump textures
• Planned out how I will deal with all the different textures on the shader side, cutting the checks out at shader compile time

Yea, I know, it’s a lot. It just felt wrong to create a devlog in the middle of everything, since up until after fixing errors I had nothing to show for it. :(

I ran into this errors when fixing those errors, where the entire model (I was using the Sponza scene, check the attached video) was banded, where parts “didn’t exist” and the other bands did. This reminded me a lot of the “Minecraft Farlands” specifically the pocket edition ones.

🔥 What didn’t I do? 💥

To keep this brief:

• Fully split up the SSBO system in the BufferManager
• Reimplement good use cases of UBOs (although I did put in place double buffering)
• Add the more sophicticated data handling in the PathTracer (as I commented it’s existance out so I could complile).
• Figure out how shadow mapping is going to be cleaned up in the Rasterizer.

❤️ Thanks for reading!

These devlogs have been getting more attention, and I’m getting closer to doing a rebrand to finally get my point and final ideas across! :3

Github repo: https://github.com/pkncoder/Engine
Project landing page: https://pkncoder.github.io/Engine

🥀 Git commits 🗿

Patched in the “new” buffer system - Really just to get it to compile before I do anything big. Attempting to run the app to test resources & scene

Well it compiles, runs, and renders. I still need to go through all the models, HOWEVER, I am having an issue with like 3 models in sponza and bump UGH

Well, I checked Phase-III, and the issue with those models are there too, probally some texture coord issue or the bump map is messed up (I’ll check in blender), BUT THEN ON FIRST LOAD THE MODEL FRA LANDED????

—————– Devlog XIV —————–

The Planning - The possible NEW NAME??? - The New Project!!

To recap, my project is a custom made rendering engine that focuses on diverse rendering options along with high stylistic control (very high-level explanation).

✨ So What Happened? 📸

I haven’t done much pure coding, HOWEVER, I am getting ready for some large-scale rewrites and additions to the code. For what has happened:

• Fully sectioned the resource - disk - and scene - cpu/logic - directories (folders) so there wasn’t any GPU actions taken place.
• Refactored resource and scene directories
• Re-implemented Application into CMakeLists so I can compile and link that file.
• Did some planning for the huge renderer rewrite that is coming up.

Along with all of that, I came up with a possible name for the application (since, surprisingly, Tempname: Engine is a temp name) I had it when when gazing at the sun through some clouds over a feild. Although it is super basic, so I’m going to have to play with it.

❤️ Thanks for Reading!!!

I might have to take a bit of a break from progress on this project, as I have a website that I’m making for my local fire dept. (look out for a new stardance project)!

I’m also planning on doing some re-marketing / re-branding (idk what to call it) to change the descriptions of the project (ex. the “To recap section on my devlogs, and the landing page). I’ve been getting more questions on it, and my current explanations are a bit too much.

Github repo: https://github.com/pkncoder/Engine
Project landing page: https://pkncoder.github.io/Engine

🗿 Commits 🥀

(top-oldest : bottom-newest)

No more mention of buffer manager or any uploading to gpu in scene
& assets. Meshes are now split up from models in the cache, models
hold refrences to asset handles to meshes.

Refactored and fixed errors in scene and resources. The program won’t work, as only scene and resources are being compiled & linked

Added application back into the mix & fixed the scene loading section.

Did some planning on how a model will go from spawn to render

—————– Devlog XIII —————–

Spent some time off from working on this project, started the beginnings of another one. Finally ended up getting the interest to come back to this one

To recap, my project is a custom made rendering engine that focuses on diverse rendering options along with high stylistic control (very high-level explanation).

💡 Overview

Commit message for this devlog:

BREAKING CHANGE - New asset system, new scene system, renamed SceneLoader to PrefabSpawner, still need to update rest of code with temp fix until reworking for new system.

✨ What did I do?

Previously, the asset manager did still handle caching already loaded assets (models, materials, textures), however the implementation was not professional and temporary:

• Caching based on a string key (slow)
• Broke the “single responsibility principal” many times by uploading to the GPU & constructing Scene objects

Now, I am using AssetHandles (UUIDs) for caching, and I no longer uploading to the GPU in AssetManager.

❌ What didn’t I do?

This new system is a good start for realigning and separating the different parts of the program, but is only about a third of the work. For what I still need to do, this is what follows:

1. Stop uploading to the GPU in the PrefabSpawner (scene)
2. Fix the renderer and find where I will upload the mesh & texture data.
3. Check for compilation and working across the whole project.
4. Change every instance of AssetManager to using AssetHandles.

Once I have these, I can move onto redoing the renderers and FINALLY start working on the “fun stuff”

❤️ Thanks for reading

Github repo: https://github.com/pkncoder/Engine
Project landing page: https://pkncoder.github.io/Engine

—————– Devlog XII —————–

I haven’t done as much programing recently, but yesterday I wanted to finish what I needed to do quickly, as it wouldn’t take that long.

To recap, my project is a custom made rendering engine that focuses on diverse rendering options along with high stylistic control (very high-level explanation).

🎯 UUIDs

For a quick explanation of what a UUID is: UUID stands for Universally Unique Identifier. In practice it is a random alphanumeric (a-z,0-9) ID between 64-128 bits.

For my project, I used an unsigned 64 bit integer (no negative numbers). It isn’t exactly what the standard for a UUID is, as it isn’t alphanumeric, but I think for now 18.4 quintillion ids are just fine.

⬆️ What Next??

Now that I’ve finished this, the next step is to gut & rewrite the entire asset managing system. I need to redo how files are found, how data is stored, how they are retrieved. Basically the CRUD (create, read, update, delete) line and more.

❤️ Thanks for reading

Github repo: https://github.com/pkncoder/Engine
Project landing page: https://pkncoder.github.io/Engine

—————– Devlog XI —————–

I haven’t been programming as much, as marching band 🎺 has started,
so I’ve had less time. But now I can do the really exiting stuff!

To recap, my project is a custom made rendering engine that focuses on
diverse rendering options along with high stylistic control (very
high-level explanation).

What did I Do?

As I mentioned in the last devlog, I have been working on doing a full passthrough of the entire project to get ready for major rewrites. I have completed by refactor checklist, so I have gone through ever cpp file to:

• Fix warnings
• Check object method & attribute visibility
• Check const, static, and inline declarations
• Change the placement and formatting of method
• Going through every line of code to do minor logic changes & change formatting
• Rename methods, attributes, functions, and variables to better names & names w/ personal conventions.
• Add comments everywhere
• Change the placement of the #include statements (main header file, object interfaces, project files, project packages, extra C++ headers)
• Run a full clean, compile, and test of the application

The LIE

Technically I didn’t go through every file, as I left AssetManager & Rasterizer. Since these will be completely rewrote soon I felt like it was a waste.

What next?

Now that I have finished cleaning up the code base, the next projects are to:

1. Move to using UUIDs instead of an entity index in scene
2. Gut AssetManager and rewrite it
3. Change to using metafiles instead of a preditermined path to assets
4. Rework the scene class
5. Extend IRenderer and get ready for the fun part!

Thanks for reading!

I tried to keep this one shorter for y’all. I don’t normally get too much attention to my devlogs, but I would be more than happy to answer any questions, as there is so much more to this project that even the landing page doesn’t cover (WIP).

If you’re curious, feel free to reach out on slack (pkncoder), and here are some extra links about the project:
Github repo: https://github.com/pkncoder/Engine
Project landing page: https://pkncoder.github.io/Engine

—————– Devlog X —————–

I’ve been working on refactoring my project for the last few hours. Part of how I code includes: Comments throughout to explain the code, strict formatting throughout, and trying to help the compiler with “const” and “inline” keywords.

To recap, my project is a custom made rendering engine that focuses on
diverse rendering options along with high stylistic control (very
high-level explanation).

The process

My process of refactoring usually happens once I finish a new addition, however I haven’t been adding new things for a while. Now that I’ve added a new addition to the project (Event system & LayerStack), I want to go through the entire codebase under the src/ directory (not the glsl shaders).

Project code stats (src/ directory)

Running the command line utility “cloc” on my src/ directory to count code stats, I get these counts:

-------------------------------------------------------------------------------
Language                     files          blank        comment           code
-------------------------------------------------------------------------------
C++                                  23              646               464                  1930
C/C++ Header              47              506               205                  1302
-------------------------------------------------------------------------------
SUM:                               70             1152               669                  3232
-------------------------------------------------------------------------------

Not very big yet, although that will be increased once I get to redoing the entire rendering engine.

What I have done

Now, back to my refactoring. I got through the basics: removing warnings, double checking the public/private attribute declarations on classes & structs, setting const on functions & params, setting inline on functions.

The checklist

This is my entire checklist for refactors, this is my first project using it, so it is still being worked on:

### Refactor Checklist (src/)

1. [x] Fix warnings
2. [x] Fix public vs. private
3. [x] Make functions const when needed
4. [x] Make function params const when needed
5. [x] Make functions inline when needed
6. [ ] Fix placement of functions
7. [ ] Refactor step by step in code
8. [ ] Rename things
9. [ ] Add comments
10. [ ] Place the \#includes in the right spots
11. [ ] Fix file tree
12. [ ] Run ```./fullTest```
13. [ ] Update the obsidian canvas & png
14. [ ] Update the website

Eventually I will also need to make one for the shaders too, as they are sometimes more technical on the code side.

Conclusion

That’s all that I’ve been doing, thanks for reading. Here is my Github repo & landing page for this application:

Source Code: https://github.com/pkncoder/Engine
Landing Page: https://pkncoder.github.io/Engine

Devlog IX

I have been working the past week to get the Event system working & trying to fix pointer / referance issues (there are still a few I haven’t figured out).

But now I have a working event system.

To recap, my project is a custom made rendering engine that focuses on diverse rendering options along with high stylistic control (very high-level explanation).

LayerStack recap

In my previous devlog, I explained the Layer Stack 🥞, a top-down structure for controlling object ownership and main loop execution. Every frame, the layer stack runs the first layer to poll camera movement inputs (temp), and then next layer is ran to render out the frame through the RendererManager.

Events

This is great, but where the layer stack really shines is the event system. Events are reactions to when anything happens, keys being pressed / released, the window resizing, etc. When an event is dispatched, the layerstack stops, loops through each layer running it’s “onEvent” function to let that layer react (ex. the final render needing it’s texture resized). If a layer doesn’t want below layers to react to the event, it can consume it, stopping the event dispatching and continuing execution.

Struggle and Pointer Nonsense

I struggled a ton with the event state not updating correctly, and the camera not giving the right values to render the triangles. It turned out to be objects/classes duplicating, and not being able to update. There is so many debug messages in the terminal 😭

Ends

This was all front-end changes (no change in the render), but now there is a better system put in place (back end changes).
Github repo: https://github.com/pkncoder/Engine/tree/Phase-IV
Landing page / Website: https://pkncoder.github.io/Engine/

Tempname: Engine update. I am so tired

To keep it all contained, since the last devlog I have:

• Merged Phase-III into main & created a Phase-IV branch
• Changed the landing page’s color palette
• Modified the target architecture 4 times (3 committed)
• Created a rudimentary SceneManager class
• Implemented an EngineContext class to distribute ownership & to help with data flow+containment
• Implemented a layer system to help cut down on application & to contain/host the events system.
• Finally put in the system directory (folder) in the architecture that will host any simulations, computations, and animations. Currently it is the planned details for the camera system.

The biggest thing that I have done so far is the layer system & state/context creation.

The context of the engine lets managers talk to each other so everything can work together, while keeping everything contained.

The state is split up into two parts, state & settings (or state & configuration). The state is meant for information that is meant to change throughout runtime, and the engine depends on it to render the right final result (ex. camera state & position).
The settings part is meant for variables that won’t change too much, but if they do it is something that is a large modification to the runtime (ex. window title, rendering engine).

The layer system is like a regenerating stack of pancakes 🥞. Before you cast your pancake regeneration spell we all have, you have to prep the pancakes with butter and syrup. Each time you finish the pancakes, a new round starts and you eat them again. Then, once you are done, you have to disable the regeneration spell.
The layer system acts the same, but computationally & layers instead of pancakes. Each layer goes through the lifecycle of onAttach -> onUpdate -> onDetach.

By far the biggest reason for the layer system is the event system, but I’ll leave that for the next devlog.

Here is the github page: https://github.com/pkncoder/Engine/tree/Phase-IV
Here is the landing page: https://pkncoder.github.io/Engine/

I still have soooo much to do, especially with & after the event system. I’ve completed most of the easy stuff for Phase-IV.

Here is the current architecture & a site screenshot.

Changed my mind on shipping, however I do now have a landing page!

I still have to do things like changing the color palette (it’s alright now, but I want something different I think), adding little details to really sell the “Rendering” aspect of Tempname: Engine, etc. etc.

Here’s the landing page, please check it out & give any feedback! https://pkncoder.github.io/Engine/index.html

Since I changed my mind on shipping, here are those images that I was going to use!

Just got done with some renders on the engine, been working all day on implementing the things needed.

Along with the images, I added:

• Shadow Mapping for the Rasterizer (only 1 emitter)
• Tone mapping to the Rasterizer
• Fog to the Rasterizer
• A vignette effect to the Rasterizer
• Transparency maps to the Rasterizer
• Settings & presets for the renders
• A new “Queer Room” modeled by me in blender for the Path Tracer (going to post it on ship).

I honestly have had so much fun with this. Currently working on a landing page to go in place of my “Online Demo” on stardance (since this isn’t that kind of application D: ).

Here’s the github: https://github.com/pkncoder/Engine/tree/Phase-III! At some point I’ll be redoing the README as well for more info.

Also, these images aren’t even the best ones, I’ll leave that for the ship :3

I’ve done a bunch more Todos in my code, getting ready for shipping Phase-III. However, I realized I forgot in my planned Architechture about Acceleration structures (which are very important). So I planned that out!

Currently just:

• BVH (Bounding Volume Heirarchy) for Ray & Path Tracing
• SVO (Sparse Voxel Octree) for Ray Marching (Hypothetically)

These acceleration structures make rendering methods like Ray & Path Tracing, Ray Marching, Ray Casting, etc. feasible for real-time by “cutting out” data (objects) similar to how a Binary Tree works.

Next is more clean up, then creating models for some renders I can use in the banner of this + the github Readme, and finally creating a landing page to put in place of the online demo! Then I can finally ship!!!!

Here’s the github (ignore main branch): https://github.com/pkncoder/Engine/tree/Phase-III.

Working on finishing the current development phase, of my project, which also means finally shipping Tempname Engine: Phase-III.

I wanted to plan out Phase IV a little bit more, which will focus on:

• Getting a structured scene management system
• Improving the Renderer (ability & architecture) + adding 2 new Renderers
• Adding scene loading & serialization (and “asset serialization” which is weird name)

Here is the current & planned architectures of Phase III & Phase IV, at some point I need to redo Phase-III’s to match the style, but I’m tired of working in obsidian to not even get the hours logged.

I have finished getting albedo (basic color) textures loading!

To get this working I had to redo how meshes were loaded completely, but I finally finished that. The backrooms model was an issue, as I needed to find one that would work, and then fix it in blender, but I’m glad it’s rendering!

As for the promised model of the oiiaioooooiai cat 🐈 (Ethel), I did get the model & textures, but I will have to mess with it more, as the model & texture do not line up yet.

If you would like to try for yourself, the github repo is here: https://github.com/pkncoder/Engine/tree/Phase-III.

The repo is large currently, as I still need to compress the files, or remove them (gitignore).

The path tracer is currently disabled, as I need to swap the textures to handles, and then modify the path tracer to work with the textures. It will look really good once I get that working though!

I haven’t done much work on getting textures or anything, however I was able to re-do the shaders. Just some framework stuff like abstracting the shader models so each renderer can implement them to their need. I also spent some more time getting some generic formatting stuff like naming conventions (mostly naming conventions)

I also made an “architecture” diagram, as I was requested for one (plus I needed one anyways).

• Anything purple (besides the background) is a temporary connection/file.
• Anything green needs re-worked
• The “Services” group contains files that are completely static in use, and are accessible globally.

It’s still a bit messy, but that’s partly due to the temporary/need re-worked files. There’s a still some spaghetti code due to that. The shader files do look a lot like spaghetti as well, but that is mostly do to positioning.

It’s pretty basic, as the ui/ and system/ dirs aren’t in there either (system/ is simulations + any computations that would need to be done (ex. translating data for one renderer to another)).

I made the image in Obsidian’s canvas, sadly the wakatime add-on wasn’t working for me, so that time didn’t get counted, but oh well. And if the image is cut-off for you, the Services block has Input.cpp, Timer.cpp, and Logger.cpp.

I still have a lot of shader work to redo, but I might try to get textures working soon for the Rasterizer, as I’m wanting them more & more.

Hey everyone, I’m Kia! 👋 I’m currently building a custom 3D Engine from the ground up. While it’s definitely a fun passion project, it’s designed to be a genuinely powerful and useful tool.

The scope of this project is pretty massive, but here are the main goals I’m chasing right now:

• 🎨 Multi-Style Rendering: I want this engine to render scenes in highly stylized ways using a variety of techniques. Currently planning support for:
  • Rasterization
  • Path Tracing
  • Ray Marching
  • Ray Casting (Voxels)

• Simple and easy: No one likes being thrown to the wolves. The engine will feature a clean, simple UI that scales in complexity as you learn how to use it, rather than overwhelming you right at the start.

• Accessible Animation: Built-in tools for animations and simulations that are actually easy to understand and use.

🛠️ Latest Update: Path Tracer Rewrite
I recently did a complete rewrite of the Path Tracer! This was a massive step to future-proof the engine. It now supports multiple shader passes, debug textures, and is fully prepped for texture mapping.

Why am I so excited about getting textures working? Because the second they drop, I am immediately rendering 1) The Backrooms 🟨 and 2) the spinning “Oiiaioooooiai” cat 🐈. Texture support should be ready very soon!

Want to check it out (please do)?

• 💻 GitHub: Check out the code and the todo.md to see what I’m working on next: https://github.com/pkncoder/Engine/tree/Phase-III

• 🎮 Live Demo: Try out my almost real-time Path Tracer right in your browser (click and drag to look around): Shadertoy Path Tracer Demo: https://www.shadertoy.com/view/7fBSzR