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 warp value noise with curl noise to make it a lot more interesting. Curled Noise - Procedural GPU Patterns (Catlikecoding)

We're making donuts! This time we adapt value noise so it can tile. This allows us to wrap it seamlessly around a torus. Tiling Noise - Procedural GPU Patterns (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)

Last time we created value noise and now we add analytical derivatives to it, to adjust normal vectors to match a displaced surface. Value Noise Derivatives - Procedural GPU Patterns (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)

In the next step of our Procedural GPU Patterns journey we take our hash noise and turn it into value noise. Value Noise (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.

We bring our fractals alive by adding animation support to them! We animate octaves independently, using temporal lacunarity to scale their animation speed. We also use staggered animation to animate our fractal hash in a more pleasing way. Animating Octaves (Catlikecoding)

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

We can create hashes. We can create fractal wave patterns. Now we combine both to create fractal hashes. To avoid code duplication we introduce a small shader library that isolates and abstracts code that deals with sampling and fractal creation. Hashing (Catlikecoding)

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

We're done with the regular wave patterns. Now we're hashing coordinates to create pseudorandom patterns. We implement a simplified version of the 32-bit xxHash algorithm. We also create float values by directly putting bits in their mantissa. Hashing (Catlikecoding)

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)

We upgrade our wave patterns and turn them into fractals! Regular wave fractals aren't very interesting, but we'll use this foundation for more interesting patterns in the future. Because Procedural GPU Patterns is quite a mouthful I shortened it to PGPUP here. Fractal Waves (Catlikecoding)

We're going back to working on the map, in this case making a small change to how we store the result of pathfinding. It makes upgrading pathfinding in the future easier. Hex Map 5.3.0 (Catlikecoding)

A few days after the first part, we launch part 2! Now we're using both U and V to create more interesting wave patterns. We also add options for per-vertex or per-fragment calculations and for which pattern to show. 2D Waves (Catlikecoding)

The first part of my tutorial series about procedural patterns is here! It's for Godot Engine 4. We start with a sine wave. Seems simple, but then we add displacement and also want good shading, also when applying it to arbitrary surfaces. So we have to cover quite a bit of ground. Sine Waves (Catli

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)

We're messing with the player this time, adding energy barriers that block the player but let movable objects through. We make the barriers wiggle and send pulses along them to make it look interesting. This is the final part of the True Top-Down 2D series. Energy Barriers (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)

This time we make it easier to edit teleporters. They now look the same as when playing the game, both colors and connecting lines, though not pixelated. Teleporter Tooling (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 add a modest pause menu to our game, from which we can either resume playing the current map or restart it. Pausing (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're making things move with conveyors! Let objects and ourselves be pushed around. Conveyors (Catlikecoding)

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)

We move back to working on the maps, adding new features to them, specifically teleporters! The player can teleport itself and movable objects from source to destination areas. When a destination is occupied teleportation is blocked, which can be used for creative level design. Teleporters (Catlikec

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

In previous tutorial we added best scores for completion time and travel time, but they're only visible when we set a new best score. In part 11 we will always shown them, so the player can see how they're doing compared to the previous best performance. Showing Best Scores (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 add more info to our game's HUD. We show the valid and total detector count. We also show the travel distance and keep track of the best one per map. Game HUD (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)

This time we add a simple HUD to our game, showing the current map name and how long the player has been on it. We also keep track of the best map-completion time and show when a new best time is achieved. Game HUD (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)

It's time to add the ability to save and load to our game. This also requires a main menu screen with the option to either start a new game or continue an existing one. Map Transitions (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)

After adding support for multiple maps we now introduce map transition animations. To make this work smoothly we use autoloading, animations, and coroutines. Map Transitions (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

This time we add support for multiple maps to our game. We use a resource-naming scheme to progress between maps, so no explicit lists or map connections required. We also automatically hook up to detectors on a map to detect map completion. Multiple Maps (Catlikecoding)

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

This time we add a new gameplay element: pressure plates that detect when movable objects are on top of them. The idea is that this will enable a win condition that leads to a transition to the next map, but that'll come in the next tutorial. Light and Shadow (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 lighten up our map with a light. We first have to plunge it in darkness though. To get the exact lighting that we want we then proceed to design a custom light. Light and Shadow (Catlikecoding)

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)

This time we give our player character something to interact with: movable objects to push around! We start out with using rigidbodies for the objects, but that doesn't really work well. So we end up making them sort-of player characters too. Movable Objects (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

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)