Build a Hex-Based Planet Generator Engine in Unity & Blender

Create the hex-based sphere that serves as the foundation for the entire planet generation engine. Starting with an icosphere in Blender, you'll learn why a sphere cannot be constructed from perfectly uniform hexagons alone, explore the role of the twelve required pentagonal cells, and use Blender's modeling tools to generate a clean, gap-free mesh that's ready for use in Unity.

Export your Blender model as an FBX and establish an efficient workflow for working between Blender and Unity. You'll learn how to organize your project by separating editable .blend files from the exported game assets, configure important FBX import settings, and understand how Unity treats FBX files as prefab-like objects that can be unpacked and modified throughout development.

Transform the planet mesh into thousands of individual hexagonal and pentagonal cell objects ready for use in Unity. You'll learn how to separate faces into loose parts, assign each cell its own object origin, and prepare the mesh for object placement, procedural generation, and the systems we'll build throughout the rest of the course.

Build the Cell component that serves as the foundation for every polygon on the planet. You'll learn how to use temporary helper scripts to automate repetitive setup tasks, convert mesh normals into rotations, organize each cell into a reusable hierarchy, and store the references and data needed to support procedural terrain generation, asset placement, and the systems developed throughout the remainder of the course.

Create the terrain materials that will define the different regions of your procedural planet. You'll build a reusable material library for water, plains, forests, mountains, and snow, then apply the initial water material to every cell, establishing the starting point for the procedural terrain generation systems developed throughout this section.

Create the core data structures that drive the procedural terrain generation system. You'll define terrain types using a public enum, build the CellData class that stores references for every cell, and learn how enums can be used to efficiently map terrain types to Unity Materials, forming the foundation for the terrain generation algorithms that follow.

Create the first procedural terrain generation algorithm by randomly planting land seeds across the planet. You'll write the SetSeeds() method to select random water cells, convert them into plains, and establish the starting points from which islands and continents will grow in later lectures.

Create a reusable neighbor map for every cell on the planet by automatically discovering and storing neighboring cell indices. You'll write a helper method that analyzes the distance between cells, builds each cell's neighbor list, and prepares the data needed for procedural terrain growth, region generation, and other systems that rely on efficient neighbor lookups.

Create procedurally generated islands by expanding outward from randomly placed land seeds. You'll build an island growth algorithm that identifies neighboring water cells, maintains a dynamic frontier of expandable land, and continues growing each island until the desired land-to-water ratio is reached.

Create a simple development rig that makes it easier to visualize and test your procedural planet throughout the course. You'll build a looping camera orbit animation, smooth the animation for seamless playback, and implement a quick scene reload using Unity's Input System and SceneManager to speed up testing and iteration.

Visualize the procedural terrain generation process by converting the island growth algorithm into a Unity coroutine. You'll control how frequently the algorithm updates, watch continents grow one cell at a time for easier debugging and experimentation, or generate the entire world instantly by disabling the frame delay.

Transform the terrain generation engine into a flexible, data-driven system by building a modular terrain rule framework. You'll replace hard-coded generation logic with reusable terrain rules that define seed counts, coverage, and terrain transitions, making it easy to generate islands, forests, mountains, snow, and entirely new terrain types using the same procedural algorithm.

Create the first low-poly environmental assets for your procedural planet using Blender. In this lecture, you'll model a stylized tree and mountain, establish consistent scale and naming conventions, and prepare reusable assets that will later be duplicated, varied, and placed procedurally throughout the world.

Complete the initial asset library by modeling a low-poly house in Blender, then export your models to Unity and create reusable prefabs for procedural placement. You'll also see how the cell hierarchy automatically aligns objects to the planet's surface, making it easy to position assets upright with a simple transform reset.

Place environmental assets procedurally by extending the terrain generation engine with a modular asset placement system. You'll create reusable terrain asset definitions, control placement density with configurable coverage values, randomly select prefab variations, and automatically orient each asset to the planet's surface during generation.

Refine your low poly assets before creating variations by cleaning up topology, optimizing geometry, correcting scale, and applying a shared color atlas material. You'll learn an efficient workflow for assigning colors with UVs, organize materials for Unity's external material system, and prepare reusable asset templates for procedural generation.

Create multiple house and mountain variants by combining color palette changes with simple mesh edits in Blender. You'll use proportional editing to reshape existing models, expand a small asset library into a diverse collection, and control the rarity of special variants such as snow-capped mountains for more natural procedural generation.

Create natural-looking tree copse variants by combining grouped trees with subtle changes in scale, rotation, color, and composition. You'll learn how to build organic asset clusters, introduce rare features such as boulders to break repetition, and maximize visual variety from a small collection of reusable procedural assets.

Create a separate outline mesh that aligns perfectly with your procedural world. You'll generate clean polygon borders in Blender, prevent z-fighting, configure the FBX for Unity, and prepare independent outline meshes that can be toggled or assigned their own transparent materials.

Merge the outline meshes into your existing cell hierarchy using a temporary helper script that automates the process. You'll wire outline references into each cell, preserve the reusable project structure, and add runtime controls to toggle the grid on and off.

Complete the project by removing temporary helper scripts, consolidating material references into the terrain asset system, and cleaning up the codebase now that the procedural world has been fully constructed.