—————– 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