Catlike Coding

The Set Terrain Type Job is the next one to become a true Burst job. The specific trick needed in this case is pulling the noise texture sampling out of the job, caching it in a native array beforehand. Hex Map 5.7 - Set Terrain Type Burst Job (Catlikecoding)

We convert our second map generation mock job into a true Burst job! We have to make some changes to make hex coordinates work with Burst and port some grid functionality to Burst as well. Hex Map 5.6 - Create Climate Burst Job (Catlikecoding)

We continue the modernization of our shadows code, pulling it out of the lighting pass and splitting it into three passes. Custom SRP 7.2 - Separate Shadow Passes (Catlikecoding)

Last time we created an experimental map generator and split it into multiple mock jobs. This time we convert the first job into an actual Burst job. We start with the simplest job, which requires the least amount of changes. We'll tackle the increasingly complex other jobs in the future. Hex Map 5.

Our shadow handling code has always resided in a single class, which took care of both directional and other shadows. Because those two shadow types are handled separately we now give them their own classes. This is a rather dry refactor, but it paves the way for giving them dedicated render passes

It is time that we modernize the map generator. The class that does it is a monolithic thing that does a lot of work. We're going to split it up into mock jobs, which will become true Burst jobs in the future. We also take a look at generation inconsistencies between Mono and IL2CPP builds. Hex Map

Unity 6.5 has been released and of course it breaks our SRP again. But the fix is simple. We officially lost LPPV support with this update, but we'll add support for the superior Adaptive Probe Volume system in the future. Custom SRP 7.0.0 (Catlikecoding)

This time we change our color LUT into a true 3D texture, which we fill via a compute shader. Custom SRP 6.2.0 (Catlikecoding)

Want to see the color LUT used by a camera? Now you can! We add a debug visualization for it. This will come in handy when we modernize the LUT, which we'll do in the future. Besides that we also fix rendering when a camera is set to render to a texture. Custom SRP 6.1.0 (Catlikecoding)

We follow the previous menu upgrade with the final menu to replace: the Save/Load menu. This completes our migration to UI Toolkit. Hex Map 5.2.0 (Catlikecoding)

This time we create a new... New Map menu. We continue with the process of replacing the old uGUI system with UI Toolkit. This is a small tutorial, which will be followed soon by another one taking care of the Save/Load menu. Hex Map 5.1.0 (Catlikecoding)

This time we upgrade Hex Map to use the new input system. We do this because we move on to Unity 6.3 and the old input system is now deprecated. This makes our code input-agnostic. We're working with high-level actions, which we bind to specific user inputs via the input system asset. Hex Map 5.0.0

We upgrade our Custom SRP project to Unity 6.3, and... it fails to render. So we fix that! Native render passes are now supported and we get the Render Graph Viewer working again. Custom SRP 6.0.0 (Catlikecoding)

This time we add windows to the walls of the maze, so we can see through them. Maze 5.1.0 (Catlikecoding)

This take we convert some of our unsafe passes to more restrictive raster render passes. This will allow more efficient pass management and rendering in the future. Custom SRP 5.1.0 (Catlikecoding)

This time we have a small tutorial, to improve the player experience when editing maps. We make drawing rivers more pleasant. In general, I'd like to do more frequent smaller tutorials going forward, making each one more focused on a single feature. Hex Map 4.1.0 (Catlikecoding)

We spice up our maze with ornaments, making it more interesting to look at and a bit easier to recognize areas we've already visited before. Maze 5.0.0 (Catlikecoding)

This time we make the jump to Unity 6.1 and migrate to using more specific pass types. (This tutorial came out in May, but the Patreon post ended up missing, hence it is late.) Custom SRP 5.0.0 (Catlikecoding)

We finally make the jump and upgrade our Hex Map project to Unity 6... and it just works. We also replace the old uGUI panels with new UI To We finally make the jump and upgrade our Hex Map project to Unity 6... and it just works. We also replace the old uGUI panels with new UI Toolkit ones. Hex Map

We're upgrading Maze to Unity 6 and take this opportunity to replace TextMesh Pro with UI Toolkit. Maze 4.0.0 (Catlikecoding)

We open our RP in Unity 6, are greeted with a bunch of errors and a stream of warnings, then make everything work again. We can now finally use renderer lists for the skybox and shadow casters, no longer needing to fall back to old API calls. Shadow caster culling is done all at once, no longer inte

This time we simplify a few things. We consolidate some shadow setting and also remove the lights-per-object mode. This is in preparation for the migration to Unity 6, which will officially release next week. Custom SRP 3.2.0 (Catlikecoding)

It's been a while, but we're getting back to the Maze project! This time we're changing how we build cells, making things both simpler and more flexible. Maze 3.0.0 (Catlikecoding)

This time we make our Forward+ render configurable, adding settings for tile size and max lights per tile. We also hide the deprecated settings and mark the lights-per-object mode as obsolete. As we move forward and get closer to Unity 6 the goal is to make things as simple as possible before switch

I have upgraded the True Top-Down 2D project to Godot 4.3, which was released last week. Besides updating a few things in the written tutorials, the main change is the replacement of TileMap with TileMapLayer. True Top-Down 2D (Catlikecoding)

We've been on a quest to get rid of the cell objects. Today we complete that quest, by turning the remains of HexCell into a struct type. Hex Map 3.4.0 (Catlikecoding)

We bump the major version up to 3, because we added a simple implementation of Tiled Forward+ rendering. This can make rendering much more efficient when there are many visible point and spot lights. Custom SRP 3.0.0 (Catlikecoding)

We switch to storing cell data in arrays, using a new HexCellData struct type. Then we decouple map generation and visualization from the HexCell class. Getting closer to cells without objects! Hex Map 3.3.0 (Catlikecoding)

We replace the old structured buffer arrays for light and shadow data with structured buffers. Custom SRP 2.5.0 (Catlikecoding)

We continue the downsizing operation for hex cells. This time we extract the search and visibility data from it, moving all that to the grid. This requires us to refactor all search-related code. Hex Map 3.2.0 (Catlikecoding)

We start 2024 with finalizing our RP's migration to the Render Graph API. In this case it's mostly moving code around so the tutorial paints with broader strokes than usual. With that out of the way we can move on to modernizing other parts of our RP as well. Custom SRP 2.4.0 (Catlikecoding)

This time we compact cells some more, Storing seven configuration values in 32 bits. We also simplify the cells some more and fix a bug. Hex Map 3.1.0 (Catlikecoding)

Previously we let the render graph manage our camera render textures. This time we do the same for shadow textures. We also get rid of the separate Lighting class, merging it into LightingPass. What's left are Post FX, which will come later. Custom SRP 2.3.0 (Catlikecoding)

The next Hex Map tutorial is here and we've incremented the major version! That's because we've upgraded to Unity 2022. But the big thing is that we've done away with cell game objects, they're now regular serializable classes. That gets us one step closer to making cell compatible with Burst jobs.

After introducing renderer lists we now introduce texture handles. We let the render graph manage the render textures for the color and depth attachments as well as their copies. While we adapt our passes to work with these we also decouple them from CameraRenderer. Shadow maps and post FX will also

Here's a new Maze update that adds beveled corners, to make it a bit less blocky. This tutorial is much shorter than 2.1.0, as we only have to add prefab variants and tweak occlusion a little. Working on these in project form makes it much easier to iterate on them, so I'm going for more frequent an

It's been a while, but here is a new release of the Hex Map project, with accompanying tutorial. It starts the process of reducing the memory size of HexCell. We're working toward it no longer being a game object. Hex Map 2.3.0 (Catlikecoding)

This tutorial introduces renderer lists, which is an alternative way of drawing geometry that makes it possible for the render graph to cull passes. Yes, the screenshot is very old. It is the image of the first tutorial in the Custom SRP series. Custom SRP 2.1.0 (Catlikecoding)

The Maze 2 prototype tutorial has become a project! This first 2.1.0 tutorial release adds the occlusion system that I already hinted at earlier. This can significantly reduce the amount of work needed to render the scene. Maze being a project now makes it possible to add such features and more can

I have written tutorials to accompany the releases of the Hex Map project, like I did for Custom SRP. The released versions so far are 2.0.0 URP, 2.1.0 Code Cleanup, and 2.2.0 Cell Visuals Upgrade. The last one is a good starting point as it is the first to introduce new functionality while the othe

Version 2.0.0 of our custom SRP makes the switch to exclusively using the Render Graph API. This is just the first step, with minimal refactoring to rely on the API. Proper usage of it and better code separation will follow in the next versions. Note that this, like all future releases, is both a pr

The Custom SRP tutorial series has seen some changes! First, I upgraded the entire series to Unity 2022. These are minimal changes that I point out throughout the series, so you'll see them if you work through the series now. Second, I have created a Custom SRP project that has the latest FXAA tutor

The Hex Map 2.2.0 release is now available. It brings a few visual improvements: better per-vertex feature visibility, better grid lines, highlighting of cells that are affected by an edit action, and underwater terrain that gets colorized based on submergence. There is also a new Changes documentat

Hex Map release 2.1.0 has refactored code and new code documentation. It brings the code up to more modern standards and paves the way for future changes.

Hex Map version 2.0.0 switches from Built-in RP to URP. I also put in the first bit of documentation.

The repository for the Hex Map project is available! At this moment it contains Hex Map version 1.0.0, which is the last unitypackage of Hex Map 27 imported in a Unity 2021 LTS project and cleaned up a bit. The project will progress from there. The first thing planned is switching from built-in to U

I am going to do something new. For a long time I have published tutorial series, which are sequential in nature. In the near future I am going to introduce a project-based approach. This means that I will publish a project/package repository and will add to it incrementally, releasing versions. Why