@markmris

My renderer is starting to get pretty advanced now! I just finished making the metal/reflective material, as you can see in the photo. I also added gamma correction, which is just square rooting the color output so that the color accuracy and intensity is proper. One issue I ran into was figuring out a weird compiler quirk with override methods, how I wasn’t meant to use the override keyword when defining a function in the .cpp module, but you are supposed to use it only in the declaration in the .h header file.

I fixed one big thing today! Shadow Acne. (Yes that’s what it’s called). This is an issue where a ray starts too close to its origin and accidentally hits itself, causing black freckles all over the image. (As seen in the first photo below). It seemed the only way to fix it was to increase pixel sampling, which is shooting multiple rays at each pixel that are all slightly offset and calculating the average of the colors hit, as seen in the second photo. The downside to this is that it makes the renderer MUCH slower. Image generation jumped from a few seconds to ~2 minutes.

I also spent a decent amount of time getting a better understanding of the pipeline and rendering process. Here’s a rundown of how it works if you’re interested:

1. Start by initializing the camera, image and viewport size, and defining the position of every object in the world.
2. Loop through each pixel in the image.
3. For each pixel looped through, loop through every object in the scene. Run each object’s respective “hit” function to calculate whether or not it was hit.
4. If the object was hit, run the sampling process as explained above. If not, color the sky gradient.

Obviously there’s much more to it but that’s too much to explain.

Today I did some new vector math to generate diffuse materials. The idea is that a diffuse is a surface that is the same color all around it, and not this pixely, but it’s a work in progress. Not much friction today overall.

Today I worked on antialiasing, the process of blending edge pixels with the background to give the image smoother surfaces and to look nicer. Unfortunately, this process makes the renderer a lot slower, meaning it will have to be heavily optimized over time. I also ran into a big issue where the rendered image was black. I found out that I messed up some arithmetic and also had a divide by zero error that didn’t show up.

I finally have a decent graphics engine!

Over the past while, I’ve been cleaning up and reorganizing the entire codebase so it’s much easier to work with and expand. Instead of having everything jumbled together, I’ve split the project into reusable modules and created a central header that keeps the code organized.

The biggest improvement is how objects are handled. Before, adding another sphere or object required changing the rendering code itself. Now, I can simply add a new object to a list, and the engine automatically includes it the next time it renders the image. This makes building more complex worlds much faster and sets up a solid foundation for future features and shapes.

This’ll hopefully someday turn into a game engine or open source graphics engine that will actually generate frames, so it can be used to make video games from scratch!

Here’s the GitHub if you’re interested in following along: https://github.com/markmris/marge

Finally got a chance after exams to continue working on my graphics engine. I spent some time watching videos on vector math to better understand them and how they differ from regular scalars, coordinates, and lines. With my new knowledge I got to work on creating a surface normal, and now my sphere has a VERY ugly blend of colors that give it some visual depth. The concept of surface normals still doesn’t make that much sense to me, so I’m gonna spend more time watching videos and understanding them

I’ve started rendering actual shapes now. The first shape I rendered is a sphere, though it looks like a circle (kind of like the Japanese flag) since it doesn’t have any depth yet. I also discovered and fixed a major bug making the viewport/window a square and the image a rectangle which distorted shapes and gradients.

I implemented raycasts to be used instead of manual color drawings and made a sky gradient. Ran into a bug with the vector math and moved around a few things to fix it, now it works, looks better, and renders faster!