re-drafted first two posts, pretty happy with them now

Author: json-born

config.toml

@@ -10,7 +10,7 @@ theme = 'PaperMod'
   # Homepage info
   [params.homeInfoParams]
     Title = "Welcome 👋"
-    Content = "This is the blog of Domenico Salvia aka json-born, a programmer and all round creative person from the UK. Follow along whilst I chase my lifelong ambition to build virtual worlds."
+    Content = "I’m Domenico (aka json-born). Making video games has been my dream since I first sat at a computer. After 13 years of software work, I’m finally giving it a shot."
 
   # Show read time and word count
   ShowReadingTime = true

content/posts/doom-engine-recreation.md

@@ -9,45 +9,53 @@ cover:
   caption: "Exploring the legendary DOOM engine"
 ---
 
-I've been reading Fabien Sanglard's [Game Engine Black Book: DOOM](https://fabiensanglard.net/gebbdoom/), and it's honestly blown my mind. The book breaks down all the clever tricks behind id Software's masterpiece and makes you realize just how insanely talented those early developers were. Reading about BSP trees has me wanting to build something myself.
+I've been reading Fabien Sanglard's [*Game Engine Black Book: DOOM*](https://fabiensanglard.net/gebbdoom/), and honestly, it has blown my mind. The book breaks down all the clever tricks behind id Software's masterpiece and makes you appreciate just how insanely talented those early developers were. Reading about BSP trees, sub-pixel accuracy and perspective-correct texture mapping has me itching to build something myself.
 
-So that's exactly what I'm going to do.
+So that is exactly what I am going to do.
 
-I'm building an id Tech 1 engine recreation project in C++. This isn't about making a game, it's about learning by doing, understanding how this stuff actually works, and appreciating the engineering genius that Sanglard documents so well in his book. I want to implement the core systems from scratch and really get to grips with how they work together.
+I am starting an **id Tech 1 engine recreation project in C++**. This is not about making a game. It is about learning by doing, understanding how everything works under the hood, and gaining a deeper appreciation for the engineering genius Sanglard documents so well. I want to implement the core systems from scratch and see firsthand how they all fit together.
 
-The plan is deliberately old-school: pure software rendering using [SDL](https://www.libsdl.org/) just as a display window. No modern GPU tricks, no shortcuts. I'll be calculating every single pixel in a framebuffer and pushing that each frame, just like the original engine did back in 1993.
+The plan is deliberately old school: **pure software rendering using [SDL](https://www.libsdl.org/)** as a display window. No modern GPU tricks, no shortcuts. Every single pixel will be calculated in a framebuffer and pushed to the screen each frame, just like the original engine did back in 1993.
 
-## The approach
+---
+
+## The Approach
 
-After a couple of evenings chatting with GPT, I've come up with a rough plan of action:
+After a couple of hours thinking the problem through, and with a little help from GPT-5, I sketched out a rough plan:
 
 ### Foundations
 
-Setting up the C++20 project structure, getting SDL running, and implementing the basic framebuffer system. You can read about this below, aside from some tooling issues, it was pretty straightforward.
+Set up a C++20 project, get SDL running, and draw something. Aside from some tooling quirks, this part was surprisingly straightforward.
 
 ### WAD Loader
 
-This is where things get interesting. I need to parse DOOM's WAD files and extract the maps, textures, and sprites. The WAD format is beautifully simple but requires careful handling to get right.
+This is where things start to get interesting. DOOM stores all of its game data, including maps, textures, sprites, sounds, and more, inside WAD files. WAD stands for 'Where’s All the Data' and is essentially a simple archive format with a structured directory of all the resources the game needs. To bring the engine to life, I will need to parse these files and extract the maps, textures, and sprites.
 
-### BSP & Software Rendering
+### BSP and Software Rendering
 
-This is the big one. Implementing the Binary Space Partitioning system for proper visibility determination, then building the software renderer that draws walls, floors, and ceilings pixel by pixel. Texture mapping in particular looks like it's going to be a real pain.
+This is the big challenge. DOOM’s maps in the WAD file already provide all the geometry in terms of sectors, lines, and vertices, but to render the world efficiently I will need to build a Binary Space Partitioning system to determine what is visible at any moment. On top of that, the software renderer will draw walls, floors, and ceilings pixel by pixel, and getting the texture mapping right promises to be a real headache.
 
 ### Game Features
 
-Player movement, input handling, sprite rendering, lighting effects, and all the other systems that make DOOM feel like DOOM.
+Finally, player movement, input handling, sprite rendering, lighting, and the other systems that make DOOM feel like DOOM. I'm keeping my goals for this section open-ended for now.
+
+I am not trying to recreate every feature or optimize for modern hardware. I just want to understand the clever solutions Carmack, Romero, and the id team came up with given the limitations of early 1990s PCs.
+
+This project feels like the perfect bridge between my web development background and my eventual goal of making games. It is low level enough to teach proper C++ and graphics programming but focused enough that I will not get lost in scope creep.
+
+---
 
-I'm not trying to recreate every feature or optimize for modern hardware. I just want to understand the clever solutions that Carmack, Romero, and the rest of the id team came up with when working with the limitations of early 90s PCs.
+## Laying the Foundations
 
-This feels like the perfect bridge between my web development background and wanting to make games eventually. It's low-level enough to teach me proper C++ and graphics programming, but focused enough that I won't get completely lost in scope creep.
+At the start, I set up a new C++ project in JetBrains Rider. At this point, I was unfamiliar with most IDEs for C++ development, so I figured it did not matter much which one I used, and I defaulted to Rider after reading that it was becoming quite popular for game development. I planned to use CMake for build management due to it's portability, but after wrestling with the configuration for a while, I realized that Rider does not fully support CMake for native C++ projects out of the box.
 
-## Laying the foundations
+I quickly realized that none of this mattered at the moment and that I was wasting time. I switched to Visual Studio and MSBuild instead, which integrates cleanly with vcpkg for dependency management. This made it much easier to get a working project structure up and running, and I can always port the project to CMake later if I want to.
 
-I began by setting up a new project in JetBrains Rider, thinking I could use CMake. After some confusion, I realized that Rider doesn’t support CMake for native C++ projects out of the box — a frustrating discovery, but it quickly led me to switch to Visual Studio, which has native support for C++ and integrates seamlessly with vcpkg, which should hopefully make dependency management less of a headache.
+With the environment ready, I moved on to the first rendering test. For this, I used [SDL](https://www.libsdl.org/).
 
-For those unfamiliar, [SDL](https://www.libsdl.org/) (Simple DirectMedia Layer) is a lightweight, cross-platform library that handles graphics, input, audio, and more. In this project, I'm using it purely as a window and display backend — all the actual rendering will happen in software, which gives me full control over every pixel, just like the original DOOM engine did.
+For those unfamiliar, [SDL](https://www.libsdl.org/) (Simple DirectMedia Layer) is a lightweight, cross platform library for graphics, input, audio, and more. In this project, I am using it purely as a window and display backend. All the actual rendering will happen in software, giving me full control over every pixel just like the original DOOM engine.
 
-Once the setup was complete, I wrote some boilerplate for initializing SDL creating a window and drawing some stuff into it:
+Once the setup was complete, I wrote some boilerplate to initialize SDL, create a window, and draw a simple pixel:
 
 ```cpp
 #include <SDL3/SDL.h>
@@ -108,8 +116,8 @@ int main() {
 }
 ```
 
-Seeing it compile cleanly was a relief after banging my head against google for an hour trying to work out the best tools to use. Heres the end result:
+Seeing it compile cleanly was a relief after an hour of wrestling with tools. Here is the result:
 
 ![SDL3 Test Window](/images/test-window.png)
 
-It aint much, but it's a start...
+It's not much, but it is a start.

content/posts/hello-world.md

@@ -2,23 +2,23 @@
 title: "Hello World!"
 date: 2025-09-19T18:43:00+01:00
 draft: false
-tags: ["Hello World!"]
+tags: ["Hello World"]
 ---
 
-My earliest gaming memory is sitting on my Dad's lap at 4 or 5 years old, firing the shotgun in DOOM while he handled the movement. Even at that age it dawned on me that the monitor was a window into another world...
+My earliest gaming memory is sitting on my dad’s lap at four or five, firing the shotgun in DOOM while he handled the movement. I had no idea what I was doing, and I’m pretty sure the game was way too intense for a toddler. Even so, I remember staring at the screen and being completely fascinated, caught up in this strange new world I didn’t fully understand but couldn’t look away from.
 
-When I was 9 or 10, my Dad asked me what I thought I might want to do when I was older, and without much thought, I told him I wanted to make computer games. When it came time to think about University, I remembered that conversation, said fuck it, and applied to study Computer Science with a specialisation in games at the University of Brighton.
+By the time I was nine or ten, my dad asked me what I wanted to do when I grew up. Without much thought, I told him I wanted to make computer games. Years later, when it came time to pick a university course, I remembered that conversation, shrugged, and applied to study Computer Science with a games specialization at the University of Brighton.
 
-After graduating with a 2:1, a £2k overdraft, £25k in student loan debt and a strong desire to get drunk and make music with my friends, I got my first job as a junior web developer at a tiny start up in Brighton, UK. That was 13 years ago, and I'm still working in the same industry as a Software Architect.
+I graduated with a 2:1, a £2k overdraft, £25k in student loans, and a strong desire to get drunk and make music with my friends. I was passionate about coding, but I wasn’t ready to make a conventional office job the center of my life. My first job was as a junior web developer at a tiny startup in Brighton, UK. That was thirteen years ago. Today, I work in the same industry as a Software Architect.
 
-I'm sad to say, I've barely written a line of C++ since Uni. That mostly stems from fear I think. I have and always have had a genuine desire to create things for myself and for others, but I also fear failure and greater than that, I also fear success. I don't think this is uncommon, it's very typical of Millennials.
+I’m sad to say I’ve barely written a line of C++ since uni. Part of that stems from fear. I’ve always had a genuine desire to create for myself and for others, but I’ve also feared failure, and oddly enough, success. I suspect this isn’t unusual, it seems like a very Millennial thing.
 
-Over the years, my skills as a programmer have really come along. Outside of work, I've hard-committed to numerous creative hobbies at various junctures in my life: music production, martial arts, poker, cooking and songwriting to name a few. I finally feel confident enough in my abilities as both a problem solver and a creative to take the plunge and chase the original dream, to build virtual worlds.
+Over the years, my skills as a programmer have developed more than I ever imagined they would. Outside of work, I’ve dabbled in a bunch of creative pursuits: music production, martial arts, poker, cooking, songwriting. And now I finally feel confident enough in both my problem-solving and creative abilities to take the plunge and chase that original dream: building virtual worlds.
 
-I'm starting this devlog to document that journey. My long-term goal is ambitious but clear: to write and release my own indie game. In the short term, I plan to study the work of the early pioneers and sharpen my C++ whilst doing so, diving deep into programming concepts, game engines, design principles, and probably some maths I should have paid more attention to at Uni.
+This devlog is where that journey begins. My long-term goal is ambitious but clear: to write and release my own indie game. In the short term, I’ll study the pioneers, sharpen my C++, and dive deep into programming concepts, game engines, design principles, and yes, the maths I probably should have paid more attention to at uni!
 
-I'll be documenting everything along the way. The experiments and toy projects, programming concepts as I learn them, design decisions and why they worked (or didn't), tools and resources that actually help, and inevitably, the mistakes and dead ends (probably a lot of these).
+I’ll document everything along the way: experiments and toy projects, programming concepts as I learn them, design decisions and whether they worked, tools and resources that actually help, and inevitably, the mistakes and dead ends, probably a lot of those.
 
-I guess you could say this is my hello world moment for game development.
+You could say this is my “Hello World” moment for game development.
 
-Let's see where I end up.
+Let’s see where it takes me.