MY PROJECT PRESENTATION SCRIPT

Optimized Procedural Terrain Generation System

What to say — in your own words

OPENING — Introduce Yourself and Your Project

SAY THIS FIRST:

Good morning/afternoon. My name is Michael Jacob, and my project is
titled: Design and Development of an Optimized Procedural Terrain
Generation System for Resource-Constrained Hardware.
In simple terms, I built a system that can automatically generate realistic
3D outdoor environments — like mountains, valleys, and plains — inside a
game engine, and I made sure it runs smoothly even on computers that are
not very powerful.

TIP: Make eye contact. Speak slowly. Don't rush this part — it sets the tone.

SECTION 1 — The Problem I Was Solving

SAY THIS:
The problem I identified is this: in modern games, creating large open-world
environments usually requires very expensive, high-end hardware. This
makes it difficult for developers and players in places with limited resources
— like many institutions here in Nigeria — to build or enjoy these kinds of
experiences.
So the question I asked was: can we build a terrain generation system that
looks good AND performs well, even on a mid-range or older computer?

TIP: Pause here. Let the question land before you move on.

SECTION 2 — What I Built

SAY THIS:
To answer that question, I built a procedural terrain generation system
using Unity and C#. Procedural means the terrain is created by the
computer using algorithms — mathematical rules — rather than being
designed by hand.
The core of the system uses something called Perlin Noise. Perlin Noise is a
mathematical function that produces smooth, random-looking patterns that
closely resemble natural landscapes. I use it to generate a height map —
basically a grid of numbers where each number tells the system how high or
low the ground should be at that point.
From that height map, the system builds a 3D mesh — the actual shape of
the terrain — and then automatically colours it based on height: blue for
water, yellow for beaches, green for grass, grey for rocks, and white for
snow at the peaks.

TIP: You can gesture up and down with your hand when you describe the height going up and down
— it helps make it visual.

SECTION 3 — How I Made It Run Fast

SAY THIS:
Now, the important part — performance. The key technique I used is called
Level of Detail, or LOD. The idea is simple: things that are far away from the
player don't need to look as detailed as things that are close up. So for
terrain chunks that are nearby, the system generates a high-quality detailed
mesh. For chunks that are far away, it generates a simpler, lower-detail
version. This saves a huge amount of processing power.
I also built an Endless Terrain system. Instead of generating the entire
world at once — which would crash any computer — the system only
generates the terrain chunks that are close to the player. As the player
moves, new chunks are generated just ahead of them, and old ones are
hidden. This is the same approach used in games like Minecraft.
On top of that, I used multi-threading, which means terrain generation
happens in the background without freezing or interrupting the game.

TIP: If they ask 'what is multi-threading?' — say: It means the computer does two things at once — it
keeps running the game on one track, and generates new terrain quietly on another track in the
background.

SECTION 4 — The Components I Built

SAY THIS:
The system is made up of several scripts, each with a specific job:
• [Link] — generates the Perlin Noise height map.
• [Link] — shapes the terrain edges so it looks like a
contained landmass.
• [Link] — turns the height values into an actual 3D mesh,
with LOD support.
• [Link] — the main controller that coordinates everything
and manages the background threads.
• [Link] — handles chunk loading and unloading as the
player moves.
• [Link] and [Link] — handle the visual
appearance and colouring.

TIP: You don't have to memorize all these. Just mention 2 or 3 if asked. MapGenerator,
MeshGenerator, and EndlessTerrain are the most important ones to know.
SECTION 5 — My Results

SAY THIS:
After testing the system, the results were very encouraging. The
unoptimised baseline system — without LOD or threading — ran at around
15 frames per second and had noticeable stuttering when new terrain was
generated.
After applying my optimisations, the system achieved a stable 60 frames per
second, with no stuttering, and significantly lower memory usage. This
confirmed that the LOD and threading approach successfully solved the
performance problem I set out to address.

TIP: If they ask what frames per second means — say: It measures how smoothly the game is
running. 60 FPS is the gold standard for smooth gameplay. Below 30 FPS starts to feel choppy.

CLOSING — Wrap Up Confidently

SAY THIS TO END:

In summary, this project demonstrates that it is entirely possible to build a
high-quality, realistic procedural terrain generation system that runs
efficiently on resource-constrained hardware. By combining Perlin Noise for
generation, Level of Detail for performance, and multi-threading for smooth
delivery, the system achieves both visual quality and hardware efficiency.
I believe this work has real-world relevance, especially in environments
where expensive hardware is not always available. I am happy to take any
questions.

TIP: Smile when you say the last sentence. It shows confidence and signals you know your work
well.

BONUS — Likely Questions & How to Answer Them

Q: What is Perlin Noise?

It is a mathematical algorithm that generates smooth, natural-looking
random patterns. It was invented by Ken Perlin and is widely used in
computer graphics and game development to simulate natural textures like
terrain, clouds, and fire.

Q: Why did you use Unity?

Unity is one of the most widely used game engines in the world, supports
C# natively, has a strong ecosystem for 3D development, and provides
excellent tools for testing performance — which was central to my project.

Q: What is LOD (Level of Detail)?

LOD is a technique where objects that are far from the player are rendered
with fewer triangles and less detail, while nearby objects are rendered with
full detail. This saves significant GPU and CPU resources without the player
noticing a difference in quality.

Q: What are the limitations of your project?

The system currently generates terrain using only Perlin Noise, which
produces natural but somewhat predictable landscapes. Future work could
incorporate biome systems, water simulation, or AI-driven terrain sculpting.
Also, the system was tested on a specific hardware configuration, so
broader testing across more devices would strengthen the findings.

Q: What did you learn from this project?

I learned a great deal about performance optimization, 3D mathematics,
multi-threaded programming, and how game engines work under the hood.
Most importantly, I learned how to identify a real-world problem and build a
technically sound solution to address it.